mDNS Discovery

# Without mDNS - need to know IP address
gambiarra join ABC123 --hub http://192.168.1.100:3000

# With mDNS - automatic discovery
gambiarra join ABC123  # Finds hub automatically

# Enable mDNS with --mdns flag
gambiarra serve --port 3000 --mdns

import { hub } from "gambiarra-sdk";

const myHub = await hub.create({
  port: 3000,
  mdns: true  // Enable mDNS
});

console.log(`Hub published as: ${myHub.mdnsName}`);
// Output: Hub published as: gambiarra-hub-3000

import { createHub } from "@gambiarra/core/hub";

const myHub = createHub({
  port: 3000,
  hostname: "0.0.0.0",
  mdns: true
});

console.log(`mDNS name: ${myHub.mdnsName}`);

gambiarra-hub-{port}._gambiarra._tcp.local

mDNS.publish({
  name: `gambiarra-hub-${port}`,
  port,
  txt: {
    version: "1.0",
    protocol: "http"
  }
});

import { mDNS } from "@gambiarra/core/mdns";

// Start browsing for Gambiarra services
const stopBrowsing = mDNS.browse((service) => {
  console.log(`Found hub: ${service.name}`);
  console.log(`  Port: ${service.port}`);
  console.log(`  Version: ${service.txt.version}`);
  console.log(`  Protocol: ${service.txt.protocol}`);
});

// Stop browsing when done
stopBrowsing();

Found hub: gambiarra-hub-3000
  Port: 3000
  Version: 1.0
  Protocol: http

import { mDNS } from "@gambiarra/core/mdns";

function discoverHub(): Promise<string> {
  return new Promise((resolve, reject) => {
    const timeout = setTimeout(() => {
      stopBrowsing();
      reject(new Error("No hub found within 5 seconds"));
    }, 5000);

    const stopBrowsing = mDNS.browse((service) => {
      clearTimeout(timeout);
      stopBrowsing();
      
      // Resolve to hub URL
      const hubUrl = `http://localhost:${service.port}`;
      resolve(hubUrl);
    });
  });
}

// Use it
const hubUrl = await discoverHub();
console.log(`Connecting to ${hubUrl}`);

import Bonjour from "bonjour-service";

const instance = new Bonjour();

const service = instance.publish({
  name: "gambiarra-hub-3000",
  type: "gambiarra",
  port: 3000,
  txt: { version: "1.0", protocol: "http" }
});

export function unpublish(name: string): boolean {
  const service = publishedServices.get(name);
  if (service) {
    if (service.stop) {
      service.stop();
    }
    publishedServices.delete(name);
    return true;
  }
  return false;
}

close: () => {
  clearInterval(healthInterval);
  if (mdnsName) {
    mDNS.unpublish(mdnsName);  // Stop broadcasting
  }
  Room.clear();
  SSE.closeAll();
  server.stop();
}

// Hub 1
const hub1 = createHub({ port: 3000, mdns: true });
// Published as: gambiarra-hub-3000

// Hub 2 - use different port
const hub2 = createHub({ port: 3001, mdns: true });
// Published as: gambiarra-hub-3001

const myHub = createHub({ port: 3000, mdns: true });

// Always close the hub when done
process.on("SIGINT", () => {
  myHub.close();  // This unpublishes mDNS
  process.exit(0);
});

# Fallback to manual IP when mDNS fails
gambiarra join ABC123 --hub http://192.168.1.100:3000

# Run hub with host network
docker run --network host gambiarra-hub

# docker-compose.yml
services:
  hub:
    image: gambiarra-hub
    ports:
      - "3000:3000"
      - "5353:5353/udp"  # mDNS

# Browse for Gambiarra services
dns-sd -B _gambiarra._tcp local.

# Resolve a specific service
dns-sd -L gambiarra-hub-3000 _gambiarra._tcp local.

# Browse all services
avahi-browse -a

# Browse Gambiarra services
avahi-browse -rt _gambiarra._tcp

import { mDNS } from "@gambiarra/core/mdns";

// Test publishing
const service = mDNS.publish({
  name: "test-hub",
  port: 9999,
  txt: { test: "true" }
});

console.log("Published test-hub on port 9999");

// Test browsing
const stopBrowsing = mDNS.browse((service) => {
  if (service.name === "test-hub") {
    console.log("✅ Found test-hub!");
    console.log(service);
    stopBrowsing();
  }
});

// Cleanup after 5 seconds
setTimeout(() => {
  mDNS.unpublish("test-hub");
  console.log("Unpublished test-hub");
}, 5000);

import { mDNS } from "@gambiarra/core/mdns";

mDNS.publish({
  name: "my-custom-service",
  type: "myapp",  // Custom type
  port: 8080,
  txt: {
    version: "2.0",
    features: "chat,rooms"
  }
});

// Browse for custom type
const stopBrowsing = mDNS.browse({
  type: "myapp"
}, (service) => {
  console.log("Found myapp service:", service);
});

import { mDNS } from "@gambiarra/core/mdns";

const discoveredHubs = [];

const stopBrowsing = mDNS.browse((service) => {
  discoveredHubs.push({
    name: service.name,
    url: `http://localhost:${service.port}`,
    metadata: service.txt
  });
});

// Wait 3 seconds to discover all hubs
await new Promise(resolve => setTimeout(resolve, 3000));
stopBrowsing();

console.log(`Found ${discoveredHubs.length} hubs:`);
discoveredHubs.forEach(hub => {
  console.log(`  ${hub.name}: ${hub.url}`);
});

import { mDNS } from "@gambiarra/core/mdns";

async function findHealthyHub(): Promise<string> {
  return new Promise((resolve, reject) => {
    const stopBrowsing = mDNS.browse(async (service) => {
      const hubUrl = `http://localhost:${service.port}`;
      
      try {
        // Check if hub is healthy
        const response = await fetch(`${hubUrl}/health`);
        if (response.ok) {
          stopBrowsing();
          resolve(hubUrl);
        }
      } catch (error) {
        console.warn(`Hub ${service.name} not responding`);
      }
    });
    
    setTimeout(() => {
      stopBrowsing();
      reject(new Error("No healthy hub found"));
    }, 5000);
  });
}

import { mDNS } from "@gambiarra/core/mdns";

// Publish a service
const service = mDNS.publish({
  name: string,
  port: number,
  type?: string,  // default: "gambiarra"
  txt?: Record<string, string>
});

// Unpublish a service
mDNS.unpublish(name: string): boolean

// Browse for services
const stopBrowsing = mDNS.browse(
  callback: (service: DiscoveredService) => void
): () => void

// Cleanup all services
mDNS.destroy(): void

interface DiscoveredService {
  name: string;                    // Service name
  port: number;                    // Port number
  txt: Record<string, string>;     // TXT records
}