camstack 0.7.2 → 0.8.0

package/dist/cli.js

@@ -8,7 +8,7 @@ import { createRequire } from "module";
 import { fileURLToPath } from "url";
 import { dirname, resolve as resolve3 } from "path";
 import * as os4 from "os";
-import { parseArgs as parseArgs6 } from "util";
+import { parseArgs as parseArgs7 } from "util";
 
 // src/commands/serve.ts
 import { parseArgs } from "util";
@@ -178,6 +178,47 @@ function resolveAddonPath(arg) {
   }
   return null;
 }
+async function resolveAddonPathInteractive(arg) {
+  if (arg !== ".") {
+    const resolved = resolveAddonPath(arg);
+    if (!resolved) {
+      throw new Error(`Path not resolved: ${arg} (tried as-is + packages/addon-${arg} + packages/${arg})`);
+    }
+    return resolved;
+  }
+  const cwdAbs = path2.resolve(".");
+  if (fs2.existsSync(path2.join(cwdAbs, "package.json"))) {
+    const { discoverAddonsInCwd: discoverAddonsInCwd2 } = await import("./discover-addons-OH6SFUPV.js");
+    const direct = discoverAddonsInCwd2(cwdAbs, 0);
+    if (direct.length > 0 && direct[0].path === cwdAbs) {
+      return cwdAbs;
+    }
+  }
+  const { discoverAddonsInCwd } = await import("./discover-addons-OH6SFUPV.js");
+  const candidates = discoverAddonsInCwd(cwdAbs, 5);
+  if (candidates.length === 0) {
+    throw new Error(`No addon found in the current directory tree (5 levels deep). Run inside an addon source dir, pass a path, or use the workspace shorthand.`);
+  }
+  if (candidates.length === 1) {
+    const only = candidates[0];
+    console.log(`[camstack] Auto-selected ${only.name} (${path2.relative(cwdAbs, only.path) || "."}, matched by ${only.matchedBy})`);
+    return only.path;
+  }
+  const clack5 = await import("@clack/prompts");
+  const choice = await clack5.select({
+    message: `Found ${candidates.length} addons \u2014 pick one to deploy`,
+    options: candidates.map((c) => ({
+      value: c.path,
+      label: `${c.name}${c.displayName && c.displayName !== c.name ? ` (${c.displayName})` : ""}`,
+      hint: `${path2.relative(cwdAbs, c.path) || "."}  matched by ${c.matchedBy}`
+    }))
+  });
+  if (clack5.isCancel(choice)) {
+    clack5.cancel("Cancelled.");
+    process.exit(130);
+  }
+  return choice;
+}
 function readBuildScript(addonDir, scriptName) {
   const pkgJsonPath = path2.join(addonDir, "package.json");
   if (!fs2.existsSync(pkgJsonPath)) return null;
@@ -275,10 +316,7 @@ async function uploadToTarget(args) {
   return result;
 }
 async function deployAddon(addonPath, opts) {
-  const resolvedPath = resolveAddonPath(addonPath);
-  if (!resolvedPath) {
-    throw new Error(`Path not resolved: ${addonPath} (tried as-is + packages/addon-${addonPath} + packages/${addonPath})`);
-  }
+  const resolvedPath = path2.isAbsolute(addonPath) && fs2.existsSync(addonPath) ? addonPath : await resolveAddonPathInteractive(addonPath);
   let tgzPath;
   let cleanup = null;
   if (resolvedPath.endsWith(".tgz") || resolvedPath.endsWith(".tar.gz")) {
@@ -702,7 +740,9 @@ async function whoamiCommand(opts) {
     });
     clearTimeout(timer);
     if (res.status === 401) {
-      console.error(`[camstack] \u2717 Token rejected by server (revoked / expired). Run \`camstack login\` to refresh.`);
+      clearSession(session.server);
+      console.error(`[camstack] \u2717 Token rejected by server (revoked / expired).`);
+      console.error(`[camstack]   Local cache cleared. Run \`camstack login\` to issue a new one.`);
       process.exit(2);
     }
     if (!res.ok) {
@@ -1055,6 +1095,135 @@ async function runDev(args) {
   });
 }
 
+// src/commands/watch.ts
+import * as path6 from "path";
+import { parseArgs as parseArgs6 } from "util";
+import * as clack4 from "@clack/prompts";
+var POLL_INTERVAL_MS = 2e3;
+var LOG_BATCH_LIMIT = 100;
+var LEVEL_COLOURS = {
+  debug: "\x1B[90m",
+  // grey
+  info: "\x1B[37m",
+  // white
+  warn: "\x1B[33m",
+  // yellow
+  error: "\x1B[31m"
+  // red
+};
+var RESET = "\x1B[0m";
+function fmtTs(ts) {
+  const d = typeof ts === "number" ? new Date(ts) : new Date(ts);
+  return d.toISOString().slice(11, 23);
+}
+function fmtScope(scope) {
+  if (!scope || scope.length === 0) return "";
+  return ` \x1B[2m[${scope.join(".")}]${RESET}`;
+}
+function printLine(e, addonId) {
+  const colour = LEVEL_COLOURS[e.level] ?? "";
+  process.stdout.write(`${fmtTs(e.timestamp)} ${colour}${e.level.padEnd(5)}${RESET}${fmtScope(e.scope)} \x1B[2m${addonId}${RESET} ${e.message}
+`);
+}
+async function fetchLogs(server, token, addonId, limit) {
+  const input = encodeURIComponent(JSON.stringify({ json: { addonId, limit } }));
+  const url = `${server}/trpc/addons.getLogs?input=${input}`;
+  const res = await fetch(url, { headers: { Authorization: `Bearer ${token}` } });
+  if (!res.ok) {
+    const text2 = await res.text().catch(() => "");
+    throw new Error(`getLogs HTTP ${res.status}: ${text2.slice(0, 200)}`);
+  }
+  const body = await res.json();
+  return body.result?.data?.json ?? [];
+}
+async function runWatch(args) {
+  const { values, positionals } = parseArgs6({
+    args: [...args],
+    options: {
+      server: { type: "string", short: "s" },
+      token: { type: "string", short: "t" },
+      node: { type: "string", short: "n" },
+      cluster: { type: "boolean", short: "c" },
+      "no-build": { type: "boolean" },
+      "build-script": { type: "string" },
+      level: { type: "string", short: "l" },
+      "no-initial-deploy": { type: "boolean" }
+    },
+    strict: true,
+    allowPositionals: true
+  });
+  const addonArg = positionals[0] ?? ".";
+  const session = loadSession(typeof values.server === "string" ? values.server : void 0);
+  const serverUrl = (typeof values.server === "string" ? values.server : void 0) ?? process.env.CAMSTACK_SERVER ?? session?.server;
+  const token = (typeof values.token === "string" ? values.token : void 0) ?? 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"] } : {}
+  };
+  clack4.intro("camstack watch");
+  const resolvedPath = await resolveAddonPathInteractive(addonArg);
+  const addonId = path6.basename(resolvedPath).replace(/^addon-/, "");
+  if (values["no-initial-deploy"] !== true) {
+    await deployAddon(resolvedPath, deployOpts);
+  }
+  clack4.log.info(`Tailing logs for "${addonId}" \u2014 Ctrl-C to stop.`);
+  console.log("");
+  const seenKeys = /* @__PURE__ */ new Set();
+  let firstRound = true;
+  let stop = false;
+  const shutdown = () => {
+    stop = true;
+    console.log("\n[camstack watch] Stopped.");
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  while (!stop) {
+    try {
+      const entries = await fetchLogs(serverUrl, token, addonId, LOG_BATCH_LIMIT);
+      const sorted = [...entries].sort((a, b) => {
+        const ta = typeof a.timestamp === "number" ? a.timestamp : new Date(a.timestamp).getTime();
+        const tb = typeof b.timestamp === "number" ? b.timestamp : new Date(b.timestamp).getTime();
+        return ta - tb;
+      });
+      for (const e of sorted) {
+        if (values.level && e.level !== values.level) continue;
+        const ts = typeof e.timestamp === "number" ? e.timestamp : new Date(e.timestamp).getTime();
+        const key = `${ts}|${e.level}|${e.message}`;
+        if (seenKeys.has(key)) continue;
+        seenKeys.add(key);
+        if (!firstRound) printLine(e, addonId);
+      }
+      if (firstRound) {
+        const tail = sorted.slice(-20);
+        for (const e of tail) {
+          if (values.level && e.level !== values.level) continue;
+          printLine(e, addonId);
+        }
+        firstRound = false;
+      }
+      if (seenKeys.size > 1e3) {
+        const arr = Array.from(seenKeys);
+        seenKeys.clear();
+        arr.slice(-500).forEach((k) => seenKeys.add(k));
+      }
+    } catch (err) {
+      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));
+  }
+}
+
 // src/cli.ts
 var __dirname = dirname(fileURLToPath(import.meta.url));
 var require2 = createRequire(import.meta.url);
@@ -1213,14 +1382,36 @@ function buildCommands() {
         "  -c, --cluster           Push to hub + every online agent (requires admin token)"
       ].join("\n")
     },
+    {
+      name: "watch",
+      summary: "Deploy + tail server-side addon logs (polling /trpc/addons.getLogs)",
+      run: runWatch,
+      help: () => [
+        "Usage: camstack watch [options] [path]",
+        "",
+        "Argument:",
+        "  path                       Addon dir / workspace name / `.` for 5-level scan",
+        "",
+        "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",
+        "      --no-build             Skip `npm run build`",
+        "      --build-script <n>     Override script name (default: build)",
+        "  -l, --level <lvl>          Filter logs by level (debug/info/warn/error)",
+        "      --no-initial-deploy    Skip initial deploy \u2014 only tail existing addon",
+        "",
+        "Each round polls the last 100 entries; new entries (by timestamp+content)",
+        "are printed. Ctrl-C to stop."
+      ].join("\n")
+    },
     {
       name: "dev",
-      aliases: ["watch"],
-      summary: "Watch addon source + auto build & push on every change (live-reload loop)",
+      summary: "Watch addon source + auto build & redeploy 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: "."',
@@ -1277,7 +1468,7 @@ function buildCommands() {
 }
 function parseSubcommandArgs(args, options, allowPositionals) {
   if (args.some((a) => HELP_FLAGS.has(a))) return null;
-  const parsed = parseArgs6({
+  const parsed = parseArgs7({
     args: [...args],
     options,
     allowPositionals,

package/dist/discover-addons-OH6SFUPV.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+
+// src/commands/discover-addons.ts
+import * as fs from "fs";
+import * as path from "path";
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", "dist", "build", ".git", ".next", "coverage", "__tests__", "__snapshots__"]);
+function readPackageJson(dir) {
+  const pkgPath = path.join(dir, "package.json");
+  if (!fs.existsSync(pkgPath)) return null;
+  try {
+    const parsed = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+    return parsed !== null && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function classifyAddon(pkg) {
+  const camstack = pkg["camstack"];
+  if (camstack !== null && typeof camstack === "object") {
+    const manifest = camstack;
+    if (Array.isArray(manifest.addons) && manifest.addons.length > 0) return "manifest";
+  }
+  const name = pkg["name"];
+  if (typeof name === "string" && (name.startsWith("@camstack/addon-") || name.startsWith("camstack-addon-"))) {
+    return "name-prefix";
+  }
+  const keywords = pkg["keywords"];
+  if (Array.isArray(keywords) && keywords.includes("camstack") && keywords.includes("addon")) {
+    return "keywords";
+  }
+  return null;
+}
+function manifestDisplayName(pkg) {
+  const camstack = pkg["camstack"];
+  if (camstack === null || typeof camstack !== "object") return void 0;
+  const manifest = camstack;
+  const first = Array.isArray(manifest.addons) ? manifest.addons[0] : void 0;
+  return first && typeof first.name === "string" ? first.name : void 0;
+}
+function discoverAddonsInCwd(root = process.cwd(), maxDepth = 5) {
+  const out = [];
+  const stack = [{ dir: path.resolve(root), depth: 0 }];
+  while (stack.length > 0) {
+    const { dir, depth } = stack.pop();
+    const pkg = readPackageJson(dir);
+    if (pkg) {
+      const matchedBy = classifyAddon(pkg);
+      if (matchedBy) {
+        const name = typeof pkg["name"] === "string" ? pkg["name"] : path.basename(dir);
+        const displayName = manifestDisplayName(pkg);
+        out.push({
+          path: dir,
+          name,
+          ...displayName ? { displayName } : {},
+          depth,
+          matchedBy
+        });
+        continue;
+      }
+    }
+    if (depth >= maxDepth) continue;
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name.startsWith(".") && entry.name !== ".") continue;
+      if (SKIP_DIRS.has(entry.name)) continue;
+      stack.push({ dir: path.join(dir, entry.name), depth: depth + 1 });
+    }
+  }
+  return out.sort((a, b) => a.depth - b.depth || a.name.localeCompare(b.name));
+}
+export {
+  discoverAddonsInCwd
+};

package/package.json

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