@commandgarden/cli 0.1.0 → 1.0.0

package/dist/main.js

@@ -7,7 +7,7 @@ var __export = (target, all) => {
 
 // src/main.ts
 import { Command } from "commander";
-import { join as join2, dirname as dirname2 } from "path";
+import { join as join3, dirname } from "path";
 import { homedir } from "os";
 import { fileURLToPath } from "url";
 
@@ -58,6 +58,54 @@ var DaemonClient = class {
     }
     return data;
   }
+  async connectSSE(path, onEvent, signal) {
+    const resp = await this.rawFetch(path, {
+      method: "GET",
+      headers: {
+        "Authorization": `Bearer ${this.token}`,
+        "X-CommandGarden": "1",
+        "Accept": "text/event-stream"
+      },
+      signal
+    });
+    if (!resp.ok || !resp.body) {
+      throw new Error(`SSE connection failed: HTTP ${resp.status}`);
+    }
+    const reader = resp.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        let currentEvent = "message";
+        let currentData = "";
+        for (const line of lines) {
+          if (line.startsWith("event: ")) {
+            currentEvent = line.slice(7).trim();
+          } else if (line.startsWith("data: ")) {
+            currentData = line.slice(6);
+          } else if (line === "") {
+            if (currentData) {
+              try {
+                onEvent(currentEvent, JSON.parse(currentData));
+              } catch {
+                onEvent(currentEvent, currentData);
+              }
+              currentData = "";
+              currentEvent = "message";
+            }
+          }
+        }
+      }
+    } catch (err) {
+      if (signal?.aborted) return;
+      throw err;
+    }
+  }
   rawFetch(path, init) {
     return fetch(`${this.baseUrl}${path}`, init);
   }
@@ -79,6 +127,9 @@ function parseDuration(input) {
   return new Date(Date.now() - value * UNITS[unit]);
 }
 
+// src/commands/run.ts
+import { createInterface } from "readline";
+
 // src/formatters.ts
 import Table from "cli-table3";
 function formatTable(data, columns) {
@@ -138,6 +189,30 @@ function parseConnectorArgs(rawArgs) {
   }
   return result;
 }
+function promptApproval(request) {
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  let cancelled = false;
+  const cancel = () => {
+    cancelled = true;
+    rl.close();
+  };
+  const prompt = `
+\u26A0  Step ${request.stepIndex + 1} [${request.stepType}] in ${request.connectorKey} requires approval.
+   Capability: ${request.capability}
+   ${request.description}
+   Approve? (y/n): `;
+  const promise = new Promise((resolve) => {
+    rl.question(prompt, (answer) => {
+      rl.close();
+      if (cancelled) return;
+      resolve(answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes");
+    });
+    rl.on("close", () => {
+      if (cancelled) resolve(true);
+    });
+  });
+  return { promise, cancel };
+}
 async function executeRun(client, connector, args, outputFormat) {
   try {
     const resp = await client.post("/api/run", {
@@ -145,10 +220,57 @@ async function executeRun(client, connector, args, outputFormat) {
       args,
       format: outputFormat
     });
-    if (!resp.ok) {
-      return `Error: ${resp.error ?? "Unknown error from extension"} (${resp.durationMs}ms)`;
+    if (!resp.requiresApproval) {
+      if (!resp.ok) {
+        return `Error: ${resp.error ?? "Unknown error from extension"} (${resp.durationMs}ms)`;
+      }
+      return format(resp.data, resp.columns, connector, outputFormat);
     }
-    return format(resp.data, resp.columns, connector, outputFormat);
+    const requestId = resp.requestId;
+    process.stderr.write(`Pipeline requires approval. Waiting for steps...
+`);
+    return new Promise((resolve) => {
+      const abortController = new AbortController();
+      let activePrompt = null;
+      client.connectSSE(
+        `/api/run/events/${requestId}`,
+        (event, data) => {
+          if (event === "approval") {
+            const approvalReq = data;
+            activePrompt = promptApproval(approvalReq);
+            activePrompt.promise.then(async (approved) => {
+              activePrompt = null;
+              try {
+                await client.post("/api/approval", {
+                  approvalId: approvalReq.approvalId,
+                  approved
+                });
+              } catch {
+              }
+              if (!approved) {
+                abortController.abort();
+                resolve(`Aborted: Step ${approvalReq.stepIndex + 1} [${approvalReq.stepType}] was rejected.`);
+              }
+            });
+          } else if (event === "result") {
+            if (activePrompt) {
+              activePrompt.cancel();
+              activePrompt = null;
+              process.stderr.write("\n   (approved via extension)\n");
+            }
+            abortController.abort();
+            const result = data;
+            if (!result.ok) {
+              resolve(`Error: ${result.error ?? "Unknown error"} (${result.durationMs}ms)`);
+            } else {
+              resolve(format(result.data, result.columns ?? [], connector, outputFormat));
+            }
+          }
+        },
+        abortController.signal
+      ).catch(() => {
+      });
+    });
   } catch (err) {
     return `Error: ${err instanceof Error ? err.message : String(err)}`;
   }
@@ -4603,6 +4725,7 @@ function buildQueryString(filter) {
   const params = new URLSearchParams();
   if (filter.since) params.set("since", filter.since);
   if (filter.connector) params.set("connector", filter.connector);
+  if (filter.type) params.set("type", filter.type);
   if (filter.limit) params.set("limit", String(filter.limit));
   const qs = params.toString();
   return qs ? `?${qs}` : "";
@@ -4614,7 +4737,7 @@ async function executeAuditList(client, filter) {
     );
     if (resp.events.length === 0) return "No audit events found.";
     const table = new Table3({
-      head: ["Timestamp", "Type", "Connector", "User", "Duration", "Rows", "Error"],
+      head: ["Timestamp", "Type", "Connector", "User", "Duration", "Rows", "Source", "Error"],
       style: { head: ["cyan"] }
     });
     for (const e of resp.events) {
@@ -4625,6 +4748,7 @@ async function executeAuditList(client, filter) {
         e.user,
         `${e.durationMs}ms`,
         e.rowCount?.toString() ?? "-",
+        e.source ?? "-",
         e.error ?? e.denialReason ?? ""
       ]);
     }
@@ -4633,7 +4757,24 @@ async function executeAuditList(client, filter) {
     return `Error: ${err instanceof Error ? err.message : String(err)}`;
   }
 }
-var AUDIT_COLUMNS = ["id", "timestamp", "type", "user", "connector", "durationMs", "rowCount", "error", "denialReason"];
+var AUDIT_COLUMNS = [
+  "id",
+  "timestamp",
+  "type",
+  "user",
+  "connector",
+  "durationMs",
+  "rowCount",
+  "error",
+  "denialReason",
+  "correlationId",
+  "connectorHash",
+  "source",
+  "args",
+  "domains",
+  "capabilities",
+  "steps"
+];
 async function executeAuditExport(client, filter, format2) {
   try {
     const resp = await client.get(
@@ -4646,8 +4787,15 @@ async function executeAuditExport(client, filter, format2) {
     const rows = resp.events.map(
       (e) => AUDIT_COLUMNS.map((col) => {
         const val = e[col];
-        const str = String(val ?? "");
-        return str.includes(",") || str.includes('"') ? `"${str.replace(/"/g, '""')}"` : str;
+        let str;
+        if (val === null || val === void 0) {
+          str = "";
+        } else if (typeof val === "object") {
+          str = JSON.stringify(val);
+        } else {
+          str = String(val);
+        }
+        return str.includes(",") || str.includes('"') || str.includes("\n") ? `"${str.replace(/"/g, '""')}"` : str;
       }).join(",")
     );
     return [header, ...rows].join("\n") + "\n";
@@ -4655,12 +4803,54 @@ async function executeAuditExport(client, filter, format2) {
     return `Error: ${err instanceof Error ? err.message : String(err)}`;
   }
 }
+async function executeAuditShow(client, id) {
+  try {
+    const resp = await client.get(`/api/audit/${id}`);
+    const e = resp.event;
+    const lines = [
+      `Event: ${e.id}`,
+      `Type: ${e.type}`,
+      `Connector: ${e.connector}${e.connectorHash ? ` (hash: ${e.connectorHash})` : ""}`,
+      `Correlation: ${e.correlationId ?? "-"}`,
+      `User: ${e.user}`,
+      `Timestamp: ${e.timestamp.replace("T", " ").slice(0, 19)}`,
+      `Duration: ${e.durationMs}ms`
+    ];
+    if (e.rowCount !== void 0) lines.push(`Rows: ${e.rowCount}`);
+    if (e.error) lines.push(`Error: ${e.error}`);
+    if (e.denialReason) lines.push(`Denial: ${e.denialReason}`);
+    if (e.source) lines.push(`Source: ${e.source}`);
+    if (e.previousValue !== void 0) lines.push(`Previous: ${e.previousValue}`);
+    if (e.newValue !== void 0) lines.push(`New: ${e.newValue}`);
+    if (Object.keys(e.args).length > 0) {
+      lines.push(`Args: ${JSON.stringify(e.args)}`);
+    }
+    if (e.steps && e.steps.length > 0) {
+      lines.push("");
+      lines.push("Pipeline Steps:");
+      const stepTable = new Table3({
+        head: ["#", "Step", "Capability", "Duration", "Error"],
+        style: { head: ["cyan"] }
+      });
+      for (const s of e.steps) {
+        stepTable.push([
+          s.index + 1,
+          s.step,
+          s.capability ?? "-",
+          `${s.durationMs}ms`,
+          s.error ?? ""
+        ]);
+      }
+      lines.push(stepTable.toString());
+    }
+    return lines.join("\n");
+  } catch (err) {
+    return `Error: ${err instanceof Error ? err.message : String(err)}`;
+  }
+}
 
 // src/commands/config-cmd.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
-import { dirname } from "path";
-import { parse as parseYaml2, stringify as stringifyYaml } from "yaml";
-var VALID_SECTIONS = ["daemon", "security", "connectors", "audit", "output"];
+import { readFileSync as readFileSync4, existsSync as existsSync2 } from "fs";
 function executeConfigShow(configPath) {
   if (!existsSync2(configPath)) {
     return [
@@ -4671,35 +4861,123 @@ function executeConfigShow(configPath) {
   }
   return readFileSync4(configPath, "utf-8");
 }
-function executeConfigSet(configPath, key, value) {
-  const parts = key.split(".");
-  if (parts.length !== 2 || !VALID_SECTIONS.includes(parts[0])) {
-    return `Unknown config section: "${parts[0]}". Valid sections: ${VALID_SECTIONS.join(", ")}`;
-  }
-  let config2 = {};
-  if (existsSync2(configPath)) {
-    const raw = readFileSync4(configPath, "utf-8");
-    config2 = parseYaml2(raw) ?? {};
-  }
-  const [section, prop] = parts;
-  if (!config2[section]) config2[section] = {};
-  let parsed = value;
-  if (value === "true") parsed = true;
-  else if (value === "false") parsed = false;
-  else if (!isNaN(Number(value)) && value !== "") parsed = Number(value);
-  config2[section][prop] = parsed;
-  mkdirSync2(dirname(configPath), { recursive: true });
-  writeFileSync2(configPath, stringifyYaml(config2), "utf-8");
-  return `Set ${key} = ${value}`;
+async function executeConfigSet(client, key, value) {
+  try {
+    await client.post("/api/config", { key, value });
+    return `Set ${key} = ${value}`;
+  } catch (err) {
+    return `Error: ${err instanceof Error ? err.message : String(err)}`;
+  }
+}
+
+// src/commands/gui-cmd.ts
+import { spawn as spawn2 } from "child_process";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync2, existsSync as existsSync3, unlinkSync as unlinkSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join2 } from "path";
+import { exec } from "child_process";
+import { parse as parseYaml2 } from "yaml";
+function readAppPort(configPath) {
+  try {
+    if (existsSync3(configPath)) {
+      const config2 = parseYaml2(readFileSync5(configPath, "utf-8"));
+      const port = config2?.app?.port;
+      if (typeof port === "number") return port;
+    }
+  } catch {
+  }
+  return 19826;
+}
+async function executeGuiStart(baseUrl, cgHome, appScript, opts) {
+  const appPort = opts.configPath ? readAppPort(opts.configPath) : 19826;
+  try {
+    const resp = await fetch(`${baseUrl}/api/status`);
+    if (!resp.ok) throw new Error();
+  } catch {
+    return "Daemon is not running. Start it with: cg daemon start (or use cg up)";
+  }
+  const pidPath = join2(cgHome, "app.pid");
+  if (existsSync3(pidPath)) {
+    const pid = parseInt(readFileSync5(pidPath, "utf-8").trim(), 10);
+    try {
+      process.kill(pid, 0);
+      return "GUI is already running.";
+    } catch {
+      unlinkSync2(pidPath);
+    }
+  }
+  mkdirSync2(cgHome, { recursive: true });
+  if (opts.background) {
+    const child2 = spawn2("node", [appScript], { detached: true, stdio: "ignore" });
+    if (child2.pid) writeFileSync2(pidPath, String(child2.pid));
+    child2.unref();
+    if (!opts.noOpen) openBrowser(`http://127.0.0.1:${appPort}`);
+    return `GUI started (PID: ${child2.pid ?? "unknown"}).`;
+  }
+  if (!opts.noOpen) openBrowser(`http://127.0.0.1:${appPort}`);
+  const child = spawn2("node", [appScript], { stdio: "inherit" });
+  await new Promise((resolve) => child.on("exit", () => resolve()));
+  return "GUI stopped.";
+}
+function executeGuiStop(cgHome) {
+  const pidPath = join2(cgHome, "app.pid");
+  if (!existsSync3(pidPath)) return "GUI is not running (no PID file found).";
+  const pid = parseInt(readFileSync5(pidPath, "utf-8").trim(), 10);
+  try {
+    process.kill(pid, "SIGTERM");
+    unlinkSync2(pidPath);
+    return `GUI stopped (PID: ${pid}).`;
+  } catch {
+    unlinkSync2(pidPath);
+    return `GUI process ${pid} not found (stale PID file cleaned up).`;
+  }
+}
+function executeGuiStatus(cgHome) {
+  const pidPath = join2(cgHome, "app.pid");
+  if (!existsSync3(pidPath)) return "GUI: not running (no PID file found).";
+  const pid = parseInt(readFileSync5(pidPath, "utf-8").trim(), 10);
+  try {
+    process.kill(pid, 0);
+    return `GUI: running (PID: ${pid}).`;
+  } catch {
+    return "GUI: not running (stale PID file).";
+  }
+}
+function openBrowser(url) {
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  exec(`${cmd} ${url}`);
+}
+
+// src/commands/up-down.ts
+async function executeUp(baseUrl, cgHome, daemonScript, appScript, configPath) {
+  const lines = [];
+  lines.push(await executeDaemonStart(baseUrl, cgHome, daemonScript));
+  for (let i = 0; i < 10; i++) {
+    try {
+      const resp = await fetch(`${baseUrl}/api/status`);
+      if (resp.ok) break;
+    } catch {
+    }
+    await new Promise((r) => setTimeout(r, 500));
+  }
+  lines.push(await executeGuiStart(baseUrl, cgHome, appScript, { background: true, configPath }));
+  return lines.join("\n");
+}
+async function executeDown(cgHome) {
+  const lines = [];
+  lines.push(executeGuiStop(cgHome));
+  lines.push(await executeDaemonStop(cgHome));
+  lines.push("All services stopped.");
+  return lines.join("\n");
 }
 
 // src/main.ts
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname2(__filename);
-var DAEMON_SCRIPT = join2(__dirname, "..", "..", "daemon", "dist", "main.js");
-var CG_HOME = join2(homedir(), ".commandgarden");
-var TOKEN_PATH = join2(CG_HOME, "session-token");
-var CONFIG_PATH = join2(CG_HOME, "config.yaml");
+var __dirname = dirname(__filename);
+var DAEMON_SCRIPT = join3(__dirname, "..", "..", "daemon", "dist", "main.js");
+var APP_SCRIPT = join3(__dirname, "..", "..", "app", "dist", "server", "main.js");
+var CG_HOME = join3(homedir(), ".commandgarden");
+var TOKEN_PATH = join3(CG_HOME, "session-token");
+var CONFIG_PATH = join3(CG_HOME, "config.yaml");
 var BASE_URL = `http://127.0.0.1:19825`;
 function createClient() {
   const token = readToken(TOKEN_PATH);
@@ -4739,26 +5017,53 @@ daemon.command("stop").description("Stop the daemon").action(async () => {
   console.log(await executeDaemonStop(CG_HOME));
 });
 var audit = program.command("audit").description("View audit event log");
-audit.command("list").description("List recent audit events").option("--since <duration>", "time window, e.g. 7d, 2w, 12h").option("--connector <pattern>", "filter by connector pattern, e.g. test/*").option("--limit <n>", "max events to return", "100").action(async (opts) => {
+audit.command("list").description("List recent audit events").option("--since <duration>", "time window, e.g. 7d, 2w, 12h").option("--connector <pattern>", "filter by connector pattern, e.g. test/*").option("--type <pattern>", "filter by event type, e.g. auth.failed, command.*").option("--limit <n>", "max events to return", "100").action(async (opts) => {
   const client = createClient();
   const filter = {};
   if (opts.since) filter.since = parseDuration(opts.since).toISOString();
   if (opts.connector) filter.connector = opts.connector;
+  if (opts.type) filter.type = opts.type;
   filter.limit = parseInt(opts.limit, 10);
   console.log(await executeAuditList(client, filter));
 });
-audit.command("export").description("Export audit events").option("--format <format>", "export format: json, csv", "json").option("--since <duration>", "time window, e.g. 7d, 30d").option("--connector <pattern>", "filter by connector pattern").action(async (opts) => {
+audit.command("export").description("Export audit events").option("--format <format>", "export format: json, csv", "json").option("--since <duration>", "time window, e.g. 7d, 30d").option("--connector <pattern>", "filter by connector pattern").option("--type <pattern>", "filter by event type").action(async (opts) => {
   const client = createClient();
   const filter = {};
   if (opts.since) filter.since = parseDuration(opts.since).toISOString();
   if (opts.connector) filter.connector = opts.connector;
+  if (opts.type) filter.type = opts.type;
   console.log(await executeAuditExport(client, filter, opts.format));
 });
+audit.command("show <id>").description("Show full details of an audit event").action(async (id) => {
+  const client = createClient();
+  console.log(await executeAuditShow(client, id));
+});
 var config = program.command("config").description("Manage daemon configuration");
 config.command("show").description("Show current configuration").action(() => {
   console.log(executeConfigShow(CONFIG_PATH));
 });
-config.command("set <key> <value>").description("Set a configuration value (e.g. daemon.port 9999)").action((key, value) => {
-  console.log(executeConfigSet(CONFIG_PATH, key, value));
+config.command("set <key> <value>").description("Set a configuration value (e.g. daemon.port 9999)").action(async (key, value) => {
+  const client = createClient();
+  console.log(await executeConfigSet(client, key, value));
+});
+var gui = program.command("gui").description("Manage the GUI app server");
+gui.command("start", { isDefault: true }).description("Start the GUI (foreground by default)").option("-b, --background", "Run in background").option("--no-open", "Do not open browser").action(async (opts) => {
+  console.log(await executeGuiStart(BASE_URL, CG_HOME, APP_SCRIPT, {
+    background: opts.background,
+    noOpen: opts.open === false,
+    configPath: CONFIG_PATH
+  }));
+});
+gui.command("stop").description("Stop the GUI").action(() => {
+  console.log(executeGuiStop(CG_HOME));
+});
+gui.command("status").description("Check GUI status").action(() => {
+  console.log(executeGuiStatus(CG_HOME));
+});
+program.command("up").description("Start daemon + GUI, open browser").action(async () => {
+  console.log(await executeUp(BASE_URL, CG_HOME, DAEMON_SCRIPT, APP_SCRIPT, CONFIG_PATH));
+});
+program.command("down").description("Stop GUI + daemon").action(async () => {
+  console.log(await executeDown(CG_HOME));
 });
 program.parse();

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@commandgarden/cli",
-  "version": "0.1.0",
+  "version": "1.0.0",
   "description": "Enterprise browser automation CLI",
   "type": "module",
   "license": "MIT",
   "main": "./dist/main.js",
   "bin": {
-    "commandgarden": "./dist/main.js",
-    "cg": "./dist/main.js"
+    "commandgarden": "dist/main.js",
+    "cg": "dist/main.js"
   },
   "files": [
     "dist"