@commandgarden/cli 1.1.4 → 1.2.0

package/dist/main.js

@@ -12202,7 +12202,7 @@ var {
 
 // src/main.ts
 import { join as join4, dirname as dirname2, resolve } from "path";
-import { readFileSync as readFileSync7 } from "fs";
+import { readFileSync as readFileSync8 } from "fs";
 import { homedir } from "os";
 import { fileURLToPath } from "url";
 
@@ -12640,7 +12640,7 @@ function stepSummary(step) {
 // src/commands/validate.ts
 import { readFileSync as readFileSync3 } from "fs";
 
-// ../shared/dist/capabilities.js
+// node_modules/@commandgarden/shared/dist/capabilities.js
 var CAPABILITIES = [
   "navigate",
   "cookie_read",
@@ -16702,7 +16702,7 @@ var coerce = {
 };
 var NEVER = INVALID;
 
-// ../shared/dist/pipeline.js
+// node_modules/@commandgarden/shared/dist/pipeline.js
 var STEP_CAPABILITY_MAP = {
   navigate: "navigate",
   wait: "navigate",
@@ -16795,7 +16795,7 @@ var pipelineStepSchema = external_exports.discriminatedUnion("step", [
   jsEvaluateStepSchema
 ]);
 
-// ../shared/dist/connector.js
+// node_modules/@commandgarden/shared/dist/connector.js
 var capabilityEnum = external_exports.enum(CAPABILITIES);
 var connectorArgSchema = external_exports.object({
   name: external_exports.string(),
@@ -16822,7 +16822,7 @@ var connectorSchema = external_exports.object({
   pipeline: external_exports.array(pipelineStepSchema).min(1)
 });
 
-// ../shared/dist/loader.js
+// node_modules/@commandgarden/shared/dist/loader.js
 var import_yaml = __toESM(require_dist(), 1);
 function parseConnectorYaml(yamlContent) {
   let parsed;
@@ -16893,7 +16893,7 @@ function validateConnectorSemantics(connector) {
   return errors;
 }
 
-// ../shared/dist/events.js
+// node_modules/@commandgarden/shared/dist/events.js
 import { randomUUID } from "crypto";
 
 // src/commands/validate.ts
@@ -16932,8 +16932,47 @@ function executeValidate(filePath) {
 
 // src/commands/daemon-cmd.ts
 import { spawn } from "child_process";
-import { readFileSync as readFileSync4, writeFileSync, existsSync as existsSync2, unlinkSync, mkdirSync } from "fs";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync2, existsSync as existsSync3, unlinkSync as unlinkSync2, mkdirSync, openSync, closeSync } from "fs";
 import { join as join2 } from "path";
+
+// src/poll.ts
+async function pollUntilReady(opts) {
+  for (let i = 0; i < opts.maxAttempts; i++) {
+    if (!opts.isAlive()) return "died";
+    if (await opts.checkReady()) return "ready";
+    await new Promise((r) => setTimeout(r, opts.intervalMs));
+  }
+  return "timeout";
+}
+
+// src/process-alive.ts
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/lockfile.ts
+import { readFileSync as readFileSync4, writeFileSync, existsSync as existsSync2, unlinkSync } from "fs";
+function acquireLock(lockPath) {
+  if (existsSync2(lockPath)) {
+    const holderPid = parseInt(readFileSync4(lockPath, "utf-8").trim(), 10);
+    if (isProcessAlive(holderPid)) return { acquired: false, holderPid };
+  }
+  writeFileSync(lockPath, String(process.pid));
+  return { acquired: true };
+}
+function releaseLock(lockPath) {
+  try {
+    unlinkSync(lockPath);
+  } catch {
+  }
+}
+
+// src/commands/daemon-cmd.ts
 async function executeDaemonStatus(baseUrl) {
   try {
     const resp = await fetch(`${baseUrl}/api/status`);
@@ -16950,33 +16989,82 @@ async function executeDaemonStatus(baseUrl) {
 async function executeDaemonStart(baseUrl, cgHome, daemonScript) {
   try {
     const resp = await fetch(`${baseUrl}/api/status`);
-    if (resp.ok) return "Daemon is already running.";
+    if (resp.ok) return { status: "already-running", message: "Daemon is already running." };
   } catch {
   }
-  const pidPath = join2(cgHome, "daemon.pid");
   mkdirSync(cgHome, { recursive: true });
-  const child = spawn("node", [daemonScript], {
-    detached: true,
-    stdio: "ignore"
-  });
-  if (child.pid) {
-    writeFileSync(pidPath, String(child.pid));
+  const lockPath = join2(cgHome, "daemon.lock");
+  const lock = acquireLock(lockPath);
+  if (!lock.acquired) {
+    return {
+      status: "locked",
+      message: `Another cg up/daemon start is already in progress (PID ${lock.holderPid}).`
+    };
+  }
+  try {
+    const pidPath = join2(cgHome, "daemon.pid");
+    const logPath = join2(cgHome, "daemon.log");
+    console.error("Starting daemon...");
+    const logFd = openSync(logPath, "a");
+    const child = spawn("node", [daemonScript], { detached: true, stdio: ["ignore", logFd, logFd] });
+    closeSync(logFd);
+    let spawnFailed = false;
+    child.on("error", () => {
+      spawnFailed = true;
+    });
+    if (child.pid) writeFileSync2(pidPath, String(child.pid));
+    child.unref();
+    const outcome = await pollUntilReady({
+      checkReady: async () => {
+        try {
+          const resp = await fetch(`${baseUrl}/api/status`);
+          return resp.ok;
+        } catch {
+          return false;
+        }
+      },
+      isAlive: () => !spawnFailed && (!child.pid || isProcessAlive(child.pid)),
+      maxAttempts: 20,
+      intervalMs: 500
+    });
+    if (outcome === "ready") {
+      return { status: "started", message: `Daemon started (PID: ${child.pid ?? "unknown"}).`, pid: child.pid };
+    }
+    if (outcome === "died") {
+      if (existsSync3(pidPath)) unlinkSync2(pidPath);
+      const tail = readLogTail(logPath, 10);
+      return { status: "failed", message: `Daemon failed to start.
+${tail}` };
+    }
+    return {
+      status: "unresponsive",
+      message: `Daemon started (PID: ${child.pid ?? "unknown"}) but is not responding. Check ${logPath} for details.`,
+      pid: child.pid
+    };
+  } finally {
+    releaseLock(lockPath);
+  }
+}
+function readLogTail(logPath, lines) {
+  try {
+    const content = readFileSync5(logPath, "utf-8");
+    return content.split("\n").slice(-lines).join("\n").trim();
+  } catch {
+    return "(no log available)";
   }
-  child.unref();
-  return `Daemon started (PID: ${child.pid ?? "unknown"}).`;
 }
 async function executeDaemonStop(cgHome) {
   const pidPath = join2(cgHome, "daemon.pid");
-  if (!existsSync2(pidPath)) {
+  if (!existsSync3(pidPath)) {
     return "Daemon is not running (no PID file found).";
   }
-  const pid = parseInt(readFileSync4(pidPath, "utf-8").trim(), 10);
+  const pid = parseInt(readFileSync5(pidPath, "utf-8").trim(), 10);
   try {
     process.kill(pid, "SIGTERM");
-    unlinkSync(pidPath);
+    unlinkSync2(pidPath);
     return `Daemon stopped (PID: ${pid}).`;
   } catch {
-    unlinkSync(pidPath);
+    unlinkSync2(pidPath);
     return `Daemon process ${pid} not found (stale PID file cleaned up).`;
   }
 }
@@ -17106,16 +17194,16 @@ async function executeAuditShow(client, id) {
 }
 
 // src/commands/config-cmd.ts
-import { readFileSync as readFileSync5, existsSync as existsSync3 } from "fs";
+import { readFileSync as readFileSync6, existsSync as existsSync4 } from "fs";
 function executeConfigShow(configPath) {
-  if (!existsSync3(configPath)) {
+  if (!existsSync4(configPath)) {
     return [
       "No config file found.",
       `Expected at: ${configPath}`,
       'Using defaults. Run "commandgarden config set <key> <value>" to create one.'
     ].join("\n");
   }
-  return readFileSync5(configPath, "utf-8");
+  return readFileSync6(configPath, "utf-8");
 }
 async function executeConfigSet(client, key, value) {
   try {
@@ -17129,12 +17217,12 @@ async function executeConfigSet(client, key, value) {
 // src/commands/gui-cmd.ts
 var import_yaml2 = __toESM(require_dist(), 1);
 import { spawn as spawn2 } from "child_process";
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync2, existsSync as existsSync4, unlinkSync as unlinkSync2, mkdirSync as mkdirSync2, openSync, closeSync } from "fs";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync3, existsSync as existsSync5, unlinkSync as unlinkSync3, mkdirSync as mkdirSync2, openSync as openSync2, closeSync as closeSync2 } from "fs";
 import { join as join3 } from "path";
 function readAppPort(configPath) {
   try {
-    if (existsSync4(configPath)) {
-      const config2 = (0, import_yaml2.parse)(readFileSync6(configPath, "utf-8"));
+    if (existsSync5(configPath)) {
+      const config2 = (0, import_yaml2.parse)(readFileSync7(configPath, "utf-8"));
       const port = config2?.app?.port;
       if (typeof port === "number") return port;
     }
@@ -17148,41 +17236,68 @@ async function executeGuiStart(baseUrl, cgHome, appScript, opts) {
     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 message = "Daemon is not running. Start it with: cg daemon start (or use cg up)";
+    return opts.background ? { status: "failed", message } : message;
   }
   const pidPath = join3(cgHome, "app.pid");
-  if (existsSync4(pidPath)) {
-    const pid = parseInt(readFileSync6(pidPath, "utf-8").trim(), 10);
-    try {
-      process.kill(pid, 0);
-      return "GUI is already running.";
-    } catch {
-      unlinkSync2(pidPath);
+  if (existsSync5(pidPath)) {
+    const pid = parseInt(readFileSync7(pidPath, "utf-8").trim(), 10);
+    if (isProcessAlive(pid)) {
+      const message = "GUI is already running.";
+      if (!opts.noOpen) openBrowser(`http://127.0.0.1:${appPort}`);
+      return opts.background ? { status: "already-running", message } : message;
     }
+    unlinkSync3(pidPath);
   }
   mkdirSync2(cgHome, { recursive: true });
   if (opts.background) {
-    const logPath = join3(cgHome, "app.log");
-    const logFd = openSync(logPath, "a");
-    const child2 = spawn2("node", [appScript], { detached: true, stdio: ["ignore", logFd, logFd] });
-    closeSync(logFd);
-    if (child2.pid) writeFileSync2(pidPath, String(child2.pid));
-    child2.unref();
-    if (!opts.noOpen) {
+    const lockPath = join3(cgHome, "app.lock");
+    const lock = acquireLock(lockPath);
+    if (!lock.acquired) {
+      return { status: "locked", message: `Another cg up/gui start is already in progress (PID ${lock.holderPid}).` };
+    }
+    try {
+      console.error("Starting GUI...");
+      const logPath = join3(cgHome, "app.log");
+      const logFd = openSync2(logPath, "a");
+      const child2 = spawn2("node", [appScript], { detached: true, stdio: ["ignore", logFd, logFd] });
+      closeSync2(logFd);
+      let spawnFailed = false;
+      child2.on("error", () => {
+        spawnFailed = true;
+      });
+      if (child2.pid) writeFileSync3(pidPath, String(child2.pid));
+      child2.unref();
+      if (opts.noOpen) {
+        return { status: "started", message: `GUI started (PID: ${child2.pid ?? "unknown"}).`, pid: child2.pid };
+      }
       const appUrl = `http://127.0.0.1:${appPort}`;
-      const ready = await waitForServer(appUrl, child2);
-      if (ready) {
+      const outcome = await pollUntilReady({
+        checkReady: async () => {
+          try {
+            await fetch(appUrl);
+            return true;
+          } catch {
+            return false;
+          }
+        },
+        isAlive: () => !spawnFailed && (!child2.pid || isProcessAlive(child2.pid)),
+        maxAttempts: 40,
+        intervalMs: 500
+      });
+      if (outcome === "ready") {
         openBrowser(appUrl);
-      } else {
-        if (child2.pid) try {
-          process.kill(child2.pid, "SIGTERM");
-        } catch {
-        }
-        if (existsSync4(pidPath)) unlinkSync2(pidPath);
-        return `GUI failed to start. Check ${logPath} for errors.`;
+        return { status: "started", message: `GUI started (PID: ${child2.pid ?? "unknown"}).`, pid: child2.pid };
+      }
+      if (child2.pid) try {
+        process.kill(child2.pid, "SIGTERM");
+      } catch {
       }
+      if (existsSync5(pidPath)) unlinkSync3(pidPath);
+      return { status: "failed", message: `GUI failed to start. Check ${logPath} for errors.` };
+    } finally {
+      releaseLock(lockPath);
     }
-    return `GUI started (PID: ${child2.pid ?? "unknown"}).`;
   }
   const child = spawn2("node", [appScript], { stdio: "inherit" });
   if (!opts.noOpen) {
@@ -17195,21 +17310,21 @@ async function executeGuiStart(baseUrl, cgHome, appScript, opts) {
 }
 function executeGuiStop(cgHome) {
   const pidPath = join3(cgHome, "app.pid");
-  if (!existsSync4(pidPath)) return "GUI is not running (no PID file found).";
-  const pid = parseInt(readFileSync6(pidPath, "utf-8").trim(), 10);
+  if (!existsSync5(pidPath)) return "GUI is not running (no PID file found).";
+  const pid = parseInt(readFileSync7(pidPath, "utf-8").trim(), 10);
   try {
     process.kill(pid, "SIGTERM");
-    unlinkSync2(pidPath);
+    unlinkSync3(pidPath);
     return `GUI stopped (PID: ${pid}).`;
   } catch {
-    unlinkSync2(pidPath);
+    unlinkSync3(pidPath);
     return `GUI process ${pid} not found (stale PID file cleaned up).`;
   }
 }
 function executeGuiStatus(cgHome) {
   const pidPath = join3(cgHome, "app.pid");
-  if (!existsSync4(pidPath)) return "GUI: not running (no PID file found).";
-  const pid = parseInt(readFileSync6(pidPath, "utf-8").trim(), 10);
+  if (!existsSync5(pidPath)) return "GUI: not running (no PID file found).";
+  const pid = parseInt(readFileSync7(pidPath, "utf-8").trim(), 10);
   try {
     process.kill(pid, 0);
     return `GUI: running (PID: ${pid}).`;
@@ -17234,23 +17349,28 @@ async function waitForServer(url, child) {
   return false;
 }
 function openBrowser(url) {
+  console.error("Opening browser...");
   const child = process.platform === "darwin" ? spawn2("open", [url], { stdio: "ignore" }) : process.platform === "win32" ? spawn2("cmd", ["/c", "start", "", url], { stdio: "ignore" }) : spawn2("xdg-open", [url], { stdio: "ignore" });
+  child.on("error", () => {
+  });
   child.unref();
 }
 
 // src/commands/up-down.ts
-async function executeUp(baseUrl, cgHome, daemonScript, appScript, configPath) {
+async function executeUp(baseUrl, cgHome, daemonScript, appScript, configPath, opts = {}) {
   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));
+  const daemonResult = await executeDaemonStart(baseUrl, cgHome, daemonScript);
+  lines.push(daemonResult.message);
+  const canProceed = daemonResult.status === "started" || daemonResult.status === "already-running";
+  if (!canProceed) {
+    return lines.join("\n");
   }
-  lines.push(await executeGuiStart(baseUrl, cgHome, appScript, { background: true, configPath }));
+  const guiResult = await executeGuiStart(baseUrl, cgHome, appScript, {
+    background: true,
+    configPath,
+    noOpen: opts.noOpen
+  });
+  lines.push(typeof guiResult === "string" ? guiResult : guiResult.message);
   return lines.join("\n");
 }
 async function executeDown(cgHome) {
@@ -17266,7 +17386,7 @@ var __filename = fileURLToPath(import.meta.url);
 var __dirname = dirname2(__filename);
 var CLI_VERSION = (() => {
   try {
-    const pkg = JSON.parse(readFileSync7(resolve(__dirname, "..", "package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync8(resolve(__dirname, "..", "package.json"), "utf-8"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -17316,7 +17436,8 @@ daemon.command("status").description("Check daemon status").action(async () => {
   console.log(await executeDaemonStatus(BASE_URL));
 });
 daemon.command("start").description("Start the daemon in background").action(async () => {
-  console.log(await executeDaemonStart(BASE_URL, CG_HOME, getDaemonScript()));
+  const result = await executeDaemonStart(BASE_URL, CG_HOME, getDaemonScript());
+  console.log(result.message);
 });
 daemon.command("stop").description("Stop the daemon").action(async () => {
   console.log(await executeDaemonStop(CG_HOME));
@@ -17353,11 +17474,12 @@ config.command("set <key> <value>").description("Set a configuration value (e.g.
 });
 var gui = program2.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, getAppScript(), {
+  const result = await executeGuiStart(BASE_URL, CG_HOME, getAppScript(), {
     background: opts.background,
     noOpen: opts.open === false,
     configPath: CONFIG_PATH
-  }));
+  });
+  console.log(typeof result === "string" ? result : result.message);
 });
 gui.command("stop").description("Stop the GUI").action(() => {
   console.log(executeGuiStop(CG_HOME));
@@ -17365,8 +17487,10 @@ gui.command("stop").description("Stop the GUI").action(() => {
 gui.command("status").description("Check GUI status").action(() => {
   console.log(executeGuiStatus(CG_HOME));
 });
-program2.command("up").description("Start daemon + GUI, open browser").action(async () => {
-  console.log(await executeUp(BASE_URL, CG_HOME, getDaemonScript(), getAppScript(), CONFIG_PATH));
+program2.command("up").description("Start daemon + GUI, open browser (use --no-open to skip)").option("--no-open", "Do not open browser").action(async (opts) => {
+  console.log(await executeUp(BASE_URL, CG_HOME, getDaemonScript(), getAppScript(), CONFIG_PATH, {
+    noOpen: opts.open === false
+  }));
 });
 program2.command("down").description("Stop GUI + daemon").action(async () => {
   console.log(await executeDown(CG_HOME));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@commandgarden/cli",
-  "version": "1.1.4",
+  "version": "1.2.0",
   "description": "Enterprise browser automation CLI",
   "type": "module",
   "license": "MIT",