camstack 0.5.2 → 0.6.0

package/dist/cli.js

@@ -8,7 +8,7 @@ import { createRequire } from "module";
 import { fileURLToPath } from "url";
 import { dirname, resolve as resolve2 } from "path";
 import * as os4 from "os";
-import { parseArgs as parseArgs4 } from "util";
+import { parseArgs as parseArgs5 } from "util";
 
 // src/commands/serve.ts
 import { parseArgs } from "util";
@@ -178,6 +178,33 @@ function resolveAddonPath(arg) {
   }
   return null;
 }
+function readBuildScript(addonDir, scriptName) {
+  const pkgJsonPath = path2.join(addonDir, "package.json");
+  if (!fs2.existsSync(pkgJsonPath)) return null;
+  try {
+    const parsed = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf8"));
+    if (!parsed || typeof parsed !== "object") return null;
+    const scripts = parsed.scripts;
+    if (!scripts || typeof scripts !== "object") return null;
+    const val = scripts[scriptName];
+    return typeof val === "string" && val.length > 0 ? scriptName : null;
+  } catch {
+    return null;
+  }
+}
+function buildAddon(addonDir, scriptName) {
+  console.log(`[camstack] Building (npm run ${scriptName}) in ${addonDir}...`);
+  try {
+    execSync(`npm run ${scriptName}`, {
+      cwd: addonDir,
+      stdio: "inherit",
+      timeout: 5 * 6e4
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`Build script "${scriptName}" failed in ${addonDir}: ${msg}`);
+  }
+}
 function packAddon(addonDir) {
   const pkgJsonPath = path2.join(addonDir, "package.json");
   if (!fs2.existsSync(pkgJsonPath)) {
@@ -258,6 +285,18 @@ async function deployAddon(addonPath, opts) {
     if (!fs2.existsSync(resolvedPath)) throw new Error(`File not found: ${resolvedPath}`);
     tgzPath = resolvedPath;
   } else {
+    const buildMode = opts.buildMode ?? "auto";
+    const scriptName = opts.buildScript ?? "build";
+    if (buildMode !== "skip") {
+      const declared = readBuildScript(resolvedPath, scriptName);
+      if (declared) {
+        buildAddon(resolvedPath, declared);
+      } else if (buildMode === "force") {
+        throw new Error(`Build mode "force" but no "${scriptName}" script declared in ${path2.join(resolvedPath, "package.json")}`);
+      } else {
+        console.log(`[camstack] No "${scriptName}" script \u2014 skipping build (use --build force to require one).`);
+      }
+    }
     const packed = packAddon(resolvedPath);
     tgzPath = packed.tgzPath;
     cleanup = packed.cleanup;
@@ -444,29 +483,29 @@ function isUnknown(_value) {
 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 spinner4 = clack.spinner();
+    spinner4.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}".`);
+      spinner4.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.`);
+      spinner4.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}`);
+    spinner4.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 spinner3 = clack.spinner();
+  spinner3.start("Scanning LAN for camstack nodes (UDP multicast)");
   const all = await discoverNodes({});
   if (all.length === 0) {
-    spinner2.stop("No camstack nodes responded on LAN.");
+    spinner3.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).`);
+  spinner3.stop(`Found ${all.length} node(s).`);
   const chosen = await askSelect(
     "Select a hub to log into",
     all.map((n) => ({
@@ -571,8 +610,8 @@ async function logoutCommand(opts) {
     return;
   }
   clack.intro("camstack logout");
-  const spinner2 = clack.spinner();
-  spinner2.start(`Revoking token on ${session.server}`);
+  const spinner3 = clack.spinner();
+  spinner3.start(`Revoking token on ${session.server}`);
   try {
     await callTrpcMutation(
       `${session.server}/trpc/userManagement.revokeScopedToken?batch=1`,
@@ -580,9 +619,9 @@ async function logoutCommand(opts) {
       { id: session.tokenId },
       isUnknown
     );
-    spinner2.stop("Token revoked server-side.");
+    spinner3.stop("Token revoked server-side.");
   } catch (err) {
-    spinner2.stop(`Server-side revoke failed (${err instanceof Error ? err.message : String(err)}). Removing local cache anyway.`);
+    spinner3.stop(`Server-side revoke failed (${err instanceof Error ? err.message : String(err)}). Removing local cache anyway.`);
   }
   clearSession(session.server);
   clack.outro(`\u2713 Logged out of ${session.server}`);
@@ -601,6 +640,11 @@ function whoamiCommand(opts) {
   console.log(`  createdAt: ${new Date(session.createdAt).toISOString()}`);
 }
 
+// src/commands/update.ts
+import { parseArgs as parseArgs4 } from "util";
+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";
@@ -700,6 +744,91 @@ function printBanner(pkgName, current, latest) {
   process.stderr.write(lines.join("\n"));
 }
 
+// src/commands/update.ts
+function isRunningViaNpx() {
+  const entry = process.argv[1] ?? "";
+  return entry.includes("/_npx/") || entry.includes("\\_npx\\");
+}
+function runNpmInstall(spec) {
+  return new Promise((resolve3, reject) => {
+    const proc = spawn("npm", ["install", "-g", spec], { stdio: "inherit" });
+    proc.on("exit", (code) => {
+      if (code === 0) resolve3();
+      else reject(new Error(`npm install -g ${spec} exited with code ${code}`));
+    });
+    proc.on("error", reject);
+  });
+}
+async function runUpdate(args) {
+  const { values } = parseArgs4({
+    args: [...args],
+    options: {
+      version: { type: "string", short: "V" },
+      yes: { type: "boolean", short: "y" }
+    },
+    strict: true,
+    allowPositionals: false
+  });
+  const pinnedVersion = typeof values.version === "string" ? values.version : void 0;
+  const skipConfirm = values.yes === true;
+  if (isRunningViaNpx()) {
+    console.log("You are running via npx \u2014 versions are fetched per-invocation.");
+    console.log("Just call `npx camstack@latest <cmd>` for the freshest release.");
+    console.log("To install globally: `npm install -g camstack@latest`");
+    return;
+  }
+  clack2.intro("camstack update");
+  let target;
+  if (pinnedVersion) {
+    target = pinnedVersion;
+  } else {
+    const spinner3 = clack2.spinner();
+    spinner3.start("Checking npm registry");
+    const latest = await fetchLatestVersion("camstack");
+    if (!latest) {
+      spinner3.stop("Could not reach the npm registry.");
+      throw new Error("Network error \u2014 try again or pass --version <x.y.z>");
+    }
+    spinner3.stop(`Latest published: ${latest}`);
+    target = latest;
+  }
+  const { createRequire: createRequire2 } = await import("module");
+  const { fileURLToPath: fileURLToPath2 } = await import("url");
+  const { dirname: dirname2, resolve: resolve3 } = 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(resolve3(here, "..", "package.json"));
+    current = pkg.version;
+  } catch {
+  }
+  if (current === target && !pinnedVersion) {
+    clack2.outro(`Already at ${current} \u2014 no update needed.`);
+    return;
+  }
+  clack2.log.info(`Current: ${current}  \u2192  Target: ${target}`);
+  if (!skipConfirm) {
+    const ok = await clack2.confirm({
+      message: `Install camstack@${target} globally with npm?`,
+      initialValue: true
+    });
+    if (clack2.isCancel(ok) || ok === false) {
+      clack2.cancel("Cancelled.");
+      return;
+    }
+  }
+  console.log("");
+  try {
+    await runNpmInstall(`camstack@${target}`);
+  } catch (err) {
+    clack2.log.error(err instanceof Error ? err.message : String(err));
+    clack2.log.warn("If you see EACCES, your global npm prefix may need sudo or a different prefix. See https://docs.npmjs.com/resolving-eacces-permissions-errors-when-installing-packages-globally");
+    throw err;
+  }
+  clack2.outro(`\u2713 Installed camstack@${target}. Verify with: camstack --version`);
+}
+
 // src/cli.ts
 var __dirname = dirname(fileURLToPath(import.meta.url));
 var require2 = createRequire(import.meta.url);
@@ -845,13 +974,36 @@ function buildCommands() {
         '  path                    Path to addon dir, .tgz, or workspace name (e.g. "tailscale")',
         '                          Default: "." (current dir)',
         "",
-        "Options:",
+        "Build (only when path is a directory):",
+        "  -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)",
+        "",
+        "Target options:",
         "  -s, --server <url>      Server URL (default: cached session from `camstack login`)",
         "  -t, --token <token>     Auth token override ($CAMSTACK_TOKEN, then cached scoped token)",
         "  -n, --node <id>         Push to a specific node. Mutually exclusive with --cluster",
         "  -c, --cluster           Push to hub + every online agent (requires admin token)"
       ].join("\n")
     },
+    {
+      name: "update",
+      aliases: ["upgrade"],
+      summary: "Self-upgrade \u2014 runs `npm install -g camstack@latest`",
+      run: runUpdate,
+      help: () => [
+        "Usage: camstack update [options]",
+        "       camstack upgrade [options]    (alias)",
+        "",
+        "With no flags: fetches the latest version from npm, confirms,",
+        "  then runs `npm install -g camstack@<latest>`.",
+        "",
+        "Options:",
+        "  -V, --version <x.y.z>  Install a specific version (pin/downgrade)",
+        "  -y, --yes              Skip confirmation (useful for scripts)"
+      ].join("\n")
+    },
     {
       name: "info",
       summary: "Print detailed version and platform info",
@@ -868,7 +1020,7 @@ function buildCommands() {
 }
 function parseSubcommandArgs(args, options, allowPositionals) {
   if (args.some((a) => HELP_FLAGS.has(a))) return null;
-  const parsed = parseArgs4({
+  const parsed = parseArgs5({
     args: [...args],
     options,
     allowPositionals,
@@ -928,7 +1080,10 @@ async function runDeploy(args) {
     server: { type: "string", short: "s" },
     token: { type: "string", short: "t" },
     node: { type: "string", short: "n" },
-    cluster: { type: "boolean", short: "c" }
+    cluster: { type: "boolean", short: "c" },
+    build: { type: "string", short: "b" },
+    "build-script": { type: "string" },
+    "no-build": { type: "boolean" }
   }, true);
   if (!parsed) {
     console.log(commandHelp("deploy"));
@@ -948,11 +1103,23 @@ async function runDeploy(args) {
     console.error("[camstack] Error: --node and --cluster are mutually exclusive.");
     process.exit(1);
   }
+  const buildFlag = stringOpt(parsed.values, "build");
+  const noBuild = boolOpt(parsed.values, "no-build");
+  let buildMode = "auto";
+  if (noBuild) buildMode = "skip";
+  else if (buildFlag === "force" || buildFlag === "skip" || buildFlag === "auto") buildMode = buildFlag;
+  else if (buildFlag) {
+    console.error(`[camstack] Error: --build must be one of: auto, force, skip (got: ${buildFlag})`);
+    process.exit(1);
+  }
+  const buildScript = stringOpt(parsed.values, "build-script");
   await deployAddon(addonPath, {
     serverUrl: server,
     token,
     ...nodeId ? { nodeId } : {},
-    ...cluster ? { cluster: true } : {}
+    ...cluster ? { cluster: true } : {},
+    buildMode,
+    ...buildScript ? { buildScript } : {}
   });
 }
 function commandHelp(name) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "camstack",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "description": "CLI tool for managing and running CamStack server",
   "keywords": [
     "camstack",