camstack 1.1.21 → 1.1.23

package/dist/cli.js

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 import {
   runDiscover
-} from "./chunk-VL5TLTQF.js";
+} from "./chunk-ODEV2JIB.js";
 import "./chunk-K3NQKI34.js";
 
 // src/cli.ts
 import { createRequire } from "module";
 import { fileURLToPath } from "url";
-import { dirname, resolve as resolve3 } from "path";
-import * as os4 from "os";
+import { dirname, resolve as resolve5 } from "path";
+import * as os5 from "os";
 import { parseArgs as parseArgs7 } from "util";
 
 // src/commands/serve.ts
@@ -151,7 +151,7 @@ function hubRequest(url, opts = {}) {
   const parsed = new URL(url);
   const isHttps = parsed.protocol === "https:";
   const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve6, reject) => {
     const requestOptions = {
       protocol: parsed.protocol,
       hostname: parsed.hostname,
@@ -168,7 +168,7 @@ function hubRequest(url, opts = {}) {
       res.on("end", () => {
         const buffer = Buffer2.concat(chunks);
         const status = res.statusCode ?? 0;
-        resolve4({
+        resolve6({
           ok: status >= 200 && status < 300,
           status,
           statusText: res.statusMessage ?? "",
@@ -538,25 +538,424 @@ async function deployAddon(addonPath, opts) {
   }
 }
 
-// src/commands/auth.ts
+// src/commands/deploy-server.ts
+import { execSync as execSync2 } from "child_process";
+import { randomBytes as randomBytes2 } from "crypto";
+import * as fs4 from "fs";
+import * as os2 from "os";
+import * as path4 from "path";
+
+// src/commands/server-closure.ts
 import * as fs3 from "fs";
 import * as path3 from "path";
-import * as os2 from "os";
+var CAMSTACK_SCOPE_PREFIX = "@camstack/";
+function computeDevVersion(base, epochSeconds) {
+  return `${base}-dev.${epochSeconds}`;
+}
+function readPackageManifest(dir) {
+  const pkgJsonPath = path3.join(dir, "package.json");
+  try {
+    const parsed = JSON.parse(fs3.readFileSync(pkgJsonPath, "utf-8"));
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+    const raw = parsed;
+    if (typeof raw["name"] !== "string") return null;
+    return {
+      name: raw["name"],
+      version: typeof raw["version"] === "string" ? raw["version"] : "0.0.0",
+      raw
+    };
+  } catch {
+    return null;
+  }
+}
+function loadWorkspacePackages(workspaceRoot) {
+  const root = readPackageManifest(workspaceRoot);
+  if (root === null) {
+    throw new Error(`No parseable package.json at workspace root: ${workspaceRoot}`);
+  }
+  const workspaces = root.raw["workspaces"];
+  const patterns = Array.isArray(workspaces) ? workspaces.filter((w) => typeof w === "string") : [];
+  const dirs = [];
+  for (const pattern of patterns) {
+    if (pattern.endsWith("/*")) {
+      const base = path3.join(workspaceRoot, pattern.slice(0, -2));
+      let entries;
+      try {
+        entries = fs3.readdirSync(base, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const entry of entries) {
+        if (entry.isDirectory() || entry.isSymbolicLink()) dirs.push(path3.join(base, entry.name));
+      }
+    } else {
+      dirs.push(path3.join(workspaceRoot, pattern));
+    }
+  }
+  const byName = /* @__PURE__ */ new Map();
+  for (const dir of dirs) {
+    const manifest = readPackageManifest(dir);
+    if (manifest === null) continue;
+    byName.set(manifest.name, { name: manifest.name, dir, version: manifest.version });
+  }
+  return byName;
+}
+var INSTALL_DEP_FIELDS = [
+  "dependencies",
+  "optionalDependencies",
+  "peerDependencies"
+];
+var BUILD_DEP_FIELDS = [...INSTALL_DEP_FIELDS, "devDependencies"];
+function depNames(manifest, fields) {
+  const names = /* @__PURE__ */ new Set();
+  for (const field of fields) {
+    const deps = manifest[field];
+    if (deps === null || typeof deps !== "object" || Array.isArray(deps)) continue;
+    for (const name of Object.keys(deps)) names.add(name);
+  }
+  return [...names];
+}
+function walkClosure(rootName, workspace, fields) {
+  const ordered = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visit = (name) => {
+    if (visited.has(name)) return;
+    visited.add(name);
+    const pkg = workspace.get(name);
+    if (pkg === void 0) return;
+    const manifest = readPackageManifest(pkg.dir);
+    if (manifest !== null) {
+      for (const dep of depNames(manifest.raw, fields)) {
+        if (dep.startsWith(CAMSTACK_SCOPE_PREFIX) && workspace.has(dep)) visit(dep);
+      }
+    }
+    ordered.push(pkg);
+  };
+  visit(rootName);
+  return ordered;
+}
+function discoverServerClosure(workspaceRoot) {
+  const serverDir = path3.join(workspaceRoot, "server", "backend");
+  const serverManifest = readPackageManifest(serverDir);
+  if (serverManifest === null) {
+    throw new Error(
+      `No parseable package.json at ${path3.join("server/backend", "package.json")} \u2014 run \`camstack deploy-server\` from the camstack-server workspace root.`
+    );
+  }
+  const workspace = loadWorkspacePackages(workspaceRoot);
+  const serverEntry = workspace.get(serverManifest.name);
+  if (serverEntry === void 0 || path3.resolve(serverEntry.dir) !== path3.resolve(serverDir)) {
+    throw new Error(
+      `${serverManifest.name} at server/backend is not listed in the root workspaces globs.`
+    );
+  }
+  const packSet = walkClosure(serverManifest.name, workspace, INSTALL_DEP_FIELDS);
+  const buildSet = walkClosure(serverManifest.name, workspace, BUILD_DEP_FIELDS);
+  return { serverVersion: serverManifest.version, packSet, buildSet };
+}
+function withDevVersionPackageJson(pkgDir, devVersion, intraSetNames, fn) {
+  const pkgJsonPath = path3.join(pkgDir, "package.json");
+  const originalBytes = fs3.readFileSync(pkgJsonPath);
+  const parsed = JSON.parse(originalBytes.toString("utf-8"));
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Malformed package.json: ${pkgJsonPath}`);
+  }
+  const manifest = {
+    ...parsed,
+    version: devVersion
+  };
+  for (const field of BUILD_DEP_FIELDS) {
+    const deps = manifest[field];
+    if (deps === null || typeof deps !== "object" || Array.isArray(deps)) continue;
+    const rewritten = {};
+    for (const [name, range] of Object.entries(deps)) {
+      rewritten[name] = intraSetNames.has(name) ? devVersion : range;
+    }
+    manifest[field] = rewritten;
+  }
+  fs3.writeFileSync(pkgJsonPath, `${JSON.stringify(manifest, null, 2)}
+`, "utf-8");
+  try {
+    return fn();
+  } finally {
+    fs3.writeFileSync(pkgJsonPath, originalBytes);
+  }
+}
+
+// src/commands/deploy-server.ts
+var BUILD_TIMEOUT_MS = 15 * 6e4;
+var PACK_TIMEOUT_MS = 2 * 6e4;
+var UPLOAD_TIMEOUT_MS = 10 * 6e4;
+var APPLY_TIMEOUT_MS = 6e4;
+var POLL_INTERVAL_MS = 3e3;
+var POLL_BUDGET_MS = 10 * 6e4;
+var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
+function isRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function hasBuildScript(pkgDir) {
+  const manifest = readJson(path4.join(pkgDir, "package.json"));
+  if (!isRecord2(manifest)) return false;
+  const scripts = manifest["scripts"];
+  return isRecord2(scripts) && typeof scripts["build"] === "string" && scripts["build"].length > 0;
+}
+function readJson(filePath) {
+  try {
+    return JSON.parse(fs4.readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function buildPackage(pkg) {
+  if (!hasBuildScript(pkg.dir)) {
+    console.log(`[camstack]   ${pkg.name}: no build script \u2014 skipping`);
+    return;
+  }
+  console.log(`[camstack]   ${pkg.name}: npm run build`);
+  try {
+    execSync2("npm run build", { cwd: pkg.dir, stdio: "inherit", timeout: BUILD_TIMEOUT_MS });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`Build failed for ${pkg.name} (${pkg.dir}): ${msg}`, { cause: err });
+  }
+}
+function toPackFilename(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return null;
+    const first = parsed[0];
+    if (!isRecord2(first)) return null;
+    return typeof first["filename"] === "string" ? first["filename"] : null;
+  } catch {
+    const lines = raw.split("\n").filter((l) => l.trim().length > 0);
+    const last = lines[lines.length - 1]?.trim();
+    return last !== void 0 && last.length > 0 ? last : null;
+  }
+}
+function packPackage(pkg, devVersion, intraSetNames, outDir) {
+  const output = withDevVersionPackageJson(
+    pkg.dir,
+    devVersion,
+    intraSetNames,
+    () => execSync2(`npm pack --json --pack-destination ${JSON.stringify(outDir)}`, {
+      cwd: pkg.dir,
+      encoding: "utf8",
+      timeout: PACK_TIMEOUT_MS,
+      stdio: ["ignore", "pipe", "pipe"]
+    }).trim()
+  );
+  const filename = toPackFilename(output);
+  if (filename === null) {
+    throw new Error(`npm pack produced no tarball for ${pkg.name}`);
+  }
+  const tgzPath = path4.join(outDir, path4.basename(filename));
+  if (!fs4.existsSync(tgzPath)) {
+    throw new Error(`Expected tarball not found after pack: ${tgzPath}`);
+  }
+  return { name: pkg.name, tgzPath };
+}
+async function uploadClosure(args) {
+  const boundary = `----camstackdeployserver${randomBytes2(16).toString("hex")}`;
+  const CRLF = "\r\n";
+  const parts = [
+    Buffer.from(
+      `--${boundary}${CRLF}Content-Disposition: form-data; name="version"${CRLF}${CRLF}${args.version}${CRLF}`
+    )
+  ];
+  for (const tarball of args.tarballs) {
+    parts.push(
+      Buffer.from(
+        `--${boundary}${CRLF}Content-Disposition: form-data; name="file"; filename="${path4.basename(tarball.tgzPath)}"${CRLF}Content-Type: application/gzip${CRLF}${CRLF}`
+      ),
+      fs4.readFileSync(tarball.tgzPath),
+      Buffer.from(CRLF)
+    );
+  }
+  parts.push(Buffer.from(`--${boundary}--${CRLF}`));
+  const body = Buffer.concat(parts);
+  const response = await hubRequest(`${args.serverUrl}/api/server-upload`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${args.token}`,
+      "Content-Type": `multipart/form-data; boundary=${boundary}`,
+      "Content-Length": String(body.length)
+    },
+    body,
+    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(`Server upload rejected: ${detail}`);
+  }
+}
+function toApplyResult(value) {
+  if (!isRecord2(value)) return null;
+  if (typeof value["accepted"] !== "boolean" || typeof value["message"] !== "string") return null;
+  return {
+    accepted: value["accepted"],
+    restarting: value["restarting"] === true,
+    message: value["message"]
+  };
+}
+function unwrapTrpcJson(body) {
+  const first = Array.isArray(body) ? body[0] : body;
+  if (!isRecord2(first)) return null;
+  const result = first["result"];
+  if (!isRecord2(result)) return null;
+  const data = result["data"];
+  if (!isRecord2(data)) return null;
+  return data["json"];
+}
+async function applyServerUpdate(args) {
+  const res = await hubRequest(
+    `${args.serverUrl}/trpc/serverManagement.applyServerUpdate?batch=1`,
+    {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${args.token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ "0": { json: { version: args.version } } }),
+      timeoutMs: APPLY_TIMEOUT_MS
+    }
+  );
+  const body = await res.json().catch(() => null);
+  if (!res.ok) {
+    throw new Error(`applyServerUpdate returned ${res.status} ${res.statusText}`);
+  }
+  const result = toApplyResult(unwrapTrpcJson(body));
+  if (result === null) {
+    throw new Error("applyServerUpdate returned an unexpected payload shape");
+  }
+  return result;
+}
+function toStatusView(value) {
+  if (!isRecord2(value)) return null;
+  if (typeof value["updateState"] !== "string") return null;
+  const rolledBack = value["rolledBack"];
+  return {
+    runningVersion: typeof value["runningVersion"] === "string" ? value["runningVersion"] : null,
+    updateState: value["updateState"],
+    pendingVersion: typeof value["pendingVersion"] === "string" ? value["pendingVersion"] : null,
+    rolledBackFrom: isRecord2(rolledBack) && typeof rolledBack["fromVersion"] === "string" ? rolledBack["fromVersion"] : null,
+    rolledBackReason: isRecord2(rolledBack) && typeof rolledBack["reason"] === "string" ? rolledBack["reason"] : null
+  };
+}
+async function fetchServerStatus(serverUrl, token) {
+  const url = `${serverUrl}/trpc/serverManagement.getServerPackageStatus?input=${encodeURIComponent('{"json":null}')}`;
+  const res = await hubRequest(url, {
+    headers: { Authorization: `Bearer ${token}` },
+    timeoutMs: 1e4
+  });
+  if (!res.ok) return null;
+  const body = await res.json().catch(() => null);
+  return toStatusView(unwrapTrpcJson(body));
+}
+async function pollUntilPromoted(args) {
+  const deadline = Date.now() + POLL_BUDGET_MS;
+  let lastState = "";
+  while (Date.now() < deadline) {
+    let status = null;
+    try {
+      status = await fetchServerStatus(args.serverUrl, args.token);
+    } catch {
+    }
+    if (status !== null) {
+      const stateLine = `${status.updateState} (running ${status.runningVersion ?? "?"})`;
+      if (stateLine !== lastState) {
+        console.log(`[camstack]   state: ${stateLine}`);
+        lastState = stateLine;
+      }
+      if (status.rolledBackFrom === args.version) {
+        throw new Error(
+          `Dev version ${args.version} was ROLLED BACK: ${status.rolledBackReason ?? "probation boot failed"}`
+        );
+      }
+      if (status.runningVersion === args.version && status.updateState === "idle") {
+        return;
+      }
+    }
+    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.`
+  );
+}
+function printClosure(closure) {
+  console.log(
+    `[camstack] Closure from server/backend: ${closure.packSet.length} packages to pack (+${closure.buildSet.length - closure.packSet.length} build-only)`
+  );
+  for (const pkg of closure.packSet) console.log(`[camstack]   \u2022 ${pkg.name}`);
+}
+async function deployServer(opts) {
+  const workspaceRoot = path4.resolve(opts.workspaceRoot ?? ".");
+  const closure = discoverServerClosure(workspaceRoot);
+  printClosure(closure);
+  const devVersion = computeDevVersion(closure.serverVersion, Math.floor(Date.now() / 1e3));
+  console.log(`[camstack] Dev version: ${devVersion}`);
+  console.log(`[camstack] Building ${closure.buildSet.length} packages (dependency order)...`);
+  for (const pkg of closure.buildSet) buildPackage(pkg);
+  const intraSetNames = new Set(closure.packSet.map((p) => p.name));
+  const outDir = fs4.mkdtempSync(path4.join(os2.tmpdir(), "camstack-deploy-server-"));
+  try {
+    console.log(`[camstack] Packing ${closure.packSet.length} packages at ${devVersion}...`);
+    const tarballs = [];
+    for (const pkg of closure.packSet) {
+      const packed = packPackage(pkg, devVersion, intraSetNames, outDir);
+      console.log(`[camstack]   \u2713 ${pkg.name} \u2192 ${path4.basename(packed.tgzPath)}`);
+      tarballs.push(packed);
+    }
+    console.log(`[camstack] Uploading ${tarballs.length} tarballs to ${opts.serverUrl}...`);
+    await uploadClosure({
+      serverUrl: opts.serverUrl,
+      token: opts.token,
+      version: devVersion,
+      tarballs
+    });
+    console.log("[camstack] \u2713 Upload accepted");
+    console.log(`[camstack] Applying server update to ${devVersion}...`);
+    const apply = await applyServerUpdate({
+      serverUrl: opts.serverUrl,
+      token: opts.token,
+      version: devVersion
+    });
+    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`);
+  } finally {
+    fs4.rmSync(outDir, { recursive: true, force: true });
+  }
+}
+
+// src/commands/auth.ts
+import * as fs5 from "fs";
+import * as path5 from "path";
+import * as os3 from "os";
 import * as clack from "@clack/prompts";
-var SESSION_DIR = path3.join(os2.homedir(), ".camstack");
+var SESSION_DIR = path5.join(os3.homedir(), ".camstack");
 function sessionFileForServer(serverUrl) {
   const slug = serverUrl.replace(/^https?:\/\//, "").replace(/[:/?#]+/g, "_").replace(/_+$/, "");
-  return path3.join(SESSION_DIR, `${slug}.json`);
+  return path5.join(SESSION_DIR, `${slug}.json`);
 }
 function resolveSessionFile(serverUrl) {
   if (serverUrl) {
     const p = sessionFileForServer(serverUrl);
-    return fs3.existsSync(p) ? p : null;
+    return fs5.existsSync(p) ? p : null;
   }
-  if (!fs3.existsSync(SESSION_DIR)) return null;
-  const files = fs3.readdirSync(SESSION_DIR).filter((f) => f.endsWith(".json")).map((f) => path3.join(SESSION_DIR, f));
+  if (!fs5.existsSync(SESSION_DIR)) return null;
+  const files = fs5.readdirSync(SESSION_DIR).filter((f) => f.endsWith(".json")).map((f) => path5.join(SESSION_DIR, f));
   if (files.length === 0) return null;
-  return files.map((f) => ({ f, mtime: fs3.statSync(f).mtimeMs })).toSorted((a, b) => b.mtime - a.mtime)[0].f;
+  return files.map((f) => ({ f, mtime: fs5.statSync(f).mtimeMs })).toSorted((a, b) => b.mtime - a.mtime)[0].f;
 }
 function isSessionFile(value) {
   if (value === null || typeof value !== "object") return false;
@@ -573,24 +972,24 @@ function loadSession(serverUrl) {
   const file = resolveSessionFile(serverUrl);
   if (!file) return null;
   try {
-    const parsed = JSON.parse(fs3.readFileSync(file, "utf8"));
+    const parsed = JSON.parse(fs5.readFileSync(file, "utf8"));
     return isSessionFile(parsed) ? parsed : null;
   } catch {
     return null;
   }
 }
 function saveSession(session) {
-  if (!fs3.existsSync(SESSION_DIR)) {
-    fs3.mkdirSync(SESSION_DIR, { recursive: true, mode: 448 });
+  if (!fs5.existsSync(SESSION_DIR)) {
+    fs5.mkdirSync(SESSION_DIR, { recursive: true, mode: 448 });
   }
   const file = sessionFileForServer(session.server);
-  fs3.writeFileSync(file, JSON.stringify(session, null, 2), { mode: 384 });
+  fs5.writeFileSync(file, JSON.stringify(session, null, 2), { mode: 384 });
   return file;
 }
 function clearSession(serverUrl) {
   const file = sessionFileForServer(serverUrl);
-  if (fs3.existsSync(file)) {
-    fs3.unlinkSync(file);
+  if (fs5.existsSync(file)) {
+    fs5.unlinkSync(file);
     return true;
   }
   return false;
@@ -680,7 +1079,7 @@ function isUnknown(_value) {
   return true;
 }
 async function resolveServerInteractive(presetNamespace) {
-  const { discoverNodes, resolveHubFromDiscovered, filterHubNodes, DEFAULT_HUB_HTTPS_PORT } = await import("./discover-3WTX7YIA.js");
+  const { discoverNodes, resolveHubFromDiscovered, filterHubNodes, DEFAULT_HUB_HTTPS_PORT } = await import("./discover-VNCOKFC2.js");
   if (presetNamespace) {
     const spinner4 = clack.spinner();
     spinner4.start(`Discovering hub on LAN (namespace "${presetNamespace}")`);
@@ -817,7 +1216,7 @@ async function loginCommand(opts) {
   }
   const mintSpinner = clack.spinner();
   mintSpinner.start("Creating scoped token (upload + log streaming)");
-  const tokenName = opts.tokenName ?? `camstack-cli@${os2.hostname()}`;
+  const tokenName = opts.tokenName ?? `camstack-cli@${os3.hostname()}`;
   const scopes = [
     {
       type: "capability",
@@ -929,18 +1328,18 @@ import { spawn } from "child_process";
 import * as clack2 from "@clack/prompts";
 
 // 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");
+import * as fs6 from "fs";
+import * as path6 from "path";
+import * as os4 from "os";
+var CACHE_DIR = path6.join(os4.homedir(), ".camstack");
+var CACHE_FILE = path6.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 (!fs6.existsSync(CACHE_FILE)) return null;
+    const parsed = JSON.parse(fs6.readFileSync(CACHE_FILE, "utf8"));
     if (!parsed || typeof parsed !== "object") return null;
     const c = parsed;
     if (typeof c.lastCheckAt !== "number") return null;
@@ -955,8 +1354,8 @@ function readCache() {
 }
 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));
+    if (!fs6.existsSync(CACHE_DIR)) fs6.mkdirSync(CACHE_DIR, { recursive: true, mode: 448 });
+    fs6.writeFileSync(CACHE_FILE, JSON.stringify(c, null, 2));
   } catch {
   }
 }
@@ -1033,10 +1432,10 @@ function isRunningViaNpx() {
   return entry.includes("/_npx/") || entry.includes("\\_npx\\");
 }
 function runNpmInstall(spec) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve6, reject) => {
     const proc = spawn("npm", ["install", "-g", spec], { stdio: "inherit" });
     proc.on("exit", (code) => {
-      if (code === 0) resolve4();
+      if (code === 0) resolve6();
       else reject(new Error(`npm install -g ${spec} exited with code ${code}`));
     });
     proc.on("error", reject);
@@ -1077,12 +1476,12 @@ async function runUpdate(args) {
   }
   const { createRequire: createRequire2 } = await import("module");
   const { fileURLToPath: fileURLToPath2 } = await import("url");
-  const { dirname: dirname2, resolve: resolve4 } = await import("path");
+  const { dirname: dirname2, resolve: resolve6 } = await import("path");
   const require3 = createRequire2(import.meta.url);
   const here = dirname2(fileURLToPath2(import.meta.url));
   let current = "0.0.0";
   try {
-    const pkg = require3(resolve4(here, "..", "package.json"));
+    const pkg = require3(resolve6(here, "..", "package.json"));
     current = pkg.version;
   } catch {
   }
@@ -1115,8 +1514,8 @@ async function runUpdate(args) {
 }
 
 // src/commands/dev.ts
-import * as fs5 from "fs";
-import * as path5 from "path";
+import * as fs7 from "fs";
+import * as path7 from "path";
 import { parseArgs as parseArgs5 } from "util";
 import * as clack3 from "@clack/prompts";
 var DEFAULT_DEBOUNCE_MS = 500;
@@ -1125,15 +1524,15 @@ function resolveAddonDir(arg) {
   if (arg.endsWith(".tgz") || arg.endsWith(".tar.gz")) {
     throw new Error("`dev` requires a source directory, not a tarball (nothing to watch).");
   }
-  const absolute = path5.resolve(arg);
-  if (fs5.existsSync(absolute) && fs5.statSync(absolute).isDirectory()) {
+  const absolute = path7.resolve(arg);
+  if (fs7.existsSync(absolute) && fs7.statSync(absolute).isDirectory()) {
     return absolute;
   }
   for (const candidate of [
-    path5.resolve("packages", `addon-${arg}`),
-    path5.resolve("packages", arg)
+    path7.resolve("packages", `addon-${arg}`),
+    path7.resolve("packages", arg)
   ]) {
-    if (fs5.existsSync(candidate) && fs5.statSync(candidate).isDirectory()) {
+    if (fs7.existsSync(candidate) && fs7.statSync(candidate).isDirectory()) {
       return candidate;
     }
   }
@@ -1143,10 +1542,10 @@ function resolveAddonDir(arg) {
 }
 function watchRecursive(target, onEvent) {
   try {
-    const w = fs5.watch(target, { recursive: true }, onEvent);
+    const w = fs7.watch(target, { recursive: true }, onEvent);
     return { close: () => w.close(), recursive: true };
   } catch {
-    const w = fs5.watch(target, onEvent);
+    const w = fs7.watch(target, onEvent);
     return { close: () => w.close(), recursive: false };
   }
 }
@@ -1202,12 +1601,12 @@ async function runDev(args) {
     ...typeof values["build-script"] === "string" ? { buildScript: values["build-script"] } : {}
   };
   const watchOverride = typeof values["watch-path"] === "string" ? values["watch-path"] : void 0;
-  const watchTarget = watchOverride ? path5.resolve(addonDir, watchOverride) : fs5.existsSync(path5.join(addonDir, DEFAULT_WATCH_SUBDIR)) ? path5.join(addonDir, DEFAULT_WATCH_SUBDIR) : addonDir;
-  if (!fs5.existsSync(watchTarget)) {
+  const watchTarget = watchOverride ? path7.resolve(addonDir, watchOverride) : fs7.existsSync(path7.join(addonDir, DEFAULT_WATCH_SUBDIR)) ? path7.join(addonDir, DEFAULT_WATCH_SUBDIR) : addonDir;
+  if (!fs7.existsSync(watchTarget)) {
     throw new Error(`Watch path does not exist: ${watchTarget}`);
   }
   const debounceMs = typeof values.debounce === "string" ? parseInt(values.debounce, 10) : DEFAULT_DEBOUNCE_MS;
-  clack3.intro(`camstack dev \u2014 ${path5.basename(addonDir)}`);
+  clack3.intro(`camstack dev \u2014 ${path7.basename(addonDir)}`);
   clack3.log.info(`Watch:  ${watchTarget}`);
   clack3.log.info(
     `Target: ${serverUrl}${cluster ? " (cluster)" : nodeId ? ` (node: ${nodeId})` : " (hub)"}`
@@ -1260,10 +1659,10 @@ async function runDev(args) {
 }
 
 // src/commands/watch.ts
-import * as path6 from "path";
+import * as path8 from "path";
 import { parseArgs as parseArgs6 } from "util";
 import * as clack4 from "@clack/prompts";
-var POLL_INTERVAL_MS = 2e3;
+var POLL_INTERVAL_MS2 = 2e3;
 var LOG_BATCH_LIMIT = 100;
 var LEVEL_COLOURS = {
   debug: "\x1B[90m",
@@ -1337,7 +1736,7 @@ async function runWatch(args) {
   };
   clack4.intro("camstack watch");
   const resolvedPath = await resolveAddonPathInteractive(addonArg);
-  const addonId = path6.basename(resolvedPath).replace(/^addon-/, "");
+  const addonId = path8.basename(resolvedPath).replace(/^addon-/, "");
   if (values["no-initial-deploy"] !== true) {
     await deployAddon(resolvedPath, deployOpts);
   }
@@ -1386,7 +1785,7 @@ async function runWatch(args) {
       const msg = err instanceof Error ? err.message : String(err);
       console.error(`[camstack watch] poll error: ${msg}`);
     }
-    await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+    await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS2));
   }
 }
 
@@ -1395,7 +1794,7 @@ var __dirname = dirname(fileURLToPath(import.meta.url));
 var require2 = createRequire(import.meta.url);
 var pkgVersion = "0.1.0";
 try {
-  const pkg = require2(resolve3(__dirname, "..", "package.json"));
+  const pkg = require2(resolve5(__dirname, "..", "package.json"));
   pkgVersion = pkg.version;
 } catch {
 }
@@ -1481,7 +1880,7 @@ function buildCommands() {
         "  -n, --namespace <ns>   Filter discovery to this cluster 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@${os4.hostname()})`
+        `  --token-name <name>    Name shown server-side (default: camstack-cli@${os5.hostname()})`
       ].join("\n")
     },
     {
@@ -1551,6 +1950,26 @@ function buildCommands() {
         "  -c, --cluster           Push to hub + every online agent (requires admin token)"
       ].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)",
+      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.",
+        "",
+        "Options:",
+        "  -s, --server <url>     Server URL (default: cached session from `camstack login`)",
+        "  -t, --token <token>    Auth token override ($CAMSTACK_TOKEN, then cached scoped token)",
+        "      --no-verify        Do not wait for promotion after applyServerUpdate is accepted"
+      ].join("\n")
+    },
     {
       name: "watch",
       summary: "Deploy + tail server-side addon logs (polling /trpc/addons.getLogs)",
@@ -1626,10 +2045,10 @@ function buildCommands() {
       summary: "Print detailed version and platform info",
       run: () => {
         console.log(`camstack v${pkgVersion}`);
-        console.log(`Platform: ${os4.platform()}-${os4.arch()}`);
+        console.log(`Platform: ${os5.platform()}-${os5.arch()}`);
         console.log(`Node.js: ${process.version}`);
-        console.log(`CPU: ${os4.cpus()[0]?.model ?? "unknown"} (${os4.cpus().length} cores)`);
-        console.log(`Memory: ${Math.round(os4.totalmem() / 1024 / 1024)} MB`);
+        console.log(`CPU: ${os5.cpus()[0]?.model ?? "unknown"} (${os5.cpus().length} cores)`);
+        console.log(`Memory: ${Math.round(os5.totalmem() / 1024 / 1024)} MB`);
       },
       help: () => "Usage: camstack info"
     }
@@ -1766,6 +2185,35 @@ async function runDeploy(args) {
     verify: !noVerify
   });
 }
+async function runDeployServer(args) {
+  const parsed = parseSubcommandArgs(
+    args,
+    {
+      server: { type: "string", short: "s" },
+      token: { type: "string", short: "t" },
+      "no-verify": { type: "boolean" }
+    },
+    false
+  );
+  if (!parsed) {
+    console.log(commandHelp("deploy-server"));
+    return;
+  }
+  const session = loadSession(stringOpt(parsed.values, "server"));
+  const server = stringOpt(parsed.values, "server") ?? process.env.CAMSTACK_SERVER ?? session?.server ?? "https://localhost:4443";
+  const token = stringOpt(parsed.values, "token") ?? process.env.CAMSTACK_TOKEN ?? session?.token;
+  if (!token) {
+    console.error(
+      "[camstack] Error: No token. Run `camstack login` first, pass --token, or set CAMSTACK_TOKEN."
+    );
+    process.exit(1);
+  }
+  await deployServer({
+    serverUrl: server,
+    token,
+    verify: !boolOpt(parsed.values, "no-verify")
+  });
+}
 function commandHelp(name) {
   const cmd = buildCommands().find((c) => c.name === name);
   return cmd ? cmd.help() : "";