@cira-app/cli 0.1.0

package/bin/cira.js

@@ -0,0 +1,1348 @@
+#!/usr/bin/env node
+
+// dist/config.js
+import { homedir } from "node:os";
+import { chmodSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+var DEFAULT_API_URL = "https://cira-aumitshiv.vercel.app";
+function ciraHome() {
+  return process.env["CIRA_HOME"] ?? join(homedir(), ".cira");
+}
+function configPath() {
+  return join(ciraHome(), "config.json");
+}
+function readConfig() {
+  const apiUrl = process.env["CIRA_API_URL"] ?? DEFAULT_API_URL;
+  try {
+    const raw = JSON.parse(readFileSync(configPath(), "utf8"));
+    return {
+      // An explicit environment override always wins over the stored value.
+      apiUrl: process.env["CIRA_API_URL"] ?? raw.apiUrl ?? DEFAULT_API_URL,
+      ...raw.token !== void 0 ? { token: raw.token } : {},
+      ...raw.email !== void 0 ? { email: raw.email } : {}
+    };
+  } catch {
+    return { apiUrl };
+  }
+}
+function writeConfig(config) {
+  const path = configPath();
+  mkdirSync(dirname(path), { recursive: true, mode: 448 });
+  writeFileSync(path, `${JSON.stringify(config, null, 2)}
+`, { mode: 384 });
+  chmodSync(path, 384);
+}
+function clearConfig() {
+  try {
+    rmSync(configPath());
+  } catch {
+  }
+}
+
+// dist/api.js
+var ApiError = class extends Error {
+  status;
+  constructor(message, status2) {
+    super(message);
+    this.status = status2;
+    this.name = "ApiError";
+  }
+};
+async function api(path, options = {}) {
+  const config = readConfig();
+  const token = options.token ?? config.token;
+  let response;
+  try {
+    response = await fetch(`${config.apiUrl}${path}`, {
+      method: options.method ?? "GET",
+      headers: {
+        "content-type": options.raw === void 0 ? "application/json" : "application/octet-stream",
+        ...options.raw !== void 0 ? { "x-cira-sha": options.raw.sha } : {},
+        ...token !== void 0 ? { authorization: `Bearer ${token}` } : {}
+      },
+      ...options.raw !== void 0 ? { body: new Uint8Array(options.raw.body) } : options.body !== void 0 ? { body: JSON.stringify(options.body) } : {}
+    });
+  } catch {
+    throw new ApiError(`Could not reach Cira at ${config.apiUrl}.`, 0);
+  }
+  if (response.status === 401) {
+    throw new ApiError("You are not signed in. Run: cira login", 401);
+  }
+  if (!response.ok) {
+    const said = await response.json().then((body) => typeof body === "object" && body !== null && "error" in body ? String(body.error) : null).catch(() => null);
+    throw new ApiError(said ?? `Cira returned an error (${response.status}).`, response.status);
+  }
+  return await response.json();
+}
+
+// dist/deploy.js
+import { basename } from "node:path";
+
+// dist/files.js
+import { createHash } from "node:crypto";
+import { readFileSync as readFileSync2, readdirSync } from "node:fs";
+import { join as join2, relative, sep } from "node:path";
+
+// ../deploy/dist/bundle.js
+var EXCLUDED_DIRECTORIES = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".next",
+  ".turbo",
+  ".vercel",
+  ".cira",
+  "dist",
+  "build",
+  "out",
+  "coverage",
+  ".cache",
+  ".DS_Store"
+]);
+var EXCLUDED_FILE_PATTERNS = [
+  /^\.env($|\.)/,
+  /\.log$/,
+  /^\.DS_Store$/,
+  /\.tsbuildinfo$/,
+  /^npm-debug\.log/,
+  /^yarn-error\.log/
+];
+function isExcludedDirectory(name) {
+  return EXCLUDED_DIRECTORIES.has(name);
+}
+function isExcludedFile(name) {
+  if (name === ".env.example")
+    return false;
+  return EXCLUDED_FILE_PATTERNS.some((pattern) => pattern.test(name));
+}
+function shouldUpload(relativePath) {
+  const segments = relativePath.split("/").filter((s) => s !== "");
+  if (segments.length === 0)
+    return false;
+  for (const segment of segments.slice(0, -1)) {
+    if (isExcludedDirectory(segment))
+      return false;
+  }
+  const name = segments[segments.length - 1];
+  if (name === void 0)
+    return false;
+  if (isExcludedDirectory(name))
+    return false;
+  return !isExcludedFile(name);
+}
+var MAX_BUNDLE_BYTES = 100 * 1024 * 1024;
+var MAX_FILE_BYTES = 25 * 1024 * 1024;
+
+// dist/files.js
+function collectFiles(root) {
+  const found = [];
+  const walk = (dir) => {
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = join2(dir, entry.name);
+      const rel = relative(root, full).split(sep).join("/");
+      if (!shouldUpload(rel))
+        continue;
+      if (entry.isDirectory()) {
+        walk(full);
+        continue;
+      }
+      if (!entry.isFile())
+        continue;
+      try {
+        const body = readFileSync2(full);
+        found.push({
+          path: rel,
+          size: body.byteLength,
+          sha: createHash("sha1").update(body).digest("hex")
+        });
+      } catch {
+      }
+    }
+  };
+  walk(root);
+  return found.sort((a, b) => a.path.localeCompare(b.path));
+}
+function readFileBody(root, relativePath) {
+  return readFileSync2(join2(root, relativePath));
+}
+function readSourceFiles(root, files) {
+  const wanted = files.filter((file) => file.path === "package.json" || /\.(ts|tsx|js|jsx|mjs)$/.test(file.path));
+  const out = [];
+  for (const file of wanted) {
+    if (file.size > 4e5)
+      continue;
+    try {
+      out.push({ path: file.path, text: readFileSync2(join2(root, file.path), "utf8") });
+    } catch {
+    }
+  }
+  return out;
+}
+
+// ../extract/dist/extract.js
+var HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE"];
+var LIMITS = {
+  routes: 60,
+  functions: 80,
+  shapes: 60,
+  excerptChars: 900,
+  shapeChars: 700,
+  fileChars: 12e4
+};
+function extractRepo(files) {
+  const notes = [];
+  const summary = {
+    framework: "nextjs",
+    packageName: null,
+    dependencies: [],
+    routes: [],
+    functions: [],
+    shapes: [],
+    notes
+  };
+  const source = files.filter((f) => isInteresting(f.path));
+  const manifest = files.find((f) => f.path === "package.json");
+  if (manifest !== void 0) {
+    const parsed = readManifest(manifest.text);
+    summary.packageName = parsed.name;
+    summary.dependencies = parsed.dependencies;
+  }
+  for (const file of source) {
+    if (file.text.length > LIMITS.fileChars) {
+      notes.push(`${file.path} was too large to read.`);
+      continue;
+    }
+    const route = readRoute(file);
+    if (route !== null)
+      summary.routes.push(route);
+    summary.functions.push(...readFunctions(file));
+    summary.shapes.push(...readShapes(file));
+  }
+  summary.routes.sort((a, b) => a.path.localeCompare(b.path));
+  summary.functions.sort((a, b) => a.name.localeCompare(b.name));
+  summary.shapes.sort((a, b) => a.name.localeCompare(b.name));
+  summary.routes = cap(summary.routes, LIMITS.routes, "routes", notes);
+  summary.functions = cap(summary.functions, LIMITS.functions, "functions", notes);
+  summary.shapes = cap(summary.shapes, LIMITS.shapes, "shapes", notes);
+  return summary;
+}
+function cap(items, limit, what, notes) {
+  if (items.length <= limit)
+    return items;
+  notes.push(`Only the first ${limit} ${what} of ${items.length} are described here.`);
+  return items.slice(0, limit);
+}
+function isInteresting(path) {
+  if (!/\.(ts|tsx|js|jsx|mjs)$/.test(path))
+    return false;
+  const noisy = [
+    "node_modules/",
+    ".next/",
+    "dist/",
+    "build/",
+    "out/",
+    "coverage/",
+    "public/",
+    ".turbo/",
+    ".vercel/"
+  ];
+  if (noisy.some((prefix) => path.includes(prefix)))
+    return false;
+  if (/\.(test|spec)\.[tj]sx?$/.test(path))
+    return false;
+  if (/\.d\.ts$/.test(path))
+    return false;
+  if (/(^|\/)(next-env|next\.config|tailwind\.config|postcss\.config)\b/.test(path)) {
+    return false;
+  }
+  return true;
+}
+function readManifest(text) {
+  try {
+    const pkg = JSON.parse(text);
+    return {
+      name: typeof pkg.name === "string" ? pkg.name : null,
+      // Names only: a version number says nothing about what an app does, and
+      // the list is here to hint at the domain (a database client, a payments
+      // SDK) rather than to describe a build.
+      dependencies: Object.keys({ ...pkg.dependencies, ...pkg.devDependencies }).sort()
+    };
+  } catch {
+    return { name: null, dependencies: [] };
+  }
+}
+function routePathFor(file) {
+  const path = file.replace(/^\.\//, "");
+  const app = /^(?:src\/)?app\/(.*\/)?route\.[tj]sx?$/.exec(path);
+  if (app !== null) {
+    const segments = (app[1] ?? "").split("/").filter((s) => s !== "").filter((s) => !(s.startsWith("(") && s.endsWith(")"))).filter((s) => !s.startsWith("_"));
+    return `/${segments.join("/")}`.replace(/\/$/, "") || "/";
+  }
+  const pages = /^(?:src\/)?pages\/(api\/.*)\.[tj]sx?$/.exec(path);
+  if (pages !== null) {
+    const withoutIndex = (pages[1] ?? "").replace(/\/index$/, "");
+    return `/${withoutIndex}`;
+  }
+  return null;
+}
+function readRoute(file) {
+  const path = routePathFor(file.path);
+  if (path === null)
+    return null;
+  const isAppRouter = /^(?:src\/)?app\//.test(file.path.replace(/^\.\//, ""));
+  const methods = isAppRouter ? HTTP_METHODS.filter((method) => exportsHandler(file.text, method)) : methodsFromPagesHandler(file.text);
+  if (methods.length === 0)
+    return null;
+  return {
+    path,
+    methods,
+    file: file.path,
+    dynamic: path.includes("["),
+    doc: leadingDoc(file.text, new RegExp(`(?:async\\s+)?function\\s+${methods[0]}\\b`)) ?? fileDoc(file.text),
+    excerpt: trim(stripImports(file.text), LIMITS.excerptChars)
+  };
+}
+function exportsHandler(text, method) {
+  const patterns = [
+    new RegExp(`export\\s+(?:async\\s+)?function\\s+${method}\\s*\\(`),
+    new RegExp(`export\\s+(?:const|let|var)\\s+${method}\\s*[:=]`),
+    new RegExp(`export\\s*\\{[^}]*\\b${method}\\b[^}]*\\}`)
+  ];
+  return patterns.some((pattern) => pattern.test(text));
+}
+function methodsFromPagesHandler(text) {
+  if (!/export\s+default\s/.test(text))
+    return [];
+  const found = HTTP_METHODS.filter((method) => new RegExp(`method\\s*===?\\s*["'\`]${method}["'\`]`, "i").test(text));
+  return found.length > 0 ? found : ["GET", "POST"];
+}
+function readFunctions(file) {
+  const serverAction = /^\s*["']use server["']/m.test(file.text);
+  const found = [];
+  const pattern = /export\s+(?:async\s+)?function\s+([A-Za-z_$][\w$]*)\s*\(([^)]*)\)([^{;]*)/g;
+  for (const match of file.text.matchAll(pattern)) {
+    const name = match[1];
+    if (name === void 0)
+      continue;
+    if (HTTP_METHODS.includes(name))
+      continue;
+    found.push({
+      name,
+      file: file.path,
+      signature: oneLine(`${name}(${match[2] ?? ""})${match[3] ?? ""}`),
+      doc: leadingDoc(file.text, new RegExp(`function\\s+${name}\\b`)),
+      serverAction
+    });
+  }
+  return found;
+}
+function readShapes(file) {
+  const found = [];
+  for (const match of file.text.matchAll(/export\s+interface\s+([A-Za-z_$][\w$]*)\s*(?:extends[^{]*)?\{/g)) {
+    const name = match[1];
+    if (name === void 0 || match.index === void 0)
+      continue;
+    found.push({
+      name,
+      file: file.path,
+      kind: "interface",
+      text: trim(block(file.text, match.index), LIMITS.shapeChars)
+    });
+  }
+  for (const match of file.text.matchAll(/export\s+type\s+([A-Za-z_$][\w$]*)\s*=\s*([^;]{0,400});/g)) {
+    const name = match[1];
+    if (name === void 0)
+      continue;
+    found.push({
+      name,
+      file: file.path,
+      kind: "type",
+      text: oneLine(`type ${name} = ${match[2] ?? ""}`)
+    });
+  }
+  for (const match of file.text.matchAll(/(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*z\s*\.\s*object\s*\(/g)) {
+    const name = match[1];
+    if (name === void 0 || match.index === void 0)
+      continue;
+    found.push({
+      name,
+      file: file.path,
+      kind: "zod",
+      text: trim(block(file.text, match.index), LIMITS.shapeChars)
+    });
+  }
+  return found;
+}
+function leadingDoc(text, anchor) {
+  const at = text.search(anchor);
+  if (at === -1)
+    return null;
+  const before = text.slice(0, at);
+  const jsdoc = /\/\*\*([\s\S]*?)\*\/(?:\s*(?:export|default|async|const|let|var))*\s*$/.exec(before);
+  if (jsdoc !== null) {
+    return oneLine((jsdoc[1] ?? "").replace(/^\s*\*/gm, " ")).slice(0, 400);
+  }
+  const lines = before.split("\n");
+  const comments = [];
+  for (let i = lines.length - 2; i >= 0; i -= 1) {
+    const line = (lines[i] ?? "").trim();
+    if (line.startsWith("//"))
+      comments.unshift(line.slice(2).trim());
+    else
+      break;
+  }
+  return comments.length > 0 ? comments.join(" ").slice(0, 400) : null;
+}
+function fileDoc(text) {
+  const match = /^\s*\/\*\*([\s\S]*?)\*\//.exec(text);
+  if (match === null)
+    return null;
+  return oneLine((match[1] ?? "").replace(/^\s*\*/gm, " ")).slice(0, 400);
+}
+function block(text, start) {
+  const open = text.indexOf("{", start);
+  if (open === -1)
+    return text.slice(start, start + LIMITS.shapeChars);
+  let depth = 0;
+  for (let i = open; i < text.length && i < open + LIMITS.shapeChars * 2; i += 1) {
+    const char = text[i];
+    if (char === "{")
+      depth += 1;
+    else if (char === "}") {
+      depth -= 1;
+      if (depth === 0)
+        return text.slice(start, i + 1);
+    }
+  }
+  return text.slice(start, start + LIMITS.shapeChars);
+}
+function stripImports(text) {
+  return text.split("\n").filter((line) => !/^\s*import\s/.test(line) && !/^\s*export\s+\*/.test(line)).join("\n").trim();
+}
+function oneLine(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function trim(text, max) {
+  return text.length <= max ? text : `${text.slice(0, max)}
+// ...trimmed`;
+}
+
+// dist/project.js
+import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join3 } from "node:path";
+function linkPath(dir) {
+  return join3(dir, ".cira", "project.json");
+}
+function readProjectLink(dir = process.cwd()) {
+  try {
+    const raw = JSON.parse(readFileSync3(linkPath(dir), "utf8"));
+    if (typeof raw.appId !== "string" || typeof raw.spaceId !== "string" || typeof raw.spaceSlug !== "string" || typeof raw.appSlug !== "string") {
+      return null;
+    }
+    return raw;
+  } catch {
+    return null;
+  }
+}
+function writeProjectLink(link, dir = process.cwd()) {
+  mkdirSync2(join3(dir, ".cira"), { recursive: true });
+  writeFileSync2(linkPath(dir), `${JSON.stringify(link, null, 2)}
+`);
+}
+function detectFramework(dir = process.cwd()) {
+  const pkgPath = join3(dir, "package.json");
+  if (!existsSync(pkgPath))
+    return null;
+  try {
+    const pkg = JSON.parse(readFileSync3(pkgPath, "utf8"));
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    return deps["next"] !== void 0 ? "nextjs" : null;
+  } catch {
+    return null;
+  }
+}
+
+// dist/ui.js
+var useColour = process.stdout.isTTY === true && process.env["NO_COLOR"] === void 0;
+var wrap = (code) => (text) => useColour ? `\x1B[${code}m${text}\x1B[0m` : text;
+var dim = wrap("2");
+var bold = wrap("1");
+var green = wrap("32");
+var red = wrap("31");
+function info(message) {
+  process.stdout.write(`${message}
+`);
+}
+function success(message) {
+  process.stdout.write(`${green("OK")} ${message}
+`);
+}
+function fail(message) {
+  process.stderr.write(`${red("Error")} ${message}
+`);
+}
+
+// dist/deploy.js
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function deploy(argv = []) {
+  const requestedSpace = readFlag(argv, "--space");
+  const config = readConfig();
+  if (config.token === void 0) {
+    fail("Not signed in. Run: cira login");
+    return 1;
+  }
+  const root = process.cwd();
+  info("");
+  info(`${dim("Detecting application...")}`);
+  const framework = detectFramework(root);
+  if (framework === null) {
+    fail("This folder is not a Next.js app. Cira deploys Next.js in V1.");
+    return 1;
+  }
+  success("Next.js app");
+  const link = readProjectLink(root);
+  let me;
+  try {
+    me = await api("/api/cli/me");
+  } catch (error) {
+    fail(error instanceof ApiError ? error.message : "Could not reach Cira.");
+    return 1;
+  }
+  if (me.spaces.length === 0) {
+    fail("You are not in a space yet. Open Cira and join or create one first.");
+    return 1;
+  }
+  if (requestedSpace !== null && !me.spaces.some((s) => s.slug === requestedSpace)) {
+    fail(`You are not in a space called "${requestedSpace}".`);
+    info(dim(`  You are in: ${me.spaces.map((s) => s.slug).join(", ")}`));
+    return 1;
+  }
+  const spaceSlug = requestedSpace ?? link?.spaceSlug ?? (me.spaces.length === 1 ? me.spaces[0]?.slug : void 0);
+  if (spaceSlug === void 0) {
+    fail("You are in more than one space, so tell Cira which one to deploy to.");
+    info("");
+    for (const s of me.spaces) {
+      info(`  cira deploy --space ${s.slug}${dim(`   (${s.name})`)}`);
+    }
+    info("");
+    return 1;
+  }
+  const files = collectFiles(root);
+  if (files.length === 0) {
+    fail("There is nothing to deploy in this folder.");
+    return 1;
+  }
+  const bytes = files.reduce((n, f) => n + f.size, 0);
+  info(`${dim(`Packaging ${files.length} files (${formatBytes(bytes)})...`)}`);
+  for (const file of files) {
+    try {
+      await api("/api/cli/upload", {
+        method: "POST",
+        body: void 0,
+        raw: { sha: file.sha, body: readFileBody(root, file.path) }
+      });
+    } catch (error) {
+      fail(error instanceof ApiError ? `${error.message} while uploading ${file.path}` : `Could not upload ${file.path}.`);
+      return 1;
+    }
+  }
+  success("Uploaded");
+  info(`${dim(`Deploying to ${spaceSlug}...`)}`);
+  let started;
+  try {
+    started = await api("/api/cli/deploy", {
+      method: "POST",
+      body: {
+        spaceSlug,
+        appName: link === null ? prettyName(basename(root)) : basename(root),
+        appId: link?.appId ?? null,
+        files
+      }
+    });
+  } catch (error) {
+    fail(error instanceof ApiError ? error.message : "The deploy could not be started.");
+    return 1;
+  }
+  writeProjectLink({
+    appId: started.appId,
+    spaceId: "",
+    spaceSlug: started.spaceSlug,
+    appSlug: started.appSlug
+  }, root);
+  info(`${dim("Analyzing capabilities...")}`);
+  const analysis = api("/api/cli/capabilities", {
+    method: "POST",
+    body: {
+      appId: started.appId,
+      summary: extractRepo(readSourceFiles(root, files))
+    }
+  }).catch((error) => error instanceof Error ? error : new Error("failed"));
+  const deadline = Date.now() + 10 * 60 * 1e3;
+  let last = "";
+  while (Date.now() < deadline) {
+    await sleep(3e3);
+    let status2;
+    try {
+      status2 = await api(`/api/cli/deploy/status?id=${encodeURIComponent(started.deploymentId)}`);
+    } catch {
+      continue;
+    }
+    if (status2.status !== last) {
+      info(dim(`  ${status2.status}...`));
+      last = status2.status;
+    }
+    if (status2.status === "live") {
+      info("");
+      success("Deployed");
+      info("");
+      info(`  ${bold(`${config.apiUrl}/${started.spaceSlug}/${started.appSlug}`)}`);
+      info("");
+      info(dim("  Only you can see it. Give people access from that page."));
+      await reportCapabilities(await analysis);
+      return 0;
+    }
+    if (status2.status === "failed" || status2.status === "removed") {
+      info("");
+      fail("The deploy did not finish. Open the app in Cira to see why.");
+      return 1;
+    }
+  }
+  fail("Timed out waiting for the deploy to finish.");
+  return 1;
+}
+function prettyName(folder) {
+  const cleaned = folder.replace(/[-_]+/g, " ").trim();
+  return cleaned === "" ? "App" : cleaned.replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function formatBytes(n) {
+  if (n < 1024)
+    return `${n} B`;
+  if (n < 1024 * 1024)
+    return `${Math.round(n / 1024)} KB`;
+  return `${(n / (1024 * 1024)).toFixed(1)} MB`;
+}
+function readFlag(argv, flag) {
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === flag)
+      return argv[i + 1] ?? null;
+    if (arg !== void 0 && arg.startsWith(`${flag}=`)) {
+      return arg.slice(flag.length + 1);
+    }
+  }
+  return null;
+}
+async function reportCapabilities(result) {
+  if (result instanceof Error) {
+    info("");
+    info(dim(`  Capabilities were not analyzed: ${result.message}`));
+    return;
+  }
+  if (result.detected.length === 0) {
+    info("");
+    info(dim("  No capabilities detected in this app."));
+    return;
+  }
+  info("");
+  info(`${bold("Capabilities")}`);
+  info("");
+  for (const capability of result.detected) {
+    const mark = capability.risk === "read" ? " " : "!";
+    info(`  ${mark} ${bold(capability.name)}`);
+    info(`    ${dim(capability.description)}`);
+  }
+  info("");
+  const parts = [];
+  if (result.enabled > 0)
+    parts.push(`${result.enabled} enabled`);
+  if (result.review > 0)
+    parts.push(`${result.review} awaiting review`);
+  info(`  ${parts.join(", ")}`);
+  if (result.review > 0) {
+    info(dim("  Anything that writes stays off until someone turns it on."));
+  }
+  info("");
+}
+
+// dist/login.js
+import { hostname } from "node:os";
+
+// dist/skill/command.js
+import { createInterface } from "node:readline/promises";
+
+// dist/skill/index.js
+import { homedir as homedir2 } from "node:os";
+
+// ../cira-skill/dist/index.js
+import { readFileSync as readFileSync4 } from "node:fs";
+var SKILL_PATH = new URL("../SKILL.md", import.meta.url);
+var MANIFEST = new URL("../package.json", import.meta.url);
+function canonicalSkill() {
+  const source = readFileSync4(SKILL_PATH, "utf8");
+  const parsed = splitFrontmatter(source);
+  return {
+    name: parsed.fields["name"] ?? "cira",
+    description: parsed.fields["description"] ?? "Build and deploy to Cira.",
+    body: parsed.body,
+    source,
+    version: packageVersion()
+  };
+}
+function packageVersion() {
+  try {
+    const pkg = JSON.parse(readFileSync4(MANIFEST, "utf8"));
+    return typeof pkg.version === "string" ? pkg.version : "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function splitFrontmatter(source) {
+  const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(source);
+  if (match === null)
+    return { fields: {}, body: source.trim() };
+  const fields = {};
+  for (const line of (match[1] ?? "").split("\n")) {
+    const at = line.indexOf(":");
+    if (at === -1)
+      continue;
+    const key = line.slice(0, at).trim();
+    const value = line.slice(at + 1).trim();
+    if (key !== "")
+      fields[key] = value;
+  }
+  return { fields, body: source.slice(match[0].length).trim() };
+}
+
+// dist/update/state.js
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join4 } from "node:path";
+function readUpdateState() {
+  return read("update-state.json", {});
+}
+function writeUpdateState(state) {
+  write("update-state.json", state);
+}
+function readSkillState() {
+  const state = read("skill-state.json", { targets: {} });
+  return { ...state, targets: state.targets ?? {} };
+}
+function writeSkillState(state) {
+  write("skill-state.json", state);
+}
+function read(name, fallback) {
+  try {
+    return {
+      ...fallback,
+      ...JSON.parse(readFileSync5(join4(ciraHome(), name), "utf8"))
+    };
+  } catch {
+    return fallback;
+  }
+}
+function write(name, value) {
+  try {
+    mkdirSync3(ciraHome(), { recursive: true, mode: 448 });
+    writeFileSync3(join4(ciraHome(), name), `${JSON.stringify(value, null, 2)}
+`);
+  } catch {
+  }
+}
+
+// dist/skill/agents.js
+import { existsSync as existsSync3 } from "node:fs";
+import { join as join6 } from "node:path";
+
+// dist/skill/installer.js
+import { mkdirSync as mkdirSync4, existsSync as existsSync2, writeFileSync as writeFileSync4 } from "node:fs";
+import { delimiter, join as join5 } from "node:path";
+function sharedSkillsDir(env) {
+  return join5(env.home, ".agents", "skills");
+}
+function writeSkill(skillsDir, skill) {
+  const directory = join5(skillsDir, skill.name);
+  mkdirSync4(directory, { recursive: true });
+  const path = join5(directory, "SKILL.md");
+  writeFileSync4(path, `${skill.source.trimEnd()}
+`);
+  return { ok: true, where: path };
+}
+function onPath(env, command) {
+  return env.path.some((dir) => [command, `${command}.exe`, `${command}.cmd`].some((name) => dir === "" ? false : existsSync2(join5(dir, name))));
+}
+function systemPath() {
+  return (process.env["PATH"] ?? "").split(delimiter).filter((p) => p !== "");
+}
+
+// dist/skill/agents.js
+function claudeCode(env) {
+  const home = process.env["CLAUDE_CONFIG_DIR"] ?? join6(env.home, ".claude");
+  return {
+    id: "claude-code",
+    name: "Claude Code",
+    detect: () => Promise.resolve(existsSync3(home) || onPath(env, "claude")),
+    install: (skill) => Promise.resolve(writeSkill(join6(home, "skills"), skill))
+  };
+}
+function codex(env) {
+  const home = process.env["CODEX_HOME"] ?? join6(env.home, ".codex");
+  return {
+    id: "codex",
+    name: "Codex",
+    detect: () => Promise.resolve(existsSync3(home) || onPath(env, "codex")),
+    install: (skill) => Promise.resolve(writeSkill(sharedSkillsDir(env), skill))
+  };
+}
+function pi(env) {
+  return {
+    id: "pi",
+    name: "Pi",
+    detect: () => Promise.resolve(existsSync3(join6(env.home, ".pi")) || onPath(env, "pi")),
+    install: (skill) => Promise.resolve(writeSkill(sharedSkillsDir(env), skill))
+  };
+}
+function geminiCli(env) {
+  return {
+    id: "gemini-cli",
+    name: "Gemini CLI",
+    detect: () => Promise.resolve(existsSync3(join6(env.home, ".gemini")) || onPath(env, "gemini")),
+    install: (skill) => Promise.resolve(writeSkill(sharedSkillsDir(env), skill))
+  };
+}
+
+// dist/skill/cursor.js
+import { existsSync as existsSync4, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "node:fs";
+import { join as join7 } from "node:path";
+function cursor(env) {
+  return {
+    id: "cursor",
+    name: "Cursor",
+    detect: () => Promise.resolve(existsSync4(join7(env.home, ".cursor")) || existsSync4(join7(env.home, ".config", "Cursor")) || existsSync4(join7(env.home, "Library", "Application Support", "Cursor")) || // On WSL the editor is installed on the Windows side: its binary is
+    // reachable while its configuration directory is not.
+    onPath(env, "cursor")),
+    install: (skill) => {
+      if (!isProject(env.cwd)) {
+        return Promise.resolve({
+          ok: false,
+          why: "run this from a project folder - Cursor rules live in the project"
+        });
+      }
+      const directory = join7(env.cwd, ".cursor", "rules");
+      mkdirSync5(directory, { recursive: true });
+      const path = join7(directory, `${skill.name}.mdc`);
+      const frontmatter = [
+        "---",
+        `description: ${skill.description}`,
+        "globs:",
+        "alwaysApply: false",
+        "---"
+      ].join("\n");
+      writeFileSync5(path, `${frontmatter}
+
+${skill.body.trim()}
+`);
+      return Promise.resolve({ ok: true, where: path });
+    }
+  };
+}
+function isProject(dir) {
+  return existsSync4(join7(dir, "package.json")) || existsSync4(join7(dir, ".git")) || existsSync4(join7(dir, "pyproject.toml")) || existsSync4(join7(dir, "go.mod"));
+}
+
+// dist/skill/index.js
+function installers(env = currentEnv()) {
+  return [claudeCode(env), codex(env), pi(env), geminiCli(env), cursor(env)];
+}
+function currentEnv() {
+  return { home: homedir2(), cwd: process.cwd(), path: systemPath() };
+}
+async function detectAgents(env = currentEnv()) {
+  const found = [];
+  for (const installer of installers(env)) {
+    if (await installer.detect())
+      found.push(installer);
+  }
+  return found;
+}
+async function installSkill(agents, autoUpdate = true) {
+  const skill = canonicalSkill();
+  const reports = [];
+  for (const agent of agents) {
+    try {
+      reports.push({ agent: agent.name, result: await agent.install(skill) });
+    } catch (error) {
+      reports.push({
+        agent: agent.name,
+        result: {
+          ok: false,
+          why: error instanceof Error ? error.message : "could not write the skill"
+        }
+      });
+    }
+  }
+  remember(agents, reports, autoUpdate);
+  return reports;
+}
+function remember(agents, reports, autoUpdate) {
+  const installed = new Set(reports.filter((r) => r.result.ok).map((r) => r.agent));
+  if (installed.size === 0)
+    return;
+  const state = readSkillState();
+  const targets = { ...state.targets };
+  for (const agent of agents) {
+    if (!installed.has(agent.name))
+      continue;
+    targets[agent.id] = { installed: true, autoUpdate };
+  }
+  writeSkillState({ ...state, skillVersion: canonicalSkill().version, targets });
+}
+
+// dist/skill/command.js
+async function skillCommand(argv) {
+  const action = argv[0] ?? "install";
+  if (action !== "install") {
+    fail(`Unknown skill command: ${action}`);
+    info(dim("  Try: cira skill install"));
+    return 1;
+  }
+  const agents = await detectAgents();
+  info("");
+  info(bold("Cira Skill"));
+  info("");
+  if (agents.length === 0) {
+    info(dim("  No supported coding agents detected."));
+    info(dim("  Cira installs into Claude Code, Codex, Pi, Gemini CLI and Cursor."));
+    info("");
+    return 0;
+  }
+  report(await installSkill(agents));
+  return 0;
+}
+async function offerSkill() {
+  const agents = await detectAgents();
+  if (agents.length === 0) {
+    info("");
+    info(dim("  No supported coding agents detected."));
+    info(dim("  You can install the Cira Skill later with: cira skill install"));
+    info("");
+    return;
+  }
+  info("");
+  info("  Coding agents detected:");
+  info("");
+  for (const agent of agents)
+    info(`    ${agent.name}`);
+  info("");
+  if (!await confirm("  Install the Cira Skill and keep it updated? [Y/n] ")) {
+    info("");
+    info(dim("  Left alone. Install later with: cira skill install"));
+    info("");
+    return;
+  }
+  info("");
+  report(await installSkill(agents));
+}
+function report(reports) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of reports) {
+    if (!entry.result.ok) {
+      info(`  - ${entry.agent} ${dim(entry.result.why)}`);
+      continue;
+    }
+    const where = entry.result.where;
+    success(`${entry.agent} ${dim(seen.has(where) ? "(same file)" : where)}`);
+    seen.add(where);
+  }
+  const installed = reports.filter((r) => r.result.ok).length;
+  info("");
+  if (installed > 0)
+    info(`  ${bold("You're ready.")}`);
+  info("");
+}
+async function confirm(question) {
+  if (!process.stdin.isTTY) {
+    info(dim("  Not a terminal, so nothing was installed."));
+    info(dim("  Run: cira skill install"));
+    return false;
+  }
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = (await rl.question(question)).trim().toLowerCase();
+    return answer === "" || answer === "y" || answer === "yes";
+  } finally {
+    rl.close();
+  }
+}
+
+// dist/login.js
+var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
+async function login() {
+  const config = readConfig();
+  let start;
+  try {
+    start = await api("/api/cli/auth/start", {
+      method: "POST",
+      body: { label: `${hostname()} CLI` }
+    });
+  } catch (error) {
+    fail(error instanceof ApiError ? error.message : "Could not start sign-in.");
+    return 1;
+  }
+  const url = `${config.apiUrl}${start.verifyPath}?code=${start.userCode}`;
+  info("");
+  info(`  Open ${bold(url)}`);
+  info(`  and confirm this code: ${bold(start.userCode)}`);
+  info("");
+  info(dim("  Waiting for you to approve..."));
+  const deadline = Date.now() + start.expiresInSeconds * 1e3;
+  while (Date.now() < deadline) {
+    await sleep2(start.intervalSeconds * 1e3);
+    let poll;
+    try {
+      poll = await api("/api/cli/auth/poll", {
+        method: "POST",
+        body: { deviceCode: start.deviceCode }
+      });
+    } catch {
+      continue;
+    }
+    if (poll.status === "approved" && poll.token !== void 0) {
+      writeConfig({
+        apiUrl: config.apiUrl,
+        token: poll.token,
+        ...poll.user !== void 0 ? { email: poll.user.email } : {}
+      });
+      info("");
+      success(`Signed in as ${poll.user?.email ?? "your account"}`);
+      await offerSkill();
+      return 0;
+    }
+    if (poll.status === "expired" || poll.status === "claimed") {
+      info("");
+      fail("That sign-in expired. Run cira login again.");
+      return 1;
+    }
+  }
+  info("");
+  fail("Timed out waiting for approval. Run cira login again.");
+  return 1;
+}
+
+// dist/update/index.js
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+// dist/update/check.js
+import { get } from "node:https";
+
+// dist/update/version.js
+import { readFileSync as readFileSync6 } from "node:fs";
+var MANIFESTS = ["../package.json", "../../package.json"];
+function currentVersion() {
+  for (const candidate of MANIFESTS) {
+    try {
+      const pkg = JSON.parse(readFileSync6(new URL(candidate, import.meta.url), "utf8"));
+      if (pkg.name !== "@cira-app/cli")
+        continue;
+      if (typeof pkg.version === "string")
+        return pkg.version;
+    } catch {
+    }
+  }
+  return "0.0.0";
+}
+function isNewer(candidate, current) {
+  const a = parse(candidate);
+  const b = parse(current);
+  if (a === null || b === null)
+    return false;
+  for (let i = 0; i < 3; i += 1) {
+    const left = a.parts[i] ?? 0;
+    const right = b.parts[i] ?? 0;
+    if (left !== right)
+      return left > right;
+  }
+  return b.prerelease && !a.prerelease;
+}
+function parse(value) {
+  const match = /^v?(\d+)\.(\d+)\.(\d+)(?:[-+](.*))?$/.exec(value.trim());
+  if (match === null)
+    return null;
+  return {
+    parts: [Number(match[1]), Number(match[2]), Number(match[3])],
+    prerelease: match[4] !== void 0 && match[4] !== ""
+  };
+}
+
+// dist/update/check.js
+var REGISTRY = "https://registry.npmjs.org/@cira-app%2Fcli/latest";
+var CHECK_TIMEOUT_MS = 2500;
+var TTL_MS = 8 * 60 * 60 * 1e3;
+var fetchLatestVersion = (signal, { detached }) => new Promise((resolve) => {
+  const done = (version) => resolve(version);
+  const request = get(REGISTRY, { signal, headers: { accept: "application/json" } }, (response) => {
+    if (response.statusCode !== 200) {
+      response.resume();
+      done(null);
+      return;
+    }
+    let body = "";
+    response.setEncoding("utf8");
+    response.on("data", (chunk) => {
+      body += chunk;
+      if (body.length > 2e5)
+        request.destroy();
+    });
+    response.on("end", () => {
+      try {
+        const version = JSON.parse(body).version;
+        done(typeof version === "string" ? version : null);
+      } catch {
+        done(null);
+      }
+    });
+  });
+  if (detached)
+    request.on("socket", (socket) => socket.unref());
+  request.setTimeout(CHECK_TIMEOUT_MS, () => request.destroy());
+  request.on("error", () => done(null));
+});
+async function checkForUpdate(options = {}) {
+  const current = currentVersion();
+  const state = readUpdateState();
+  const now = options.now ?? Date.now();
+  if (options.force !== true && !expired(state.lastCheckedAt, now)) {
+    const cached = state.latestVersion ?? null;
+    return {
+      current,
+      latest: cached,
+      hasUpdate: cached !== null && isNewer(cached, current)
+    };
+  }
+  writeUpdateState({ ...state, lastCheckedAt: new Date(now).toISOString() });
+  const fetchLatest = options.fetchLatest ?? fetchLatestVersion;
+  const controller = new AbortController();
+  options.signal?.addEventListener("abort", () => controller.abort());
+  const latest = await fetchLatest(controller.signal, {
+    detached: options.force !== true
+  });
+  if (latest !== null) {
+    writeUpdateState({
+      ...readUpdateState(),
+      lastCheckedAt: new Date(now).toISOString(),
+      latestVersion: latest
+    });
+  }
+  return { current, latest, hasUpdate: latest !== null && isNewer(latest, current) };
+}
+function expired(lastCheckedAt, now) {
+  if (lastCheckedAt === void 0)
+    return true;
+  const at = Date.parse(lastCheckedAt);
+  return Number.isNaN(at) || now - at >= TTL_MS;
+}
+
+// dist/update/index.js
+var run = promisify(execFile);
+var npmUpdater = async (version) => {
+  await run("npm", ["install", "-g", `@cira-app/cli@${version}`], {
+    timeout: 12e4,
+    windowsHide: true
+  });
+};
+async function updateCommand(options = {}) {
+  info("");
+  info(dim("Checking for updates..."));
+  const check = await checkForUpdate({ force: true, ...pick(options, "fetchLatest") });
+  if (!check.hasUpdate || check.latest === null) {
+    info("");
+    success("Cira is up to date.");
+    info("");
+    return 0;
+  }
+  info("");
+  info(bold("CLI"));
+  info(`  ${check.current} \u2192 ${check.latest}`);
+  info("");
+  info(dim("Updating..."));
+  info("");
+  try {
+    await (options.updateCli ?? npmUpdater)(check.latest);
+  } catch (error) {
+    fail("CLI update failed.");
+    info(dim("  Your existing installation was left unchanged."));
+    info(dim(`  ${error instanceof Error ? error.message : "npm could not run."}`));
+    info("");
+    return 1;
+  }
+  success("CLI updated");
+  const results = await syncInstalledSkills(check.latest, options.agents);
+  for (const result of results) {
+    if (result.ok)
+      success(`Cira Skill updated for ${result.agent}`);
+    else
+      fail(`Cira Skill update failed for ${result.agent} ${dim(result.why)}`);
+  }
+  const state = readUpdateState();
+  writeUpdateState({ ...state, lastNotifiedVersion: check.latest });
+  info("");
+  if (results.some((r) => !r.ok)) {
+    info("  Cira is updated, but some Skill installations need attention.");
+  } else {
+    success("Cira is up to date.");
+  }
+  info("");
+  return 0;
+}
+async function syncInstalledSkills(version, agents = installers()) {
+  const state = readSkillState();
+  const skill = canonicalSkill();
+  const results = [];
+  for (const agent of agents) {
+    const target = state.targets[agent.id];
+    if (target === void 0 || !target.installed || !target.autoUpdate)
+      continue;
+    try {
+      const outcome = await agent.install(skill);
+      results.push({
+        agent: agent.name,
+        ok: outcome.ok,
+        why: outcome.ok ? outcome.where : outcome.why
+      });
+    } catch (error) {
+      results.push({
+        agent: agent.name,
+        ok: false,
+        why: error instanceof Error ? error.message : "could not write the skill"
+      });
+    }
+  }
+  if (results.some((r) => r.ok)) {
+    writeSkillState({ ...state, skillVersion: version });
+  }
+  return results;
+}
+function beginUpdateCheck(options = {}) {
+  const controller = new AbortController();
+  const result = checkForUpdate({
+    signal: controller.signal,
+    ...pick(options, "fetchLatest")
+  }).then((check) => ({ latest: check.latest, hasUpdate: check.hasUpdate })).catch(() => null);
+  return { result, cancel: () => controller.abort() };
+}
+var GRACE_MS = 100;
+async function finishUpdateCheck(pending) {
+  const timeout = new Promise((resolve) => {
+    const timer = setTimeout(() => resolve(null), GRACE_MS);
+    timer.unref?.();
+  });
+  const check = await Promise.race([pending.result, timeout]);
+  pending.cancel();
+  if (check === null || !check.hasUpdate || check.latest === null)
+    return;
+  const state = readUpdateState();
+  if (state.lastNotifiedVersion === check.latest)
+    return;
+  info("");
+  info(`  Cira ${bold(check.latest)} is available.`);
+  info(dim("  Run `cira update`."));
+  writeUpdateState({ ...state, lastNotifiedVersion: check.latest });
+}
+function pick(source, key) {
+  return source[key] === void 0 ? {} : { [key]: source[key] };
+}
+
+// dist/index.js
+var USAGE = `
+  ${bold("cira")} - deploy software to your company
+
+  ${bold("Commands")}
+    deploy     Deploy this folder to your company
+               --space <slug>   which space, when you are in more than one
+    login      Connect this machine to your Cira account
+    skill      install    Add the Cira Skill to your coding agents
+    update     Update Cira and the Skill copies you approved
+    logout     Forget the stored credential
+    whoami     Show who you are signed in as
+    status     Show what this folder is linked to
+
+  ${bold("Environment")}
+    CIRA_API_URL   Point at a different Cira (default: production)
+    CIRA_HOME      Where the credential is stored (default: ~/.cira)
+`;
+async function whoami() {
+  const config = readConfig();
+  if (config.token === void 0) {
+    fail("Not signed in. Run: cira login");
+    return 1;
+  }
+  try {
+    const me = await api("/api/cli/me");
+    info(`${bold(me.user.name)} ${dim(`<${me.user.email}>`)}`);
+    if (me.spaces.length === 0) {
+      info(dim("  No spaces yet."));
+    } else {
+      for (const space of me.spaces) {
+        info(`  ${space.name} ${dim(`(${space.role})`)}`);
+      }
+    }
+    return 0;
+  } catch (error) {
+    fail(error instanceof ApiError ? error.message : "Could not reach Cira.");
+    return 1;
+  }
+}
+function status() {
+  const framework = detectFramework();
+  const link = readProjectLink();
+  info(`${bold("Folder")}    ${process.cwd()}`);
+  info(`${bold("Framework")} ${framework ?? dim("not a supported project")}`);
+  info(link === null ? `${bold("Linked")}    ${dim("not linked to an app yet")}` : `${bold("Linked")}    ${link.spaceSlug}/${link.appSlug}`);
+  return 0;
+}
+async function main() {
+  const command = process.argv[2];
+  switch (command) {
+    case "deploy":
+      return deploy(process.argv.slice(3));
+    case "login":
+      return login();
+    case "skill":
+      return skillCommand(process.argv.slice(3));
+    case "update":
+      return updateCommand();
+    case "logout":
+      clearConfig();
+      success("Signed out.");
+      return 0;
+    case "whoami":
+      return whoami();
+    case "status":
+      return status();
+    case void 0:
+    case "help":
+    case "--help":
+    case "-h":
+      info(USAGE);
+      return 0;
+    default:
+      fail(`Unknown command: ${command}`);
+      info(USAGE);
+      return 1;
+  }
+}
+var passive = process.argv[2] === "update" ? null : beginUpdateCheck();
+main().then(async (code) => {
+  process.exitCode = code;
+  if (passive !== null)
+    await finishUpdateCheck(passive);
+}).catch(async (error) => {
+  fail(error instanceof Error ? error.message : "Something went wrong.");
+  process.exitCode = 1;
+  if (passive !== null)
+    await finishUpdateCheck(passive);
+});