camstack 0.5.3 → 0.7.0

package/dist/cli.js

@@ -6,9 +6,9 @@ import {
 // src/cli.ts
 import { createRequire } from "module";
 import { fileURLToPath } from "url";
-import { dirname, resolve as resolve2 } from "path";
+import { dirname, resolve as resolve3 } from "path";
 import * as os4 from "os";
-import { parseArgs as parseArgs5 } from "util";
+import { parseArgs as parseArgs6 } 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}`, { cause: err });
+  }
+}
 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;
@@ -711,10 +750,10 @@ function isRunningViaNpx() {
   return entry.includes("/_npx/") || entry.includes("\\_npx\\");
 }
 function runNpmInstall(spec) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const proc = spawn("npm", ["install", "-g", spec], { stdio: "inherit" });
     proc.on("exit", (code) => {
-      if (code === 0) resolve3();
+      if (code === 0) resolve4();
       else reject(new Error(`npm install -g ${spec} exited with code ${code}`));
     });
     proc.on("error", reject);
@@ -755,12 +794,12 @@ async function runUpdate(args) {
   }
   const { createRequire: createRequire2 } = await import("module");
   const { fileURLToPath: fileURLToPath2 } = await import("url");
-  const { dirname: dirname2, resolve: resolve3 } = await import("path");
+  const { dirname: dirname2, resolve: resolve4 } = 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"));
+    const pkg = require3(resolve4(here, "..", "package.json"));
     current = pkg.version;
   } catch {
   }
@@ -790,12 +829,151 @@ async function runUpdate(args) {
   clack2.outro(`\u2713 Installed camstack@${target}. Verify with: camstack --version`);
 }
 
+// src/commands/dev.ts
+import * as fs5 from "fs";
+import * as path5 from "path";
+import { parseArgs as parseArgs5 } from "util";
+import * as clack3 from "@clack/prompts";
+var DEFAULT_DEBOUNCE_MS = 500;
+var DEFAULT_WATCH_SUBDIR = "src";
+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()) {
+    return absolute;
+  }
+  for (const candidate of [
+    path5.resolve("packages", `addon-${arg}`),
+    path5.resolve("packages", arg)
+  ]) {
+    if (fs5.existsSync(candidate) && fs5.statSync(candidate).isDirectory()) {
+      return candidate;
+    }
+  }
+  throw new Error(`Path not resolved: ${arg} (tried as-is + packages/addon-${arg} + packages/${arg})`);
+}
+function watchRecursive(target, onEvent) {
+  try {
+    const w = fs5.watch(target, { recursive: true }, onEvent);
+    return { close: () => w.close(), recursive: true };
+  } catch {
+    const w = fs5.watch(target, onEvent);
+    return { close: () => w.close(), recursive: false };
+  }
+}
+async function pushOnce(addonPath, opts, label) {
+  const start = Date.now();
+  console.log(`
+[camstack dev] \u2192 ${label}\u2026`);
+  try {
+    await deployAddon(addonPath, opts);
+    const took = ((Date.now() - start) / 1e3).toFixed(1);
+    console.log(`[camstack dev] \u2713 Synced in ${took}s`);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`[camstack dev] \u2717 Push failed: ${msg}`);
+    console.error(`[camstack dev]   Waiting for next change\u2026`);
+  }
+}
+async function runDev(args) {
+  const { values, positionals } = parseArgs5({
+    args: [...args],
+    options: {
+      server: { type: "string", short: "s" },
+      token: { type: "string", short: "t" },
+      node: { type: "string", short: "n" },
+      cluster: { type: "boolean", short: "c" },
+      "watch-path": { type: "string", short: "w" },
+      debounce: { type: "string" },
+      "no-build": { type: "boolean" },
+      "build-script": { type: "string" },
+      "no-initial-push": { type: "boolean" }
+    },
+    strict: true,
+    allowPositionals: true
+  });
+  const addonArg = positionals[0] ?? ".";
+  const addonDir = resolveAddonDir(addonArg);
+  const explicitServer = typeof values.server === "string" ? values.server : void 0;
+  const explicitToken = typeof values.token === "string" ? values.token : void 0;
+  const session = loadSession(explicitServer);
+  const serverUrl = explicitServer ?? process.env.CAMSTACK_SERVER ?? session?.server;
+  const token = explicitToken ?? process.env.CAMSTACK_TOKEN ?? session?.token;
+  if (!serverUrl || !token) {
+    throw new Error("Missing server/token. Run `camstack login` first, or pass --server + --token.");
+  }
+  const nodeId = typeof values.node === "string" ? values.node : void 0;
+  const cluster = values.cluster === true;
+  const deployOpts = {
+    serverUrl,
+    token,
+    ...nodeId ? { nodeId } : {},
+    ...cluster ? { cluster: true } : {},
+    buildMode: values["no-build"] === true ? "skip" : "auto",
+    ...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)) {
+    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.log.info(`Watch:  ${watchTarget}`);
+  clack3.log.info(`Target: ${serverUrl}${cluster ? " (cluster)" : nodeId ? ` (node: ${nodeId})` : " (hub)"}`);
+  clack3.log.info(`Debounce: ${debounceMs}ms`);
+  if (values["no-initial-push"] !== true) {
+    await pushOnce(addonDir, deployOpts, "Initial sync");
+  } else {
+    console.log("[camstack dev] Skipping initial push (--no-initial-push). Waiting for changes\u2026");
+  }
+  let timer = null;
+  let pushing = false;
+  let pending = false;
+  const runDebouncedPush = () => {
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(async () => {
+      if (pushing) {
+        pending = true;
+        return;
+      }
+      pushing = true;
+      try {
+        await pushOnce(addonDir, deployOpts, "File change detected \u2014 rebuilding");
+      } finally {
+        pushing = false;
+        if (pending) {
+          pending = false;
+          runDebouncedPush();
+        }
+      }
+    }, debounceMs);
+  };
+  const { close, recursive } = watchRecursive(watchTarget, () => runDebouncedPush());
+  if (!recursive) {
+    clack3.log.warn("Recursive watch not supported on this platform \u2014 only top-level changes will trigger a push. Upgrade Node 20+ for recursive support.");
+  }
+  const shutdown = () => {
+    console.log("\n[camstack dev] Stopping watcher\u2026");
+    if (timer) clearTimeout(timer);
+    close();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  console.log("\n[camstack dev] Watching for changes. Ctrl-C to stop.");
+  await new Promise(() => {
+  });
+}
+
 // src/cli.ts
 var __dirname = dirname(fileURLToPath(import.meta.url));
 var require2 = createRequire(import.meta.url);
 var pkgVersion = "0.1.0";
 try {
-  const pkg = require2(resolve2(__dirname, "..", "package.json"));
+  const pkg = require2(resolve3(__dirname, "..", "package.json"));
   pkgVersion = pkg.version;
 } catch {
 }
@@ -935,13 +1113,50 @@ 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: "dev",
+      aliases: ["watch"],
+      summary: "Watch addon source + auto build & push on every change (live-reload loop)",
+      run: runDev,
+      help: () => [
+        "Usage: camstack dev [options] [path]",
+        "       camstack watch [options] [path]    (alias)",
+        "",
+        "Argument:",
+        '  path                      Addon directory (or workspace name). Default: "."',
+        "",
+        "Watch options:",
+        "  -w, --watch-path <dir>    Subpath to watch (default: <addon>/src if it exists, else addon root)",
+        "      --debounce <ms>       Coalesce bursts of changes (default: 500)",
+        "      --no-initial-push     Skip the first push, only react to changes",
+        "",
+        "Build options:",
+        "      --no-build            Skip `npm run build` (just pack + upload)",
+        "      --build-script <n>    Override script name (default: build)",
+        "",
+        "Target options:",
+        "  -s, --server <url>        Server URL (default: cached session)",
+        "  -t, --token <token>       Auth token override",
+        "  -n, --node <id>           Push to a specific node",
+        "  -c, --cluster             Push to hub + every online agent",
+        "",
+        "Stop with Ctrl-C. Each cycle is sequential \u2014 concurrent changes during",
+        "a push are coalesced into the next cycle."
+      ].join("\n")
+    },
     {
       name: "update",
       aliases: ["upgrade"],
@@ -975,7 +1190,7 @@ function buildCommands() {
 }
 function parseSubcommandArgs(args, options, allowPositionals) {
   if (args.some((a) => HELP_FLAGS.has(a))) return null;
-  const parsed = parseArgs5({
+  const parsed = parseArgs6({
     args: [...args],
     options,
     allowPositionals,
@@ -1035,7 +1250,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"));
@@ -1055,11 +1273,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.3",
+  "version": "0.7.0",
   "description": "CLI tool for managing and running CamStack server",
   "keywords": [
     "camstack",