camstack 0.3.1

package/dist/cli.js

@@ -0,0 +1,812 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+import { dirname, resolve as resolve2 } from "path";
+import * as os3 from "os";
+import { parseArgs as parseArgs4 } from "util";
+
+// src/commands/serve.ts
+import { parseArgs } from "util";
+function buildServeEnv(opts) {
+  const env = {
+    CAMSTACK_MODE: "hub"
+  };
+  if (opts.port) env.PORT = opts.port;
+  if (opts.data) env.CAMSTACK_DATA = opts.data;
+  return env;
+}
+async function runServe(args) {
+  const { values } = parseArgs({
+    args: [...args],
+    options: {
+      port: { type: "string", short: "p" },
+      data: { type: "string", short: "d" }
+    },
+    strict: true,
+    allowPositionals: false
+  });
+  const opts = {
+    ...typeof values.port === "string" ? { port: values.port } : {},
+    ...typeof values.data === "string" ? { data: values.data } : {}
+  };
+  Object.assign(process.env, buildServeEnv(opts));
+  await import("@camstack/server/main.js");
+}
+
+// src/commands/agent.ts
+import * as os from "os";
+import { parseArgs as parseArgs2 } from "util";
+function buildAgentEnv(opts) {
+  const hubPort = opts.port ?? "4443";
+  const agentName = opts.name ?? `${os.hostname()}-${os.arch()}`;
+  return {
+    CAMSTACK_MODE: "agent",
+    CAMSTACK_HUB_URL: `ws://${opts.hub}:${hubPort}/agent`,
+    CAMSTACK_HUB_TOKEN: opts.token,
+    CAMSTACK_AGENT_NAME: agentName
+  };
+}
+async function runAgent(args) {
+  const { values } = parseArgs2({
+    args: [...args],
+    options: {
+      hub: { type: "string" },
+      token: { type: "string" },
+      name: { type: "string" },
+      port: { type: "string" }
+    },
+    strict: true,
+    allowPositionals: false
+  });
+  if (typeof values.hub !== "string" || values.hub.length === 0) {
+    throw new Error("--hub is required (e.g. --hub 192.168.1.10)");
+  }
+  if (typeof values.token !== "string" || values.token.length === 0) {
+    throw new Error("--token is required");
+  }
+  const opts = {
+    hub: values.hub,
+    token: values.token,
+    ...typeof values.name === "string" ? { name: values.name } : {},
+    ...typeof values.port === "string" ? { port: values.port } : {}
+  };
+  Object.assign(process.env, buildAgentEnv(opts));
+  await import("@camstack/server/main.js");
+}
+
+// src/commands/setup.ts
+import { execFileSync } from "child_process";
+import * as path from "path";
+import * as fs from "fs";
+import { parseArgs as parseArgs3 } from "util";
+function checkFfmpegAvailable() {
+  try {
+    execFileSync("ffmpeg", ["-version"], { stdio: "pipe", timeout: 5e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getDefaultDataPath() {
+  const root = process.env.CAMSTACK_ROOT;
+  if (root) return path.join(root, "data");
+  return path.join(process.cwd(), "camstack-data");
+}
+function runSetup(args) {
+  const { values } = parseArgs3({
+    args: [...args],
+    options: {
+      data: { type: "string", short: "d" }
+    },
+    strict: true,
+    allowPositionals: false
+  });
+  const dataPath = typeof values.data === "string" ? values.data : getDefaultDataPath();
+  console.log("[camstack] Running setup...");
+  console.log(`[camstack] Data directory: ${dataPath}`);
+  fs.mkdirSync(dataPath, { recursive: true });
+  console.log("[camstack] Data directory: OK");
+  if (checkFfmpegAvailable()) {
+    console.log("[camstack] ffmpeg: found in PATH");
+  } else {
+    console.warn("[camstack] ffmpeg: NOT FOUND \u2014 install ffmpeg for decode/transcode support");
+    console.warn("[camstack]   macOS: brew install ffmpeg");
+    console.warn("[camstack]   Linux: apt install ffmpeg / dnf install ffmpeg");
+  }
+  let pythonFound = false;
+  for (const bin of ["python3", "python"]) {
+    try {
+      const version = execFileSync(bin, ["--version"], { encoding: "utf8", timeout: 5e3 }).trim();
+      console.log(`[camstack] Python: ${version} (${bin})`);
+      pythonFound = true;
+      break;
+    } catch {
+    }
+  }
+  if (!pythonFound) {
+    console.log("[camstack] Python: not found (optional \u2014 needed for ML detection addons)");
+  }
+  console.log("[camstack] Setup complete.");
+}
+
+// src/commands/deploy.ts
+import { execSync } from "child_process";
+import * as fs2 from "fs";
+import * as path2 from "path";
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function toDeployResult(value) {
+  if (!isRecord(value)) return { success: false, error: "Invalid response shape" };
+  return {
+    success: value["success"] === true,
+    packageName: typeof value["packageName"] === "string" ? value["packageName"] : void 0,
+    version: typeof value["version"] === "string" ? value["version"] : void 0,
+    target: typeof value["target"] === "string" ? value["target"] : void 0,
+    addonId: typeof value["addonId"] === "string" ? value["addonId"] : void 0,
+    capabilities: Array.isArray(value["capabilities"]) ? value["capabilities"].filter((c) => typeof c === "string") : void 0,
+    error: typeof value["error"] === "string" ? value["error"] : void 0
+  };
+}
+function toPackFilenames(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.flatMap((entry) => {
+      if (!isRecord(entry)) return [];
+      return typeof entry["filename"] === "string" ? [entry["filename"]] : [];
+    });
+  } catch {
+    return [];
+  }
+}
+function resolveAddonPath(arg) {
+  const absolute = path2.resolve(arg);
+  if (fs2.existsSync(absolute)) return absolute;
+  for (const candidate of [
+    path2.resolve("packages", `addon-${arg}`),
+    path2.resolve("packages", arg)
+  ]) {
+    if (fs2.existsSync(candidate) && fs2.existsSync(path2.join(candidate, "package.json"))) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function packAddon(addonDir) {
+  const pkgJsonPath = path2.join(addonDir, "package.json");
+  if (!fs2.existsSync(pkgJsonPath)) {
+    throw new Error(`No package.json found in: ${addonDir}`);
+  }
+  console.log(`[camstack] Packing addon from ${addonDir}...`);
+  const packOutput = execSync("npm pack --json 2>/dev/null || npm pack", {
+    cwd: addonDir,
+    encoding: "utf8",
+    timeout: 6e4
+  }).trim();
+  const parsedFilenames = toPackFilenames(packOutput);
+  let tgzFilename;
+  if (parsedFilenames.length > 0) {
+    tgzFilename = parsedFilenames[0] ?? "";
+  } else {
+    const lines = packOutput.split("\n");
+    tgzFilename = lines[lines.length - 1]?.trim() ?? "";
+  }
+  if (!tgzFilename) throw new Error("npm pack did not produce a .tgz file");
+  const tgzPath = path2.join(addonDir, tgzFilename);
+  if (!fs2.existsSync(tgzPath)) {
+    throw new Error(`Expected tgz file not found: ${tgzPath}`);
+  }
+  console.log(`[camstack] Packed: ${tgzFilename}`);
+  return {
+    tgzPath,
+    cleanup: () => {
+      try {
+        if (fs2.existsSync(tgzPath)) fs2.unlinkSync(tgzPath);
+      } catch {
+      }
+    }
+  };
+}
+async function fetchOnlineAgents(serverUrl, token) {
+  const url = `${serverUrl}/trpc/nodes.topology?input=${encodeURIComponent('{"json":null}')}`;
+  const res = await fetch(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();
+  const nodes = body.result?.data?.json ?? [];
+  return nodes.filter((n) => n.isOnline && !n.isHub);
+}
+async function uploadToTarget(args) {
+  const { serverUrl, token, tgzPath, nodeId, addonId } = args;
+  const fileBuffer = fs2.readFileSync(tgzPath);
+  const formData = new FormData();
+  const blob = new Blob([fileBuffer], { type: "application/gzip" });
+  formData.append("file", blob, path2.basename(tgzPath));
+  if (nodeId) formData.append("nodeId", nodeId);
+  if (addonId) formData.append("addonId", addonId);
+  const response = await fetch(`${serverUrl}/api/addons/upload`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${token}` },
+    body: formData
+  });
+  const result = toDeployResult(await response.json().catch(() => ({})));
+  if (!response.ok) {
+    return {
+      success: false,
+      error: result.error ?? `Server returned ${response.status} ${response.statusText}`
+    };
+  }
+  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})`);
+  }
+  let tgzPath;
+  let cleanup = null;
+  if (resolvedPath.endsWith(".tgz") || resolvedPath.endsWith(".tar.gz")) {
+    if (!fs2.existsSync(resolvedPath)) throw new Error(`File not found: ${resolvedPath}`);
+    tgzPath = resolvedPath;
+  } else {
+    const packed = packAddon(resolvedPath);
+    tgzPath = packed.tgzPath;
+    cleanup = packed.cleanup;
+  }
+  try {
+    const targets = [];
+    if (opts.nodeId) {
+      targets.push({ nodeId: opts.nodeId, label: opts.nodeId });
+    } else if (opts.cluster) {
+      targets.push({ label: "hub" });
+      try {
+        const agents = await fetchOnlineAgents(opts.serverUrl, opts.token);
+        for (const a of agents) {
+          targets.push({ nodeId: a.id, label: `${a.name} (${a.id})` });
+        }
+        if (agents.length === 0) {
+          console.log("[camstack] --cluster: no online agents found, pushing to hub only");
+        } else {
+          console.log(`[camstack] --cluster: pushing to hub + ${agents.length} online agent(s)`);
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`[camstack] --cluster: failed to enumerate agents \u2014 falling back to hub only (${msg})`);
+      }
+    } else {
+      targets.push({ label: "hub" });
+    }
+    const outcomes = [];
+    for (const t of targets) {
+      console.log(`[camstack] \u2192 Deploying ${path2.basename(tgzPath)} to ${t.label}...`);
+      const result = await uploadToTarget({
+        serverUrl: opts.serverUrl,
+        token: opts.token,
+        tgzPath,
+        ...t.nodeId ? { nodeId: t.nodeId } : {}
+      });
+      if (result.success) {
+        const id = result.packageName ?? result.addonId ?? "?";
+        const ver = result.version ? `@${result.version}` : "";
+        const detail = `${id}${ver}`;
+        console.log(`[camstack]   \u2713 ${t.label}: ${detail}`);
+        outcomes.push({ target: t.label, ok: true, detail });
+      } else {
+        const detail = result.error ?? "unknown";
+        console.error(`[camstack]   \u2717 ${t.label}: ${detail}`);
+        outcomes.push({ target: t.label, ok: false, detail });
+      }
+    }
+    const failed = outcomes.filter((o) => !o.ok);
+    if (failed.length > 0) {
+      console.error(`[camstack] ${failed.length}/${outcomes.length} target(s) failed`);
+      process.exit(1);
+    }
+    console.log(`[camstack] \u2713 Deployed to ${outcomes.length} target(s)`);
+  } finally {
+    if (cleanup) cleanup();
+  }
+}
+
+// src/commands/auth.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+import * as os2 from "os";
+import * as readline from "readline";
+var SESSION_DIR = path3.join(os2.homedir(), ".camstack");
+function sessionFileForServer(serverUrl) {
+  const slug = serverUrl.replace(/^https?:\/\//, "").replace(/[:/?#]+/g, "_").replace(/_+$/, "");
+  return path3.join(SESSION_DIR, `${slug}.json`);
+}
+function resolveSessionFile(serverUrl) {
+  if (serverUrl) {
+    const p = sessionFileForServer(serverUrl);
+    return fs3.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 (files.length === 0) return null;
+  return files.map((f) => ({ f, mtime: fs3.statSync(f).mtimeMs })).sort((a, b) => b.mtime - a.mtime)[0].f;
+}
+function loadSession(serverUrl) {
+  const file = resolveSessionFile(serverUrl);
+  if (!file) return null;
+  try {
+    return JSON.parse(fs3.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function saveSession(session) {
+  if (!fs3.existsSync(SESSION_DIR)) {
+    fs3.mkdirSync(SESSION_DIR, { recursive: true, mode: 448 });
+  }
+  const file = sessionFileForServer(session.server);
+  fs3.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);
+    return true;
+  }
+  return false;
+}
+function prompt(question, masked = false) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve3) => {
+    if (!masked) {
+      rl.question(question, (answer) => {
+        rl.close();
+        resolve3(answer);
+      });
+      return;
+    }
+    process.stdout.write(question);
+    const stdin = process.stdin;
+    let value = "";
+    const onData = (chunk) => {
+      const s = chunk.toString("utf8");
+      for (const ch of s) {
+        if (ch === "\r" || ch === "\n") {
+          stdin.removeListener("data", onData);
+          stdin.setRawMode(false);
+          stdin.pause();
+          rl.close();
+          process.stdout.write("\n");
+          resolve3(value);
+          return;
+        }
+        if (ch === "") {
+          process.exit(130);
+        }
+        if (ch === "\x7F" || ch === "\b") {
+          if (value.length > 0) {
+            value = value.slice(0, -1);
+            process.stdout.write("\b \b");
+          }
+          continue;
+        }
+        value += ch;
+        process.stdout.write("*");
+      }
+    };
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.on("data", onData);
+  });
+}
+async function callTrpcMutation(url, authorization, payload, isPayload) {
+  const headers = { "Content-Type": "application/json" };
+  if (authorization) headers["Authorization"] = authorization;
+  const res = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ "0": { json: payload } })
+  });
+  const text = await res.text();
+  const parseJson = (raw) => {
+    if (!raw) return null;
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return raw;
+    }
+  };
+  const body = parseJson(text);
+  if (!res.ok) {
+    const errMsg2 = body !== null && typeof body === "object" && "error" in body ? String(body.error) : text.slice(0, 200);
+    throw new Error(`${res.status} ${res.statusText}: ${errMsg2}`);
+  }
+  const first = Array.isArray(body) ? body[0] : body;
+  if (first === null || typeof first !== "object") throw new Error(`${url}: response missing envelope`);
+  const result = first.result;
+  if (result === null || result === void 0 || typeof result !== "object") throw new Error(`${url}: response missing result`);
+  const data = result.data;
+  if (data === null || data === void 0 || typeof data !== "object") throw new Error(`${url}: response missing result.data`);
+  const json = data.json;
+  if (!isPayload(json)) throw new Error(`${url}: response payload shape mismatch`);
+  return json;
+}
+function isLoginPayload(value) {
+  if (value === null || typeof value !== "object") return false;
+  const v = value;
+  if (typeof v.token !== "string") return false;
+  if (v.user === null || typeof v.user !== "object") return false;
+  const u = v.user;
+  return typeof u.id === "string" && typeof u.username === "string";
+}
+function isCreateScopedTokenPayload(value) {
+  if (value === null || typeof value !== "object") return false;
+  const v = value;
+  if (typeof v.token !== "string") return false;
+  if (v.record === null || typeof v.record !== "object") return false;
+  return typeof v.record.id === "string";
+}
+function isUnknown(_value) {
+  return true;
+}
+async function loginCommand(opts) {
+  const server = opts.server;
+  const username = opts.username ?? await prompt(`Username for ${server}: `);
+  const password = opts.password ?? await prompt(`Password: `, true);
+  console.log(`[camstack] Authenticating against ${server}\u2026`);
+  const login = await callTrpcMutation(
+    `${server}/trpc/auth.login?batch=1`,
+    void 0,
+    { username, password },
+    isLoginPayload
+  );
+  const jwt = login.token;
+  const user = login.user;
+  const prior = loadSession(server);
+  if (prior && prior.tokenId) {
+    try {
+      await callTrpcMutation(
+        `${server}/trpc/userManagement.revokeScopedToken?batch=1`,
+        `Bearer ${jwt}`,
+        { id: prior.tokenId },
+        isUnknown
+      );
+    } catch (err) {
+      console.warn(`[camstack] Failed to revoke prior token (${prior.tokenId}): ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  console.log(`[camstack] Creating upload-only scoped token\u2026`);
+  const tokenName = opts.tokenName ?? `camstack-cli@${os2.hostname()}`;
+  const scopes = [{ type: "route-prefix", target: "/api/addons/upload" }];
+  const created = await callTrpcMutation(
+    `${server}/trpc/userManagement.createScopedToken?batch=1`,
+    `Bearer ${jwt}`,
+    { name: tokenName, scopes },
+    isCreateScopedTokenPayload
+  );
+  const scopedToken = created.token;
+  const tokenId = created.record.id;
+  const session = {
+    server,
+    username: user.username,
+    tokenId,
+    token: scopedToken,
+    scopes,
+    createdAt: Date.now()
+  };
+  const file = saveSession(session);
+  console.log(`[camstack] \u2713 Logged in as ${user.username} \u2192 ${server}`);
+  console.log(`[camstack]   Scoped token: ${scopedToken.slice(0, 12)}\u2026 (id: ${tokenId})`);
+  console.log(`[camstack]   Cached at:    ${file}`);
+  console.log(`[camstack]   Scope:        upload addons only \u2014 no other API surface granted.`);
+}
+async function logoutCommand(opts) {
+  const session = loadSession(opts.server);
+  if (!session) {
+    console.log(`[camstack] No active session for ${opts.server}.`);
+    return;
+  }
+  try {
+    await callTrpcMutation(
+      `${session.server}/trpc/userManagement.revokeScopedToken?batch=1`,
+      `Bearer ${session.token}`,
+      { id: session.tokenId },
+      isUnknown
+    );
+  } catch (err) {
+    console.warn(`[camstack] Server-side revoke failed (${err instanceof Error ? err.message : String(err)}). Removing local cache anyway.`);
+  }
+  clearSession(session.server);
+  console.log(`[camstack] \u2713 Logged out of ${session.server}`);
+}
+function whoamiCommand(opts) {
+  const session = loadSession(opts.server);
+  if (!session) {
+    console.log(`[camstack] Not logged in${opts.server ? ` to ${opts.server}` : ""}.`);
+    process.exit(1);
+  }
+  console.log(`[camstack] Active session:`);
+  console.log(`  server:    ${session.server}`);
+  console.log(`  username:  ${session.username}`);
+  console.log(`  token:     ${session.token.slice(0, 12)}\u2026 (id: ${session.tokenId})`);
+  console.log(`  scopes:    ${session.scopes.map((s) => `${s.type}:${s.target}`).join(", ")}`);
+  console.log(`  createdAt: ${new Date(session.createdAt).toISOString()}`);
+}
+
+// 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"));
+  pkgVersion = pkg.version;
+} catch {
+}
+function errMsg(err) {
+  if (err instanceof Error) return err.message;
+  if (typeof err === "string") return err;
+  return String(err);
+}
+var HELP_FLAGS = /* @__PURE__ */ new Set(["-h", "--help"]);
+function printGlobalHelp(commands) {
+  const lines = [];
+  lines.push(`camstack v${pkgVersion} \u2014 self-hosted camera platform`);
+  lines.push("");
+  lines.push("Usage: camstack <command> [options]");
+  lines.push("");
+  lines.push("Commands:");
+  const widest = Math.max(...commands.map((c) => c.name.length));
+  for (const cmd of commands) {
+    const padded = cmd.name.padEnd(widest, " ");
+    const aliasNote = cmd.aliases && cmd.aliases.length > 0 ? ` (alias: ${cmd.aliases.join(", ")})` : "";
+    lines.push(`  ${padded}  ${cmd.summary}${aliasNote}`);
+  }
+  lines.push("");
+  lines.push("Global flags:");
+  lines.push("  -v, --version    Print version");
+  lines.push("  -h, --help       Show this help, or per-command help with `camstack <cmd> --help`");
+  console.log(lines.join("\n"));
+}
+function buildCommands() {
+  return [
+    {
+      name: "serve",
+      summary: "Start CamStack in hub mode",
+      run: runServe,
+      help: () => [
+        "Usage: camstack serve [options]",
+        "",
+        "Options:",
+        "  -p, --port <port>      Port to listen on",
+        "  -d, --data <path>      Data directory path"
+      ].join("\n")
+    },
+    {
+      name: "agent",
+      summary: "Start CamStack in agent mode (worker node)",
+      run: runAgent,
+      help: () => [
+        "Usage: camstack agent [options]",
+        "",
+        "Required:",
+        "  --hub <ip>             Hub server IP address",
+        "  --token <token>        Authentication token",
+        "",
+        "Optional:",
+        "  --name <name>          Agent name (default: hostname-arch)",
+        "  --port <port>          Hub port (default: 4443)"
+      ].join("\n")
+    },
+    {
+      name: "setup",
+      summary: "Check dependencies and create default config",
+      run: runSetup,
+      help: () => [
+        "Usage: camstack setup [options]",
+        "",
+        "Options:",
+        "  -d, --data <path>      Data directory path"
+      ].join("\n")
+    },
+    {
+      name: "login",
+      summary: "Authenticate and cache a long-lived upload-only token at ~/.camstack/<host>.json",
+      run: runLogin,
+      help: () => [
+        "Usage: camstack login [options]",
+        "",
+        "Options:",
+        "  -s, --server <url>     CamStack server URL (default: $CAMSTACK_SERVER or https://localhost:4443)",
+        "  -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@${os3.hostname()})`
+      ].join("\n")
+    },
+    {
+      name: "logout",
+      summary: "Revoke the cached scoped token and drop the local session file",
+      run: runLogout,
+      help: () => [
+        "Usage: camstack logout [options]",
+        "",
+        "Options:",
+        "  -s, --server <url>     CamStack server URL (default: $CAMSTACK_SERVER or https://localhost:4443)"
+      ].join("\n")
+    },
+    {
+      name: "whoami",
+      summary: "Print the active cached session (server + username + scopes)",
+      run: runWhoami,
+      help: () => [
+        "Usage: camstack whoami [options]",
+        "",
+        "Options:",
+        "  -s, --server <url>     Pick a specific session (default: most recently used)"
+      ].join("\n")
+    },
+    {
+      name: "deploy",
+      aliases: ["push"],
+      summary: "Build and deploy an addon to a CamStack server (hub by default, or cluster-wide)",
+      run: runDeploy,
+      help: () => [
+        "Usage: camstack deploy [options] [path]",
+        "       camstack push   [options] [path]    (alias)",
+        "",
+        "Argument:",
+        '  path                    Path to addon dir, .tgz, or workspace name (e.g. "tailscale")',
+        '                          Default: "." (current dir)',
+        "",
+        "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: "info",
+      summary: "Print detailed version and platform info",
+      run: () => {
+        console.log(`camstack v${pkgVersion}`);
+        console.log(`Platform: ${os3.platform()}-${os3.arch()}`);
+        console.log(`Node.js: ${process.version}`);
+        console.log(`CPU: ${os3.cpus()[0]?.model ?? "unknown"} (${os3.cpus().length} cores)`);
+        console.log(`Memory: ${Math.round(os3.totalmem() / 1024 / 1024)} MB`);
+      },
+      help: () => "Usage: camstack info"
+    }
+  ];
+}
+function parseSubcommandArgs(args, options, allowPositionals) {
+  if (args.some((a) => HELP_FLAGS.has(a))) return null;
+  const parsed = parseArgs4({
+    args: [...args],
+    options,
+    allowPositionals,
+    strict: true
+  });
+  return {
+    values: parsed.values,
+    positionals: parsed.positionals
+  };
+}
+async function runLogin(args) {
+  const parsed = parseSubcommandArgs(args, {
+    server: { type: "string", short: "s" },
+    username: { type: "string", short: "u" },
+    password: { type: "string", short: "p" },
+    "token-name": { type: "string" }
+  }, false);
+  if (!parsed) {
+    console.log(commandHelp("login"));
+    return;
+  }
+  const server = stringOpt(parsed.values, "server") ?? process.env.CAMSTACK_SERVER ?? "https://localhost:4443";
+  await loginCommand({
+    server,
+    ...optionalString(parsed.values, "username"),
+    ...optionalString(parsed.values, "password"),
+    ...optionalString(parsed.values, "token-name", "tokenName")
+  });
+}
+async function runLogout(args) {
+  const parsed = parseSubcommandArgs(args, {
+    server: { type: "string", short: "s" }
+  }, false);
+  if (!parsed) {
+    console.log(commandHelp("logout"));
+    return;
+  }
+  const server = stringOpt(parsed.values, "server") ?? process.env.CAMSTACK_SERVER ?? "https://localhost:4443";
+  await logoutCommand({ server });
+}
+function runWhoami(args) {
+  const parsed = parseSubcommandArgs(args, {
+    server: { type: "string", short: "s" }
+  }, false);
+  if (!parsed) {
+    console.log(commandHelp("whoami"));
+    return;
+  }
+  const server = stringOpt(parsed.values, "server");
+  whoamiCommand(server ? { server } : {});
+}
+async function runDeploy(args) {
+  const parsed = parseSubcommandArgs(args, {
+    server: { type: "string", short: "s" },
+    token: { type: "string", short: "t" },
+    node: { type: "string", short: "n" },
+    cluster: { type: "boolean", short: "c" }
+  }, true);
+  if (!parsed) {
+    console.log(commandHelp("deploy"));
+    return;
+  }
+  const addonPath = parsed.positionals[0] ?? ".";
+  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);
+  }
+  const nodeId = stringOpt(parsed.values, "node");
+  const cluster = boolOpt(parsed.values, "cluster");
+  if (nodeId && cluster) {
+    console.error("[camstack] Error: --node and --cluster are mutually exclusive.");
+    process.exit(1);
+  }
+  await deployAddon(addonPath, {
+    serverUrl: server,
+    token,
+    ...nodeId ? { nodeId } : {},
+    ...cluster ? { cluster: true } : {}
+  });
+}
+function commandHelp(name) {
+  const cmd = buildCommands().find((c) => c.name === name);
+  return cmd ? cmd.help() : "";
+}
+function stringOpt(values, key) {
+  const v = values[key];
+  return typeof v === "string" ? v : void 0;
+}
+function boolOpt(values, key) {
+  return values[key] === true;
+}
+function optionalString(values, key, outKey) {
+  const v = values[key];
+  if (typeof v !== "string") return {};
+  return { [outKey ?? key]: v };
+}
+async function main() {
+  const argv = process.argv.slice(2);
+  const commands = buildCommands();
+  if (argv.length === 0 || argv.length === 1 && HELP_FLAGS.has(argv[0] ?? "")) {
+    printGlobalHelp(commands);
+    return;
+  }
+  if (argv[0] === "-v" || argv[0] === "--version") {
+    console.log(pkgVersion);
+    return;
+  }
+  const cmdName = argv[0] ?? "";
+  const cmd = commands.find((c) => c.name === cmdName || (c.aliases?.includes(cmdName) ?? false));
+  if (!cmd) {
+    console.error(`[camstack] Unknown command: ${cmdName}`);
+    console.error("Run `camstack --help` for the list of commands.");
+    process.exit(1);
+  }
+  try {
+    await cmd.run(argv.slice(1));
+  } catch (err) {
+    console.error(`[camstack] ${cmd.name} failed:`, errMsg(err));
+    process.exit(1);
+  }
+}
+void main();

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "camstack",
+  "version": "0.3.1",
+  "description": "CLI tool for managing and running CamStack server",
+  "keywords": [
+    "camstack",
+    "cli",
+    "camera",
+    "nvr",
+    "detection"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/camstack/server"
+  },
+  "type": "module",
+  "bin": {
+    "camstack": "dist/cli.js"
+  },
+  "preferGlobal": true,
+  "engines": {
+    "node": ">=18.3"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "publish": "npm publish"
+  },
+  "optionalDependencies": {
+    "@camstack/server": "^0.1.0"
+  },
+  "devDependencies": {
+    "@camstack/server": "*",
+    "@types/node": "^22",
+    "tsup": "^8.5.1",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  }
+}