camstack 1.2.182 → 1.2.184

package/dist/cli.js

@@ -2,7 +2,7 @@
 import {
   FFMPEG_PATH_ENV,
   runDiscover
-} from "./chunk-6MF6DVWI.js";
+} from "./chunk-CTW2RQUZ.js";
 import "./chunk-LMMQX4CK.js";
 
 // src/cli.ts
@@ -39,7 +39,7 @@ async function runServe(args) {
     ...typeof values.data === "string" ? { data: values.data } : {}
   };
   Object.assign(process.env, buildServeEnv(opts));
-  await import("./launcher-NLPEFFVF.js");
+  await import("./launcher-DYASWHKK.js");
 }
 
 // src/commands/agent.ts
@@ -84,7 +84,7 @@ async function runAgent(args) {
     ...typeof values.port === "string" ? { port: values.port } : {}
   };
   Object.assign(process.env, buildAgentEnv(opts));
-  await import("./launcher-NLPEFFVF.js");
+  await import("./launcher-DYASWHKK.js");
 }
 
 // src/commands/setup.ts
@@ -954,6 +954,8 @@ function unwrapTrpcJson(body) {
   return data["json"];
 }
 async function applyServerUpdate(args) {
+  const payload = { version: args.version };
+  if (args.nodeId !== void 0) payload.nodeId = args.nodeId;
   const res = await hubRequest(
     `${args.serverUrl}/trpc/serverManagement.applyServerUpdate?batch=1`,
     {
@@ -962,7 +964,7 @@ async function applyServerUpdate(args) {
         Authorization: `Bearer ${args.token}`,
         "Content-Type": "application/json"
       },
-      body: JSON.stringify({ "0": { json: { version: args.version } } }),
+      body: JSON.stringify({ "0": { json: payload } }),
       timeoutMs: APPLY_TIMEOUT_MS
     }
   );
@@ -994,8 +996,8 @@ function toStatusView(value) {
     rolledBackReason: isRecord2(rolledBack) && typeof rolledBack["reason"] === "string" ? rolledBack["reason"] : null
   };
 }
-async function fetchServerStatus(serverUrl, token) {
-  const url = serverPackageStatusUrl(serverUrl);
+async function fetchServerStatus(serverUrl, token, nodeId) {
+  const url = serverPackageStatusUrl(serverUrl, nodeId);
   const res = await hubRequest(url, {
     headers: { Authorization: `Bearer ${token}` },
     timeoutMs: 1e4
@@ -1004,27 +1006,73 @@ async function fetchServerStatus(serverUrl, token) {
   const body = await res.json().catch(() => null);
   return toStatusView(unwrapTrpcJson(body));
 }
-function serverPackageStatusUrl(serverUrl) {
-  return `${serverUrl}/trpc/serverManagement.getServerPackageStatus?input=${encodeURIComponent('{"json":{}}')}`;
+function serverPackageStatusUrl(serverUrl, nodeId) {
+  const input = nodeId === void 0 ? '{"json":{}}' : JSON.stringify({ json: { nodeId } });
+  return `${serverUrl}/trpc/serverManagement.getServerPackageStatus?input=${encodeURIComponent(input)}`;
+}
+async function fetchOnlineAgentIds(serverUrl, token) {
+  const url = `${serverUrl}/trpc/nodes.topology?input=${encodeURIComponent('{"json":{}}')}`;
+  const res = await hubRequest(url, {
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  if (!res.ok) {
+    throw new Error(
+      `nodes.topology returned ${res.status}: ${await res.text().catch(() => res.statusText)}`
+    );
+  }
+  const body = await res.json();
+  if (body.error) {
+    throw new Error(`nodes.topology failed: ${body.error.json?.message ?? "unknown error"}`);
+  }
+  const nodes = body.result?.data?.json;
+  if (!Array.isArray(nodes)) {
+    throw new Error(
+      "nodes.topology returned no node list \u2014 refusing to assume the cluster is empty"
+    );
+  }
+  return nodes.filter((n) => n.isOnline && !n.isHub).map((n) => n.id);
+}
+async function propagateDevUploads(args) {
+  const response = await hubRequest(`${args.serverUrl}/api/server-upload/propagate`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${args.token}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ version: args.version, nodeId: args.nodeId }),
+    timeoutMs: UPLOAD_TIMEOUT_MS
+  });
+  const payload = await response.json().catch(() => ({}));
+  if (!response.ok || !isRecord2(payload) || payload["success"] !== true) {
+    const detail = isRecord2(payload) && typeof payload["error"] === "string" ? payload["error"] : `${response.status} ${response.statusText}`;
+    throw new Error(
+      withAuthHint(
+        `propagate to ${args.nodeId} rejected: ${detail}`,
+        response.status,
+        args.authSource
+      )
+    );
+  }
 }
 async function pollUntilPromoted(args) {
+  const label = args.label ?? args.nodeId ?? "hub";
   const deadline = Date.now() + POLL_BUDGET_MS;
   let lastState = "";
   while (Date.now() < deadline) {
     let status = null;
     try {
-      status = await fetchServerStatus(args.serverUrl, args.token);
+      status = await fetchServerStatus(args.serverUrl, args.token, args.nodeId);
     } catch {
     }
     if (status !== null) {
       const stateLine = `${status.updateState} (running ${status.runningVersion ?? "?"})`;
       if (stateLine !== lastState) {
-        console.log(`[camstack]   state: ${stateLine}`);
+        console.log(`[camstack]   ${label}: ${stateLine}`);
         lastState = stateLine;
       }
       if (status.rolledBackFrom === args.version) {
         throw new Error(
-          `Dev version ${args.version} was ROLLED BACK: ${status.rolledBackReason ?? "probation boot failed"}`
+          `${label}: dev version ${args.version} was ROLLED BACK: ${status.rolledBackReason ?? "probation boot failed"}`
         );
       }
       if (status.runningVersion === args.version && status.updateState === "idle") {
@@ -1034,7 +1082,7 @@ async function pollUntilPromoted(args) {
     await sleep2(POLL_INTERVAL_MS);
   }
   throw new Error(
-    `Timed out after ${POLL_BUDGET_MS / 6e4} minutes waiting for ${args.version} to promote \u2014 check \`serverManagement.getServerPackageStatus\` on the hub.`
+    `Timed out after ${POLL_BUDGET_MS / 6e4} minutes waiting for ${args.version} to promote on ${label} \u2014 check \`serverManagement.getServerPackageStatus\`.`
   );
 }
 function printClosure(closure) {
@@ -1043,7 +1091,104 @@ function printClosure(closure) {
   );
   for (const pkg of closure.packSet) console.log(`[camstack]   \u2022 ${pkg.name}`);
 }
+async function applyAndMaybeVerify(args) {
+  const { opts, version, nodeId, label } = args;
+  const apply = await applyServerUpdate({
+    serverUrl: opts.serverUrl,
+    token: opts.token,
+    version,
+    ...nodeId !== void 0 ? { nodeId } : {},
+    ...opts.authSource ? { authSource: opts.authSource } : {}
+  });
+  if (!apply.accepted) {
+    if (apply.message.includes("already running")) {
+      console.log(`[camstack] \u2713 ${label}: already on ${version}`);
+      return "ok";
+    }
+    console.error(`[camstack] \u2717 ${label}: ${apply.message}`);
+    return "failed";
+  }
+  console.log(`[camstack] \u2713 ${label}: ${apply.message}`);
+  if (opts.verify === false) return "ok";
+  await pollUntilPromoted({
+    serverUrl: opts.serverUrl,
+    token: opts.token,
+    version,
+    ...nodeId !== void 0 ? { nodeId } : {},
+    label
+  });
+  console.log(`[camstack] \u2713 ${label}: ${version} promoted`);
+  return "ok";
+}
+async function fanOutToAgents(opts, version) {
+  let agentTargets = opts.nodeIds ?? [];
+  if (opts.allAgents === true) {
+    console.log("[camstack] Enumerating online agents via nodes.topology...");
+    agentTargets = await fetchOnlineAgentIds(opts.serverUrl, opts.token);
+    if (agentTargets.length === 0) {
+      console.log("[camstack] No online agents \u2014 hub-only deploy complete");
+      return;
+    }
+    console.log(`[camstack] Agents: ${agentTargets.join(", ")}`);
+  }
+  if (agentTargets.length === 0) return;
+  const failures = [];
+  for (const nodeId of agentTargets) {
+    try {
+      console.log(`[camstack] Propagating dev-uploads \u2192 ${nodeId}...`);
+      await propagateDevUploads({
+        serverUrl: opts.serverUrl,
+        token: opts.token,
+        version,
+        nodeId,
+        ...opts.authSource ? { authSource: opts.authSource } : {}
+      });
+      console.log(`[camstack] \u2713 ${nodeId}: uploads staged`);
+      console.log(`[camstack] Applying server update on ${nodeId}...`);
+      const outcome = await applyAndMaybeVerify({
+        opts,
+        version,
+        nodeId,
+        label: nodeId
+      });
+      if (outcome === "failed") failures.push(`${nodeId}: apply refused`);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      failures.push(`${nodeId}: ${message}`);
+      console.error(`[camstack] \u2717 ${nodeId}: ${message}`);
+    }
+  }
+  if (failures.length > 0) {
+    console.error(
+      `[camstack] \u2717 Agent fan-out incomplete (${failures.length}/${agentTargets.length} failed):`
+    );
+    for (const line of failures) console.error(`[camstack]   \u2022 ${line}`);
+    process.exit(1);
+  }
+  console.log(`[camstack] \u2713 Dev closure ${version} on hub + ${agentTargets.length} agent(s)`);
+}
 async function deployServer(opts) {
+  const existing = opts.existingVersion?.trim();
+  if (existing !== void 0 && existing.length > 0) {
+    if (!/-dev\.\d+$/.test(existing)) {
+      console.error(
+        `[camstack] \u2717 --version must be a dev-channel version (<base>-dev.<epoch>), got: ${existing}`
+      );
+      process.exit(1);
+    }
+    console.log(
+      `[camstack] Reusing hub upload ${existing} (skip build/pack/upload) \u2014 POST /api/server-upload/propagate + apply`
+    );
+    console.log(`[camstack] Applying server update to hub (${existing})...`);
+    const hubOutcome = await applyAndMaybeVerify({
+      opts,
+      version: existing,
+      label: "hub"
+    });
+    if (hubOutcome === "failed") process.exit(1);
+    await fanOutToAgents(opts, existing);
+    return;
+  }
   const workspaceRoot = path4.resolve(opts.workspaceRoot ?? ".");
   const closure = discoverServerClosure(workspaceRoot);
   printClosure(closure);
@@ -1071,24 +1216,13 @@ async function deployServer(opts) {
     });
     console.log("[camstack] \u2713 Upload accepted");
     console.log(`[camstack] Applying server update to ${devVersion}...`);
-    const apply = await applyServerUpdate({
-      serverUrl: opts.serverUrl,
-      token: opts.token,
+    const hubOutcome = await applyAndMaybeVerify({
+      opts,
       version: devVersion,
-      ...opts.authSource ? { authSource: opts.authSource } : {}
+      label: "hub"
     });
-    if (!apply.accepted) {
-      console.error(`[camstack] \u2717 applyServerUpdate refused: ${apply.message}`);
-      process.exit(1);
-    }
-    console.log(`[camstack] \u2713 ${apply.message}`);
-    if (opts.verify === false) {
-      console.log("[camstack] --no-verify: not waiting for promotion (probation boot in progress)");
-      return;
-    }
-    console.log("[camstack] Waiting for the probation boot to promote...");
-    await pollUntilPromoted({ serverUrl: opts.serverUrl, token: opts.token, version: devVersion });
-    console.log(`[camstack] \u2713 ${devVersion} promoted \u2014 the hub is running the dev closure`);
+    if (hubOutcome === "failed") process.exit(1);
+    await fanOutToAgents(opts, devVersion);
   } finally {
     fs5.rmSync(outDir, { recursive: true, force: true });
   }
@@ -1236,7 +1370,7 @@ function isUnknown(_value) {
   return true;
 }
 async function resolveServerInteractive(presetNamespace) {
-  const { discoverNodes, resolveHubFromDiscovered, filterHubNodes, DEFAULT_HUB_HTTPS_PORT } = await import("./discover-PYV6JHPO.js");
+  const { discoverNodes, resolveHubFromDiscovered, filterHubNodes, DEFAULT_HUB_HTTPS_PORT } = await import("./discover-TF6TGNJS.js");
   if (presetNamespace) {
     const spinner4 = clack.spinner();
     spinner4.start(`Discovering hub on LAN (namespace "${presetNamespace}")`);
@@ -2437,52 +2571,59 @@ function buildCommands() {
     {
       name: "deploy",
       aliases: ["push"],
-      summary: "Build and deploy an addon to a CamStack server (hub by default, or cluster-wide)",
+      summary: "Deploy an addon, or (with --closure) the @camstack/server workspace closure on the dev channel",
       run: runDeploy,
       help: () => [
         "Usage: camstack deploy [options] [path]",
         "       camstack push   [options] [path]    (alias)",
+        "       camstack deploy --closure [options]  (server closure, no addon path)",
         "",
         "Argument:",
         '  path                    Path to addon dir, .tgz, or workspace name (e.g. "tailscale")',
-        '                          Default: "." (current dir)',
+        '                          Default: "." (current dir). Ignored with --closure.',
+        "",
+        "Server closure (dev channel, no npm publish):",
+        "      --closure           Build+pack+upload @camstack/server closure, then apply",
+        "      --version <ver>     With --closure: reuse hub upload <base>-dev.<epoch>",
+        "                          (skip build/pack/upload; propagate+apply only)",
         "",
-        "Build (only when path is a directory):",
+        "Build (addon path only):",
         "  -b, --build <mode>      `auto` (default \u2014 run build if declared),",
         "                          `force` (require + run), or `skip`",
         "      --no-build          Equivalent to --build skip",
         "      --build-script <n>  npm script name (default: build)",
-        "      --no-verify         Skip the post-deploy hub /health gate",
+        "      --no-verify         Skip post-deploy verify / promotion poll",
         "",
-        "Target options:",
-        "  -s, --server <url>      Server URL (default: $CAMSTACK_SERVER, then the cached session)",
+        "Target options (addon and --closure):",
+        "  -s, --server <url>      Hub URL (default: $CAMSTACK_SERVER, then the cached session)",
         "  -t, --token <token>     Auth token override",
         "      --token-file <path> Read the token from a file (bare token or a ~/.camstack session file)",
-        "  -n, --node <id>         Push to a specific node. Mutually exclusive with --cluster",
-        "  -c, --cluster           Push to hub + every online agent (requires admin token)",
+        "  -n, --node <id>         Target one agent. Mutually exclusive with --cluster",
+        "  -c, --cluster           Every online agent (and hub for addons; hub then agents for --closure)",
+        "",
+        "Note: -s/--server is the hub URL. Use --closure for the server package.",
         "",
         TOKEN_RESOLUTION_HELP
       ].join("\n")
     },
     {
       name: "deploy-server",
-      summary: "Dev channel: build + pack the whole @camstack/server workspace closure, upload it, and apply it via the same stage/probation/promote cycle (no npm publish)",
+      summary: "Alias of `camstack deploy --closure` (dev server-deploy channel)",
       run: runDeployServer,
       help: () => [
         "Usage: camstack deploy-server [options]",
         "",
-        "Run from the camstack-server workspace root. Discovers every workspace",
-        "  @camstack/* package in the @camstack/server dependency closure (graph-driven),",
-        "  builds them in dependency order, packs them at one uniform dev version",
-        "  (<serverBase>-dev.<epochSeconds>), uploads the tarballs to the hub",
-        "  (POST /api/server-upload), then applies via serverManagement.applyServerUpdate",
-        "  and waits for the probation boot to promote.",
+        "Deprecated alias of `camstack deploy --closure`. Prefer that form.",
         "",
         "Options:",
-        "  -s, --server <url>     Server URL (default: $CAMSTACK_SERVER, then the cached session)",
+        "  -s, --server <url>     Hub URL",
         "  -t, --token <token>    Auth token override",
-        "      --token-file <path> Read the token from a file (bare token or a ~/.camstack session file)",
-        "      --no-verify        Do not wait for promotion after applyServerUpdate is accepted",
+        "      --token-file <path> Read the token from a file",
+        "  -n, --node <id>        Propagate+apply on this agent. Mutually exclusive with --cluster/--all",
+        "  -c, --cluster          Propagate+apply on every online agent",
+        "      --all              Legacy alias of --cluster",
+        "      --version <ver>    Reuse hub upload (skip build/pack/upload)",
+        "      --no-verify        Do not wait for promotion",
         "",
         TOKEN_RESOLUTION_HELP
       ].join("\n")
@@ -2658,6 +2799,25 @@ async function runWhoami(args) {
   const server = stringOpt(parsed.values, "server");
   await whoamiCommand(server ? { server } : {});
 }
+function resolveClosureDeployOpts(values) {
+  const nodeId = stringOpt(values, "node");
+  const cluster = boolOpt(values, "cluster") || boolOpt(values, "all");
+  if (cluster && nodeId) {
+    console.error("[camstack] Error: --node and --cluster/--all are mutually exclusive.");
+    process.exit(1);
+  }
+  const version = stringOpt(values, "version");
+  const creds = resolveCommandCredentials(values);
+  return {
+    serverUrl: creds.server ?? DEFAULT_SERVER_URL,
+    token: creds.token,
+    authSource: creds.source,
+    verify: !boolOpt(values, "no-verify"),
+    ...nodeId ? { nodeIds: [nodeId] } : {},
+    ...cluster ? { allAgents: true } : {},
+    ...version ? { existingVersion: version } : {}
+  };
+}
 async function runDeploy(args) {
   const parsed = parseSubcommandArgs(
     args,
@@ -2667,6 +2827,8 @@ async function runDeploy(args) {
       "token-file": { type: "string" },
       node: { type: "string", short: "n" },
       cluster: { type: "boolean", short: "c" },
+      closure: { type: "boolean" },
+      version: { type: "string" },
       build: { type: "string", short: "b" },
       "build-script": { type: "string" },
       "no-build": { type: "boolean" },
@@ -2678,6 +2840,18 @@ async function runDeploy(args) {
     console.log(commandHelp("deploy"));
     return;
   }
+  if (boolOpt(parsed.values, "closure")) {
+    if (stringOpt(parsed.values, "build") || boolOpt(parsed.values, "no-build")) {
+      console.error("[camstack] Error: --closure does not take addon --build / --no-build flags.");
+      process.exit(1);
+    }
+    await deployServer(resolveClosureDeployOpts(parsed.values));
+    return;
+  }
+  if (stringOpt(parsed.values, "version")) {
+    console.error("[camstack] Error: --version requires --closure (server closure reuse).");
+    process.exit(1);
+  }
   const addonPath = parsed.positionals[0] ?? ".";
   const creds = resolveCommandCredentials(parsed.values);
   const server = creds.server ?? DEFAULT_SERVER_URL;
@@ -2718,6 +2892,10 @@ async function runDeployServer(args) {
       server: { type: "string", short: "s" },
       token: { type: "string", short: "t" },
       "token-file": { type: "string" },
+      node: { type: "string", short: "n" },
+      cluster: { type: "boolean", short: "c" },
+      all: { type: "boolean" },
+      version: { type: "string" },
       "no-verify": { type: "boolean" }
     },
     false
@@ -2726,13 +2904,8 @@ async function runDeployServer(args) {
     console.log(commandHelp("deploy-server"));
     return;
   }
-  const creds = resolveCommandCredentials(parsed.values);
-  await deployServer({
-    serverUrl: creds.server ?? DEFAULT_SERVER_URL,
-    token: creds.token,
-    authSource: creds.source,
-    verify: !boolOpt(parsed.values, "no-verify")
-  });
+  console.log("[camstack] note: `deploy-server` is an alias of `deploy --closure`");
+  await deployServer(resolveClosureDeployOpts(parsed.values));
 }
 var DEFAULT_SERVER_URL = "https://localhost:4443";
 function resolveCommandCredentials(values) {

package/dist/{discover-PYV6JHPO.js → discover-TF6TGNJS.js}

@@ -5,7 +5,7 @@ import {
   filterHubNodes,
   resolveHubFromDiscovered,
   runDiscover
-} from "./chunk-6MF6DVWI.js";
+} from "./chunk-CTW2RQUZ.js";
 import "./chunk-LMMQX4CK.js";
 export {
   DEFAULT_HUB_HTTPS_PORT,