camstack 0.3.1 → 0.5.1

package/dist/chunk-Y4LXGZZ5.js

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+
+// src/commands/discover.ts
+import * as dgram from "dgram";
+import * as os from "os";
+import { parseArgs } from "util";
+var DEFAULT_MULTICAST_GROUP = "239.0.0.0";
+var DEFAULT_UDP_PORT = 4445;
+var DEFAULT_HUB_HTTPS_PORT = 4443;
+var PACKET_FIELD_COUNT = 3;
+async function discoverNodes(opts) {
+  const namespaceFilter = opts.namespace;
+  const port = opts.udpPort ?? DEFAULT_UDP_PORT;
+  const group = opts.multicastGroup ?? DEFAULT_MULTICAST_GROUP;
+  const timeoutMs = opts.timeoutMs ?? 6e3;
+  const found = /* @__PURE__ */ new Map();
+  const socket = dgram.createSocket({ type: "udp4", reuseAddr: true });
+  await new Promise((resolve, reject) => {
+    socket.once("error", reject);
+    socket.bind(port, () => {
+      try {
+        for (const ip of getInterfaceIPv4Addresses()) {
+          try {
+            socket.addMembership(group, ip);
+          } catch {
+          }
+        }
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
+  });
+  socket.on("message", (data, rinfo) => {
+    const parsed = parsePacket(data.toString("utf8"));
+    if (!parsed) return;
+    if (namespaceFilter !== void 0 && parsed.namespace !== namespaceFilter) return;
+    const key = `${parsed.nodeID}@${rinfo.address}`;
+    if (!found.has(key)) {
+      found.set(key, { nodeID: parsed.nodeID, address: rinfo.address, tcpPort: parsed.tcpPort, namespace: parsed.namespace });
+    }
+  });
+  await new Promise((resolve) => setTimeout(resolve, timeoutMs));
+  socket.close();
+  return Array.from(found.values()).sort((a, b) => a.nodeID.localeCompare(b.nodeID));
+}
+async function resolveHubFromDiscovered(nodes, httpsPort = DEFAULT_HUB_HTTPS_PORT) {
+  const explicitHub = nodes.find((n) => n.nodeID === "hub" || n.nodeID.startsWith("hub-"));
+  const candidates = explicitHub ? [explicitHub] : nodes;
+  for (const node of candidates) {
+    if (await probeHttps(node.address, httpsPort)) {
+      return { address: node.address, port: httpsPort, nodeID: node.nodeID };
+    }
+  }
+  return null;
+}
+function parsePacket(text) {
+  const parts = text.split("|");
+  if (parts.length !== PACKET_FIELD_COUNT) return null;
+  const [ns, id, portStr] = parts;
+  if (typeof ns !== "string" || typeof id !== "string" || typeof portStr !== "string") return null;
+  const tcpPort = parseInt(portStr, 10);
+  if (Number.isNaN(tcpPort)) return null;
+  return { namespace: ns, nodeID: id, tcpPort };
+}
+function getInterfaceIPv4Addresses() {
+  const out = [];
+  const ifaces = os.networkInterfaces();
+  for (const name of Object.keys(ifaces)) {
+    const list = ifaces[name] ?? [];
+    for (const info of list) {
+      if (info.family === "IPv4" && !info.internal) out.push(info.address);
+    }
+  }
+  return out;
+}
+async function probeHttps(host, port) {
+  const { request } = await import("https");
+  return new Promise((resolve) => {
+    const req = request({
+      host,
+      port,
+      method: "HEAD",
+      path: "/trpc/health",
+      timeout: 1500,
+      rejectUnauthorized: false
+    }, (res) => {
+      resolve(typeof res.statusCode === "number");
+      res.resume();
+    });
+    req.on("error", () => resolve(false));
+    req.on("timeout", () => {
+      req.destroy();
+      resolve(false);
+    });
+    req.end();
+  });
+}
+async function runDiscover(args) {
+  const { values } = parseArgs({
+    args: [...args],
+    options: {
+      namespace: { type: "string", short: "n" },
+      timeout: { type: "string", short: "t" },
+      "udp-port": { type: "string" },
+      "multicast-group": { type: "string" },
+      json: { type: "boolean" }
+    },
+    strict: true,
+    allowPositionals: false
+  });
+  const namespace = typeof values.namespace === "string" ? values.namespace : process.env.CAMSTACK_NAMESPACE;
+  const timeoutMs = typeof values.timeout === "string" ? parseInt(values.timeout, 10) * 1e3 : void 0;
+  const udpPort = typeof values["udp-port"] === "string" ? parseInt(values["udp-port"], 10) : void 0;
+  const group = typeof values["multicast-group"] === "string" ? values["multicast-group"] : void 0;
+  const filterLabel = namespace ? `namespace "${namespace}"` : "all namespaces";
+  console.log(`[camstack] Listening for camstack nodes on ${filterLabel} (multicast ${group ?? DEFAULT_MULTICAST_GROUP}:${udpPort ?? DEFAULT_UDP_PORT}, ${(timeoutMs ?? 6e3) / 1e3}s)\u2026`);
+  const nodes = await discoverNodes({
+    ...namespace !== void 0 ? { namespace } : {},
+    ...timeoutMs !== void 0 ? { timeoutMs } : {},
+    ...udpPort !== void 0 ? { udpPort } : {},
+    ...group !== void 0 ? { multicastGroup: group } : {}
+  });
+  if (values.json === true) {
+    console.log(JSON.stringify(nodes, null, 2));
+    return;
+  }
+  if (nodes.length === 0) {
+    console.log("[camstack] No nodes responded. Verify the hub is running with a matching namespace + that you are on the same LAN.");
+    return;
+  }
+  console.log(`[camstack] Found ${nodes.length} node(s):`);
+  const idWidth = Math.max(...nodes.map((n) => n.nodeID.length));
+  const nsWidth = Math.max(...nodes.map((n) => n.namespace.length));
+  for (const n of nodes) {
+    console.log(`  \u2022 ${n.nodeID.padEnd(idWidth)}  ${n.address}  ns=${n.namespace.padEnd(nsWidth)}  (moleculer tcp :${n.tcpPort})`);
+  }
+  if (namespace) {
+    const hub = await resolveHubFromDiscovered(nodes);
+    if (hub) {
+      console.log(``);
+      console.log(`[camstack] Hub HTTPS surface: https://${hub.address}:${hub.port}`);
+      console.log(`[camstack]   \u2192 camstack login -s https://${hub.address}:${hub.port}`);
+    } else {
+      console.log(``);
+      console.log(`[camstack] No node responded on default HTTPS port ${DEFAULT_HUB_HTTPS_PORT}. Pass --server manually.`);
+    }
+  }
+}
+
+export {
+  discoverNodes,
+  resolveHubFromDiscovered,
+  runDiscover
+};

package/dist/cli.js

@@ -1,10 +1,13 @@
 #!/usr/bin/env node
+import {
+  runDiscover
+} from "./chunk-Y4LXGZZ5.js";
 
 // src/cli.ts
 import { createRequire } from "module";
 import { fileURLToPath } from "url";
 import { dirname, resolve as resolve2 } from "path";
-import * as os3 from "os";
+import * as os4 from "os";
 import { parseArgs as parseArgs4 } from "util";
 
 // src/commands/serve.ts
@@ -318,7 +321,7 @@ async function deployAddon(addonPath, opts) {
 import * as fs3 from "fs";
 import * as path3 from "path";
 import * as os2 from "os";
-import * as readline from "readline";
+import * as clack from "@clack/prompts";
 var SESSION_DIR = path3.join(os2.homedir(), ".camstack");
 function sessionFileForServer(serverUrl) {
   const slug = serverUrl.replace(/^https?:\/\//, "").replace(/[:/?#]+/g, "_").replace(/_+$/, "");
@@ -359,49 +362,34 @@ function clearSession(serverUrl) {
   }
   return false;
 }
-function prompt(question, masked = false) {
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve3) => {
-    if (!masked) {
-      rl.question(question, (answer) => {
-        rl.close();
-        resolve3(answer);
-      });
-      return;
-    }
-    process.stdout.write(question);
-    const stdin = process.stdin;
-    let value = "";
-    const onData = (chunk) => {
-      const s = chunk.toString("utf8");
-      for (const ch of s) {
-        if (ch === "\r" || ch === "\n") {
-          stdin.removeListener("data", onData);
-          stdin.setRawMode(false);
-          stdin.pause();
-          rl.close();
-          process.stdout.write("\n");
-          resolve3(value);
-          return;
-        }
-        if (ch === "") {
-          process.exit(130);
-        }
-        if (ch === "\x7F" || ch === "\b") {
-          if (value.length > 0) {
-            value = value.slice(0, -1);
-            process.stdout.write("\b \b");
-          }
-          continue;
-        }
-        value += ch;
-        process.stdout.write("*");
-      }
-    };
-    stdin.setRawMode(true);
-    stdin.resume();
-    stdin.on("data", onData);
+async function askText(message, defaultValue) {
+  const result = await clack.text({
+    message,
+    defaultValue: defaultValue ?? "",
+    placeholder: defaultValue ?? ""
   });
+  if (clack.isCancel(result)) {
+    clack.cancel("Cancelled.");
+    process.exit(130);
+  }
+  return result;
+}
+async function askPassword(message) {
+  const result = await clack.password({ message });
+  if (clack.isCancel(result)) {
+    clack.cancel("Cancelled.");
+    process.exit(130);
+  }
+  return result;
+}
+async function askSelect(message, options) {
+  const mutable = options.map((o) => o.hint ? { value: o.value, label: o.label, hint: o.hint } : { value: o.value, label: o.label });
+  const result = await clack.select({ message, options: mutable });
+  if (clack.isCancel(result)) {
+    clack.cancel("Cancelled.");
+    process.exit(130);
+  }
+  return result;
 }
 async function callTrpcMutation(url, authorization, payload, isPayload) {
   const headers = { "Content-Type": "application/json" };
@@ -411,7 +399,7 @@ async function callTrpcMutation(url, authorization, payload, isPayload) {
     headers,
     body: JSON.stringify({ "0": { json: payload } })
   });
-  const text = await res.text();
+  const text2 = await res.text();
   const parseJson = (raw) => {
     if (!raw) return null;
     try {
@@ -420,9 +408,9 @@ async function callTrpcMutation(url, authorization, payload, isPayload) {
       return raw;
     }
   };
-  const body = parseJson(text);
+  const body = parseJson(text2);
   if (!res.ok) {
-    const errMsg2 = body !== null && typeof body === "object" && "error" in body ? String(body.error) : text.slice(0, 200);
+    const errMsg2 = body !== null && typeof body === "object" && "error" in body ? String(body.error) : text2.slice(0, 200);
     throw new Error(`${res.status} ${res.statusText}: ${errMsg2}`);
   }
   const first = Array.isArray(body) ? body[0] : body;
@@ -453,19 +441,90 @@ function isCreateScopedTokenPayload(value) {
 function isUnknown(_value) {
   return true;
 }
-async function loginCommand(opts) {
-  const server = opts.server;
-  const username = opts.username ?? await prompt(`Username for ${server}: `);
-  const password = opts.password ?? await prompt(`Password: `, true);
-  console.log(`[camstack] Authenticating against ${server}\u2026`);
-  const login = await callTrpcMutation(
-    `${server}/trpc/auth.login?batch=1`,
-    void 0,
-    { username, password },
-    isLoginPayload
+async function resolveServerInteractive(presetNamespace) {
+  const { discoverNodes, resolveHubFromDiscovered } = await import("./discover-NPUMWBRW.js");
+  if (presetNamespace) {
+    const spinner3 = clack.spinner();
+    spinner3.start(`Discovering hub on LAN (namespace "${presetNamespace}")`);
+    const filtered = await discoverNodes({ namespace: presetNamespace });
+    if (filtered.length === 0) {
+      spinner3.stop(`No nodes responded for namespace "${presetNamespace}".`);
+      throw new Error(`Hub running? Same LAN?`);
+    }
+    const hub = await resolveHubFromDiscovered(filtered);
+    if (!hub) {
+      spinner3.stop(`Found ${filtered.length} node(s) but none responded on HTTPS :4443.`);
+      throw new Error("Pass --server explicitly if the hub uses a non-default port.");
+    }
+    spinner3.stop(`Hub: ${hub.nodeID} @ https://${hub.address}:${hub.port}`);
+    return `https://${hub.address}:${hub.port}`;
+  }
+  const spinner2 = clack.spinner();
+  spinner2.start("Scanning LAN for camstack nodes (UDP multicast)");
+  const all = await discoverNodes({});
+  if (all.length === 0) {
+    spinner2.stop("No camstack nodes responded on LAN.");
+    throw new Error("Either pass --server or verify the hub is running on the same network.");
+  }
+  spinner2.stop(`Found ${all.length} node(s).`);
+  const chosen = await askSelect(
+    "Select a hub to log into",
+    all.map((n) => ({
+      value: `${n.address}|${n.tcpPort}|${n.nodeID}|${n.namespace}`,
+      label: `${n.nodeID}  ${n.address}  (ns: ${n.namespace || "(none)"})`,
+      hint: `tcp :${n.tcpPort}`
+    }))
   );
-  const jwt = login.token;
-  const user = login.user;
+  const [addr, , nodeID] = chosen.split("|");
+  const chosenNode = all.find((n) => n.address === addr && n.nodeID === nodeID);
+  const probeSpinner = clack.spinner();
+  probeSpinner.start(`Probing https://${chosenNode.address}:4443`);
+  const probed = await resolveHubFromDiscovered([chosenNode]);
+  if (!probed) {
+    probeSpinner.stop(`Node ${chosenNode.nodeID} at ${chosenNode.address} did not respond on HTTPS :4443.`);
+    throw new Error("Pass --server explicitly if the hub uses a non-default port.");
+  }
+  probeSpinner.stop(`Reachable at https://${probed.address}:${probed.port}`);
+  return `https://${probed.address}:${probed.port}`;
+}
+async function loginCommand(opts) {
+  clack.intro("camstack login");
+  let server = opts.server;
+  if (!server) {
+    server = await resolveServerInteractive(opts.namespace);
+  } else {
+    clack.log.info(`Server: ${server}`);
+  }
+  const username = opts.username ?? await askText("Username", "admin");
+  const MAX_ATTEMPTS = 3;
+  let password2 = opts.password ?? await askPassword("Password");
+  let attempt = 1;
+  let jwt;
+  let displayName;
+  while (true) {
+    const authSpinner = clack.spinner();
+    authSpinner.start(`Authenticating as ${username}${attempt > 1 ? ` (attempt ${attempt}/${MAX_ATTEMPTS})` : ""}`);
+    try {
+      const login = await callTrpcMutation(
+        `${server}/trpc/auth.login?batch=1`,
+        void 0,
+        { username, password: password2 },
+        isLoginPayload
+      );
+      jwt = login.token;
+      displayName = login.user.username;
+      authSpinner.stop(`Authenticated as ${displayName}`);
+      break;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      authSpinner.stop(`Auth failed: ${msg}`);
+      if (opts.password !== void 0 || attempt >= MAX_ATTEMPTS) {
+        throw err;
+      }
+      attempt++;
+      password2 = await askPassword("Password (retry)");
+    }
+  }
   const prior = loadSession(server);
   if (prior && prior.tokenId) {
     try {
@@ -476,10 +535,11 @@ async function loginCommand(opts) {
         isUnknown
       );
     } catch (err) {
-      console.warn(`[camstack] Failed to revoke prior token (${prior.tokenId}): ${err instanceof Error ? err.message : String(err)}`);
+      clack.log.warn(`Failed to revoke prior token (${prior.tokenId}): ${err instanceof Error ? err.message : String(err)}`);
     }
   }
-  console.log(`[camstack] Creating upload-only scoped token\u2026`);
+  const mintSpinner = clack.spinner();
+  mintSpinner.start("Creating upload-only scoped token");
   const tokenName = opts.tokenName ?? `camstack-cli@${os2.hostname()}`;
   const scopes = [{ type: "route-prefix", target: "/api/addons/upload" }];
   const created = await callTrpcMutation(
@@ -490,19 +550,19 @@ async function loginCommand(opts) {
   );
   const scopedToken = created.token;
   const tokenId = created.record.id;
+  mintSpinner.stop(`Token created (${scopedToken.slice(0, 12)}\u2026)`);
   const session = {
     server,
-    username: user.username,
+    username: displayName,
     tokenId,
     token: scopedToken,
     scopes,
     createdAt: Date.now()
   };
   const file = saveSession(session);
-  console.log(`[camstack] \u2713 Logged in as ${user.username} \u2192 ${server}`);
-  console.log(`[camstack]   Scoped token: ${scopedToken.slice(0, 12)}\u2026 (id: ${tokenId})`);
-  console.log(`[camstack]   Cached at:    ${file}`);
-  console.log(`[camstack]   Scope:        upload addons only \u2014 no other API surface granted.`);
+  clack.outro(`\u2713 Logged in as ${displayName} \u2192 ${server}
+  Cached at ${file}
+  Scope: upload addons only`);
 }
 async function logoutCommand(opts) {
   const session = loadSession(opts.server);
@@ -510,6 +570,9 @@ async function logoutCommand(opts) {
     console.log(`[camstack] No active session for ${opts.server}.`);
     return;
   }
+  clack.intro("camstack logout");
+  const spinner2 = clack.spinner();
+  spinner2.start(`Revoking token on ${session.server}`);
   try {
     await callTrpcMutation(
       `${session.server}/trpc/userManagement.revokeScopedToken?batch=1`,
@@ -517,11 +580,12 @@ async function logoutCommand(opts) {
       { id: session.tokenId },
       isUnknown
     );
+    spinner2.stop("Token revoked server-side.");
   } catch (err) {
-    console.warn(`[camstack] Server-side revoke failed (${err instanceof Error ? err.message : String(err)}). Removing local cache anyway.`);
+    spinner2.stop(`Server-side revoke failed (${err instanceof Error ? err.message : String(err)}). Removing local cache anyway.`);
   }
   clearSession(session.server);
-  console.log(`[camstack] \u2713 Logged out of ${session.server}`);
+  clack.outro(`\u2713 Logged out of ${session.server}`);
 }
 function whoamiCommand(opts) {
   const session = loadSession(opts.server);
@@ -537,6 +601,105 @@ function whoamiCommand(opts) {
   console.log(`  createdAt: ${new Date(session.createdAt).toISOString()}`);
 }
 
+// src/update-notifier.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+import * as os3 from "os";
+var CACHE_DIR = path4.join(os3.homedir(), ".camstack");
+var CACHE_FILE = path4.join(CACHE_DIR, "update-check.json");
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var REGISTRY_BASE = "https://registry.npmjs.org";
+var FETCH_TIMEOUT_MS = 2500;
+function readCache() {
+  try {
+    if (!fs4.existsSync(CACHE_FILE)) return null;
+    const parsed = JSON.parse(fs4.readFileSync(CACHE_FILE, "utf8"));
+    if (!parsed || typeof parsed !== "object") return null;
+    const c = parsed;
+    if (typeof c.lastCheckAt !== "number") return null;
+    return {
+      lastCheckAt: c.lastCheckAt,
+      latestVersion: typeof c.latestVersion === "string" ? c.latestVersion : null,
+      lastNotifiedVersion: typeof c.lastNotifiedVersion === "string" ? c.lastNotifiedVersion : null
+    };
+  } catch {
+    return null;
+  }
+}
+function writeCache(c) {
+  try {
+    if (!fs4.existsSync(CACHE_DIR)) fs4.mkdirSync(CACHE_DIR, { recursive: true, mode: 448 });
+    fs4.writeFileSync(CACHE_FILE, JSON.stringify(c, null, 2));
+  } catch {
+  }
+}
+function isNewer(current, latest) {
+  const a = parseSemver(current);
+  const b = parseSemver(latest);
+  if (!a || !b) return false;
+  for (let i = 0; i < 3; i++) {
+    if ((b[i] ?? 0) > (a[i] ?? 0)) return true;
+    if ((b[i] ?? 0) < (a[i] ?? 0)) return false;
+  }
+  return false;
+}
+function parseSemver(v) {
+  const m = v.replace(/^v/, "").split(/[-+]/)[0]?.split(".");
+  if (!m || m.length < 3) return null;
+  const parts = m.map((s) => parseInt(s, 10));
+  if (parts.some(Number.isNaN)) return null;
+  return [parts[0], parts[1], parts[2]];
+}
+async function fetchLatestVersion(pkg) {
+  try {
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), FETCH_TIMEOUT_MS);
+    const res = await fetch(`${REGISTRY_BASE}/${pkg}/latest`, {
+      signal: ac.signal,
+      headers: { accept: "application/json" }
+    });
+    clearTimeout(timer);
+    if (!res.ok) return null;
+    const body = await res.json();
+    return typeof body.version === "string" ? body.version : null;
+  } catch {
+    return null;
+  }
+}
+function maybeNotifyUpdate(pkgName, currentVersion) {
+  if (process.env.CAMSTACK_NO_UPDATE_CHECK || process.env.NO_UPDATE_NOTIFIER) return;
+  if (!process.stdout.isTTY) return;
+  const cache = readCache();
+  const now = Date.now();
+  if (cache?.latestVersion && cache.latestVersion !== cache.lastNotifiedVersion && isNewer(currentVersion, cache.latestVersion)) {
+    printBanner(pkgName, currentVersion, cache.latestVersion);
+    writeCache({ ...cache, lastNotifiedVersion: cache.latestVersion });
+  }
+  const isStale = !cache || now - cache.lastCheckAt > CHECK_INTERVAL_MS;
+  if (isStale) {
+    fetchLatestVersion(pkgName).then((latest) => {
+      if (!latest) return;
+      writeCache({
+        lastCheckAt: Date.now(),
+        latestVersion: latest,
+        lastNotifiedVersion: cache?.lastNotifiedVersion ?? null
+      });
+    }).catch(() => {
+    });
+  }
+}
+function printBanner(pkgName, current, latest) {
+  const lines = [
+    "",
+    `  \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510`,
+    `  \u2502  Update available: ${current} \u2192 ${latest}`.padEnd(60) + "\u2502",
+    `  \u2502  Run: npx ${pkgName}@latest`.padEnd(60) + "\u2502",
+    `  \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518`,
+    ""
+  ];
+  process.stderr.write(lines.join("\n"));
+}
+
 // src/cli.ts
 var __dirname = dirname(fileURLToPath(import.meta.url));
 var require2 = createRequire(import.meta.url);
@@ -619,11 +782,32 @@ function buildCommands() {
       help: () => [
         "Usage: camstack login [options]",
         "",
+        "Default flow (no flags): scans the LAN for camstack nodes via UDP multicast,",
+        "  prompts you to pick one (arrow-key list), then user + password.",
+        "",
         "Options:",
-        "  -s, --server <url>     CamStack server URL (default: $CAMSTACK_SERVER or https://localhost:4443)",
+        "  -s, --server <url>     Skip discovery, use this URL directly ($CAMSTACK_SERVER)",
+        "  -n, --namespace <ns>   Skip the interactive picker \u2014 auto-resolves the hub for this namespace ($CAMSTACK_NAMESPACE)",
         "  -u, --username <name>  Username (skips prompt)",
         "  -p, --password <pwd>   Password (skips prompt \u2014 prefer letting the CLI prompt)",
-        `  --token-name <name>    Name shown server-side (default: camstack-cli@${os3.hostname()})`
+        `  --token-name <name>    Name shown server-side (default: camstack-cli@${os4.hostname()})`
+      ].join("\n")
+    },
+    {
+      name: "discover",
+      summary: "Probe the LAN for camstack hubs/agents via UDP multicast",
+      run: runDiscover,
+      help: () => [
+        "Usage: camstack discover [options]",
+        "",
+        "With no flags: lists every camstack node visible on the LAN (any namespace).",
+        "",
+        "Options:",
+        "  -n, --namespace <ns>      Filter results to one namespace ($CAMSTACK_NAMESPACE)",
+        "  -t, --timeout <seconds>   Listen window (default: 6)",
+        "  --udp-port <port>         UDP discovery port (default: 4445)",
+        "  --multicast-group <ip>    Multicast group (default: 239.0.0.0)",
+        "  --json                    Emit JSON instead of human-readable list"
       ].join("\n")
     },
     {
@@ -673,10 +857,10 @@ function buildCommands() {
       summary: "Print detailed version and platform info",
       run: () => {
         console.log(`camstack v${pkgVersion}`);
-        console.log(`Platform: ${os3.platform()}-${os3.arch()}`);
+        console.log(`Platform: ${os4.platform()}-${os4.arch()}`);
         console.log(`Node.js: ${process.version}`);
-        console.log(`CPU: ${os3.cpus()[0]?.model ?? "unknown"} (${os3.cpus().length} cores)`);
-        console.log(`Memory: ${Math.round(os3.totalmem() / 1024 / 1024)} MB`);
+        console.log(`CPU: ${os4.cpus()[0]?.model ?? "unknown"} (${os4.cpus().length} cores)`);
+        console.log(`Memory: ${Math.round(os4.totalmem() / 1024 / 1024)} MB`);
       },
       help: () => "Usage: camstack info"
     }
@@ -698,6 +882,7 @@ function parseSubcommandArgs(args, options, allowPositionals) {
 async function runLogin(args) {
   const parsed = parseSubcommandArgs(args, {
     server: { type: "string", short: "s" },
+    namespace: { type: "string", short: "n" },
     username: { type: "string", short: "u" },
     password: { type: "string", short: "p" },
     "token-name": { type: "string" }
@@ -706,9 +891,11 @@ async function runLogin(args) {
     console.log(commandHelp("login"));
     return;
   }
-  const server = stringOpt(parsed.values, "server") ?? process.env.CAMSTACK_SERVER ?? "https://localhost:4443";
+  const explicitServer = stringOpt(parsed.values, "server") ?? process.env.CAMSTACK_SERVER;
+  const namespace = stringOpt(parsed.values, "namespace") ?? process.env.CAMSTACK_NAMESPACE;
   await loginCommand({
-    server,
+    ...explicitServer ? { server: explicitServer } : {},
+    ...namespace ? { namespace } : {},
     ...optionalString(parsed.values, "username"),
     ...optionalString(parsed.values, "password"),
     ...optionalString(parsed.values, "token-name", "tokenName")
@@ -785,6 +972,7 @@ function optionalString(values, key, outKey) {
   return { [outKey ?? key]: v };
 }
 async function main() {
+  maybeNotifyUpdate("camstack", pkgVersion);
   const argv = process.argv.slice(2);
   const commands = buildCommands();
   if (argv.length === 0 || argv.length === 1 && HELP_FLAGS.has(argv[0] ?? "")) {
@@ -802,8 +990,13 @@ async function main() {
     console.error("Run `camstack --help` for the list of commands.");
     process.exit(1);
   }
+  const subArgs = argv.slice(1);
+  if (subArgs.some((a) => HELP_FLAGS.has(a))) {
+    console.log(cmd.help());
+    return;
+  }
   try {
-    await cmd.run(argv.slice(1));
+    await cmd.run(subArgs);
   } catch (err) {
     console.error(`[camstack] ${cmd.name} failed:`, errMsg(err));
     process.exit(1);

package/dist/discover-NPUMWBRW.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import {
+  discoverNodes,
+  resolveHubFromDiscovered,
+  runDiscover
+} from "./chunk-Y4LXGZZ5.js";
+export {
+  discoverNodes,
+  resolveHubFromDiscovered,
+  runDiscover
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "camstack",
-  "version": "0.3.1",
+  "version": "0.5.1",
   "description": "CLI tool for managing and running CamStack server",
   "keywords": [
     "camstack",
@@ -40,5 +40,8 @@
     "tsup": "^8.5.1",
     "typescript": "^5.7.0",
     "vitest": "^3.0.0"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.3.0"
   }
 }