forge-cw 0.1.0 → 0.1.2

package/dist/index.js

@@ -260,8 +260,17 @@ var init_runner = __esm({
           const proc = spawn("sh", ["-c", command], {
             cwd: options.cwd,
             env: { ...process.env, ...options.env },
-            stdio: ["ignore", "pipe", "pipe"]
+            stdio: ["ignore", "pipe", "pipe"],
+            detached: true
           });
+          const stop = () => {
+            try {
+              if (proc.pid)
+                process.kill(-proc.pid, "SIGTERM");
+            } catch {
+              proc.kill("SIGTERM");
+            }
+          };
           const handleData = (data) => {
             const str2 = data.toString();
             output += str2;
@@ -270,14 +279,12 @@ var init_runner = __esm({
           proc.stdout.on("data", handleData);
           proc.stderr.on("data", handleData);
           if (options.signal) {
-            options.signal.addEventListener("abort", () => {
-              proc.kill("SIGTERM");
-            }, { once: true });
+            options.signal.addEventListener("abort", stop, { once: true });
           }
           if (options.timeout) {
             timeoutId = setTimeout(() => {
               timedOut = true;
-              proc.kill("SIGTERM");
+              stop();
             }, options.timeout);
           }
           proc.on("close", (code) => {
@@ -630,45 +637,46 @@ var init_cw_reader = __esm({
       getSkillDir(scope, scopeRef, name) {
         return join2(this.getSkillConfigDir(scope, scopeRef), "skills", name);
       }
-      getSkills(account, project) {
+      // global, every account and every registered project
+      getSkills() {
+        return [
+          ...this.scanSkills(join2(this.getSkillConfigDir("global", "global"), "skills"), "global", "global"),
+          ...this.getAccounts().flatMap((a) => this.scanSkills(join2(this.getSkillConfigDir("account", a), "skills"), "account", a)),
+          ...Object.entries(this.getProjects()).flatMap(([name, p]) => this.scanSkills(join2(p.path, ".claude", "skills"), "project", name))
+        ];
+      }
+      scanSkills(dir, scope, scopeRef) {
         const results = [];
-        const scanDir = (dir, scope, scopeRef) => {
-          if (!existsSync2(dir))
-            return;
-          const entries = readdirSync2(dir, { withFileTypes: true });
-          for (const entry of entries) {
-            if (!entry.isDirectory())
-              continue;
-            if (entry.name.startsWith("acct--"))
-              continue;
-            const fullPath = join2(dir, entry.name);
-            const skillMd = join2(fullPath, "SKILL.md");
-            if (!existsSync2(skillMd))
-              continue;
-            try {
-              const content = readFileSync2(skillMd, "utf-8");
-              const { frontmatter } = this.parseFrontmatter(content);
-              const refsDir = join2(fullPath, "references");
-              const hasReferences = existsSync2(refsDir) && readdirSync2(refsDir).some((f) => f.endsWith(".md"));
-              results.push({
-                name: String(frontmatter["name"] ?? entry.name),
-                dirName: entry.name,
-                scope,
-                scopeRef,
-                description: String(frontmatter["description"] ?? ""),
-                domain: frontmatter["domain"] ? String(frontmatter["domain"]) : void 0,
-                triggers: frontmatter["triggers"] ? String(frontmatter["triggers"]) : void 0,
-                hasReferences
-              });
-            } catch {
-            }
+        if (!existsSync2(dir))
+          return results;
+        const entries = readdirSync2(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (!entry.isDirectory())
+            continue;
+          if (entry.name.startsWith("acct--"))
+            continue;
+          const fullPath = join2(dir, entry.name);
+          const skillMd = join2(fullPath, "SKILL.md");
+          if (!existsSync2(skillMd))
+            continue;
+          try {
+            const content = readFileSync2(skillMd, "utf-8");
+            const { frontmatter } = this.parseFrontmatter(content);
+            const refsDir = join2(fullPath, "references");
+            const hasReferences = existsSync2(refsDir) && readdirSync2(refsDir).some((f) => f.endsWith(".md"));
+            results.push({
+              name: String(frontmatter["name"] ?? entry.name),
+              dirName: entry.name,
+              scope,
+              scopeRef,
+              description: String(frontmatter["description"] ?? ""),
+              domain: frontmatter["domain"] ? String(frontmatter["domain"]) : void 0,
+              triggers: frontmatter["triggers"] ? String(frontmatter["triggers"]) : void 0,
+              hasReferences
+            });
+          } catch {
           }
-        };
-        scanDir(join2(this.getSkillConfigDir("global", "global"), "skills"), "global", "global");
-        if (account)
-          scanDir(join2(this.getSkillConfigDir("account", account), "skills"), "account", account);
-        if (project)
-          scanDir(join2(this.getSkillConfigDir("project", project), "skills"), "project", project);
+        }
         return results;
       }
       getSkill(scope, scopeRef, name) {
@@ -2528,7 +2536,7 @@ var init_plugins = __esm({
 
 // ../core/dist/skill-routes.js
 import { Hono as Hono2 } from "hono";
-import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, rmSync as rmSync2, existsSync as existsSync7, unlinkSync } from "node:fs";
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, rmSync as rmSync2, existsSync as existsSync7, unlinkSync, cpSync } from "node:fs";
 import { dirname as dirname2, join as join9 } from "node:path";
 function installFailure(result2) {
   try {
@@ -2552,10 +2560,32 @@ function skillRoutes(reader, options = {}) {
   const remoteOf = options.remoteOf ?? createRemoteLookup(runCommand);
   const app = new Hono2();
   const updating = /* @__PURE__ */ new Set();
-  app.get("/", (c) => {
-    const account = c.req.query("account");
-    const project = c.req.query("project");
-    return c.json(reader.getSkills(account, project));
+  const refOf = (scope, scopeRef) => scope === "global" ? "global" : scopeRef ?? "";
+  const knownScope = (scope, ref) => scope === "global" || (scope === "account" ? reader.getAccounts().includes(ref) : scope === "project" && ref in reader.getProjects());
+  app.get("/", (c) => c.json(reader.getSkills()));
+  app.post("/copy", async (c) => {
+    const { from, to } = await c.req.json();
+    const fromRef = refOf(from.scope, from.scopeRef);
+    const toRef = refOf(to.scope, to.scopeRef);
+    if (!SKILL_NAME_RE.test(from.name))
+      return c.json({ error: "Invalid skill name" }, 400);
+    if (!knownScope(from.scope, fromRef))
+      return c.json({ error: `Unknown ${from.scope}: ${fromRef}` }, 404);
+    if (!knownScope(to.scope, toRef))
+      return c.json({ error: `Unknown ${to.scope}: ${toRef}` }, 404);
+    const source = reader.getSkillDir(from.scope, fromRef, from.name);
+    const target = reader.getSkillDir(to.scope, toRef, from.name);
+    if (!existsSync7(join9(source, "SKILL.md")))
+      return c.json({ error: "Skill not found" }, 404);
+    if (existsSync7(target))
+      return c.json({ error: `${from.name} already exists in ${toRef}` }, 409);
+    try {
+      cpSync(source, target, { recursive: true });
+      return c.json({ ok: true });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error";
+      return c.json({ error: `Failed to copy skill: ${message}` }, 500);
+    }
   });
   app.get("/global/:name", (c) => {
     const name = c.req.param("name");
@@ -2701,9 +2731,8 @@ function skillRoutes(reader, options = {}) {
     if (!repo || !skill) {
       return c.json({ error: "repo and skill are required" }, 400);
     }
-    const ref = scope === "global" ? "global" : scopeRef ?? "";
-    const known = scope === "global" || (scope === "account" ? reader.getAccounts().includes(ref) : ref in reader.getProjects());
-    if (!known) {
+    const ref = refOf(scope, scopeRef);
+    if (!knownScope(scope, ref)) {
       return c.json({ error: `Unknown ${scope}: ${ref}` }, 404);
     }
     const configDir = reader.getSkillConfigDir(scope, ref);
@@ -2754,7 +2783,7 @@ function skillRoutes(reader, options = {}) {
   });
   return app;
 }
-var INSTALL_TIMEOUT_MS;
+var INSTALL_TIMEOUT_MS, SKILL_NAME_RE;
 var init_skill_routes = __esm({
   "../core/dist/skill-routes.js"() {
     "use strict";
@@ -2762,6 +2791,7 @@ var init_skill_routes = __esm({
     init_task_review();
     init_plugins();
     INSTALL_TIMEOUT_MS = 12e4;
+    SKILL_NAME_RE = /^\w[\w.-]*$/;
   }
 });
 
@@ -3143,9 +3173,8 @@ var init_terminal_screen = __esm({
       write(data) {
         this.term.write(data);
       }
-      // a resize applies at once while writes wait to be parsed, so it waits its turn behind them
       resize(cols, rows) {
-        this.term.write("", () => this.term.resize(cols, rows));
+        this.term.resize(cols, rows);
       }
       // rows oldest first, scrollback included, without the blank rows under the last one written
       read() {
@@ -3401,17 +3430,22 @@ var init_state_log = __esm({
 
 // ../core/dist/pty-routes.js
 import { WebSocketServer, WebSocket } from "ws";
-function takeSession(reader, project, sessionDir) {
+function takeSession(reader, project, sessionDir, general) {
   const sessionId = `${project}::${sessionDir}`;
   const pending = pendingSessions.get(sessionId);
   if (pending) {
     pendingSessions.delete(sessionId);
+    if (pending.type === "general")
+      general?.remember(sessionId, pending);
     return { session: pending, isNew: true };
   }
   const session = reader.getSession(project, sessionDir);
-  return session ? { session, isNew: false } : null;
+  if (session)
+    return { session, isNew: false };
+  const known = general?.get(sessionId);
+  return known ? { session: known, isNew: true } : null;
 }
-function createTerminalWss(manager, reader, { localOnly = true } = {}) {
+function createTerminalWss(manager, reader, { localOnly = true, general } = {}) {
   const wss = new WebSocketServer({ noServer: true });
   function wireWs(ws, sessionId, project, sessionDir) {
     const client = {
@@ -3448,18 +3482,18 @@ function createTerminalWss(manager, reader, { localOnly = true } = {}) {
       wireWs(ws, sessionId, project, sessionDir);
       return;
     }
-    const taken = takeSession(reader, project, sessionDir);
+    const taken = takeSession(reader, project, sessionDir, general);
     if (!taken) {
       console.log(`[pty-ws] Session not found: ${project}/${sessionDir}`);
       ws.send(JSON.stringify({ type: "error", message: `Session not found: ${project}/${sessionDir}` }));
-      ws.close();
+      ws.close(REFUSED_CLOSE_CODE);
       return;
     }
     const ptySession = manager.getOrCreate(project, sessionDir, taken.session, { isNew: taken.isNew });
     if (!ptySession) {
       console.error(`[pty-ws] Failed to spawn terminal for: ${project}/${sessionDir}`);
       ws.send(JSON.stringify({ type: "error", message: `Failed to start terminal for ${project}/${sessionDir}` }));
-      ws.close();
+      ws.close(REFUSED_CLOSE_CODE);
       return;
     }
     wireWs(ws, sessionId, project, sessionDir);
@@ -3495,16 +3529,67 @@ function parseTerminalUpgradeUrl(pathname) {
     return null;
   }
 }
+var REFUSED_CLOSE_CODE;
 var init_pty_routes = __esm({
   "../core/dist/pty-routes.js"() {
     "use strict";
     init_cw_routes();
     init_origin_guard();
+    REFUSED_CLOSE_CODE = 4404;
+  }
+});
+
+// ../core/dist/general-sessions.js
+import { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4 } from "node:fs";
+import { dirname as dirname5 } from "node:path";
+var MAX_AGE_MS, GeneralSessions;
+var init_general_sessions = __esm({
+  "../core/dist/general-sessions.js"() {
+    "use strict";
+    MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+    GeneralSessions = class {
+      file;
+      sessions = /* @__PURE__ */ new Map();
+      constructor(file = null, now = Date.now()) {
+        this.file = file;
+        if (!file || !existsSync9(file))
+          return;
+        try {
+          const saved = JSON.parse(readFileSync7(file, "utf-8"));
+          for (const [key, session] of Object.entries(saved)) {
+            if (now - Date.parse(session.created) < MAX_AGE_MS)
+              this.sessions.set(key, session);
+          }
+        } catch {
+        }
+      }
+      get(key) {
+        return this.sessions.get(key);
+      }
+      remember(key, session) {
+        this.sessions.set(key, session);
+        this.save();
+      }
+      forget(key) {
+        if (this.sessions.delete(key))
+          this.save();
+      }
+      save() {
+        if (!this.file)
+          return;
+        try {
+          mkdirSync4(dirname5(this.file), { recursive: true });
+          writeFileSync3(this.file, JSON.stringify(Object.fromEntries(this.sessions), null, 2));
+        } catch (err) {
+          console.warn(`[pty] could not save general sessions: ${err.message}`);
+        }
+      }
+    };
   }
 });
 
 // ../core/dist/liveframe.js
-import { existsSync as existsSync9, readFileSync as readFileSync7, readdirSync as readdirSync5 } from "node:fs";
+import { existsSync as existsSync10, readFileSync as readFileSync8, readdirSync as readdirSync5 } from "node:fs";
 import { mkdir, rm } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
 import { join as join11 } from "node:path";
@@ -3523,7 +3608,7 @@ function parseFrameUrl(stdout) {
 }
 function readJson2(path) {
   try {
-    return JSON.parse(readFileSync7(path, "utf8"));
+    return JSON.parse(readFileSync8(path, "utf8"));
   } catch {
     return null;
   }
@@ -3596,7 +3681,7 @@ var init_liveframe = __esm({
         return this.readFrame(project, frame, this.config().api);
       }
       listFrames() {
-        if (!existsSync9(this.root))
+        if (!existsSync10(this.root))
           return [];
         const { api } = this.config();
         const frames = [];
@@ -3636,7 +3721,7 @@ var init_liveframe = __esm({
         return this.exclusive(project, frame, async () => {
           const projectDir = join11(this.root, project);
           const dir = this.frameDir(project, frame);
-          if (existsSync9(dir))
+          if (existsSync10(dir))
             throw new LiveframeError(`${project}/${frame} already exists in ${this.root}`, 409);
           await mkdir(projectDir, { recursive: true });
           try {
@@ -3715,7 +3800,7 @@ var init_liveframe_routes = __esm({
 import { Hono as Hono4 } from "hono";
 import { cors } from "hono/cors";
 import { join as join12, basename as basename3, resolve as resolve4 } from "node:path";
-import { readdirSync as readdirSync6, existsSync as existsSync10 } from "node:fs";
+import { readdirSync as readdirSync6, existsSync as existsSync11 } from "node:fs";
 function createForgeServer(options) {
   const { dataDir, db: externalDb, authToken, localOnly = true } = options;
   const dbPath = join12(dataDir, "forge.db");
@@ -3752,13 +3837,15 @@ function createForgeServer(options) {
     }
   });
   const ptyManager = new PTYManager(states);
-  const terminalWss = createTerminalWss(ptyManager, cwReader, { localOnly });
+  const generalSessions = new GeneralSessions(join12(dataDir, "general-sessions.json"));
+  const terminalWss = createTerminalWss(ptyManager, cwReader, { localOnly, general: generalSessions });
   app.route("/api/liveframe", liveframeRoutes());
   app.get("/api/cw/session-states", (c) => c.json({ classifier: states.remoteName ?? "local", shadow: states.isShadow, states: states.snapshot() }));
   app.post("/api/cw/terminal/kill", async (c) => {
     const { project, sessionDir } = await c.req.json();
     const sessionId = `${project}::${sessionDir}`;
     ptyManager.kill(sessionId);
+    generalSessions.forget(sessionId);
     return c.json({ ok: true });
   });
   async function resolveAction(c) {
@@ -3895,7 +3982,7 @@ data: ${JSON.stringify(data)}
     if (!dir.startsWith(home)) {
       return c.json({ error: "Access denied: path must be within home directory" }, 403);
     }
-    if (!existsSync10(dir)) {
+    if (!existsSync11(dir)) {
       return c.json({ error: "Directory not found" }, 404);
     }
     try {
@@ -3903,8 +3990,8 @@ data: ${JSON.stringify(data)}
       const dirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => ({
         name: e.name,
         path: join12(dir, e.name),
-        hasPackageJson: existsSync10(join12(dir, e.name, "package.json")),
-        hasGit: existsSync10(join12(dir, e.name, ".git"))
+        hasPackageJson: existsSync11(join12(dir, e.name, "package.json")),
+        hasGit: existsSync11(join12(dir, e.name, ".git"))
       })).sort((a, b) => a.name.localeCompare(b.name));
       return c.json({
         current: dir,
@@ -3947,6 +4034,7 @@ var init_server = __esm({
     init_state_log();
     init_pty_routes();
     init_login_manager();
+    init_general_sessions();
     init_liveframe_routes();
   }
 });
@@ -4081,7 +4169,7 @@ var init_db_factory = __esm({
 });
 
 // ../core/dist/init.js
-import { existsSync as existsSync11, mkdirSync as mkdirSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync5, writeFileSync as writeFileSync4 } from "node:fs";
 import { join as join13 } from "node:path";
 import { homedir as homedir5 } from "node:os";
 function getForgeDir() {
@@ -4089,14 +4177,14 @@ function getForgeDir() {
 }
 function ensureForgeDir() {
   const forgeDir = getForgeDir();
-  if (existsSync11(forgeDir)) {
+  if (existsSync12(forgeDir)) {
     return { forgeDir, created: false };
   }
-  mkdirSync4(forgeDir, { recursive: true });
+  mkdirSync5(forgeDir, { recursive: true });
   for (const d of FORGE_SUBDIRS) {
-    mkdirSync4(join13(forgeDir, d), { recursive: true });
+    mkdirSync5(join13(forgeDir, d), { recursive: true });
   }
-  writeFileSync3(join13(forgeDir, "config.json"), JSON.stringify({
+  writeFileSync4(join13(forgeDir, "config.json"), JSON.stringify({
     port: 3e3,
     theme: "dark",
     openBrowser: true,
@@ -4115,11 +4203,11 @@ var init_init = __esm({
 // ../core/dist/cw-install.js
 import { execFile as execFile5 } from "node:child_process";
 import { createHash as createHash2 } from "node:crypto";
-import { accessSync as accessSync2, constants as constants2, existsSync as existsSync12, readFileSync as readFileSync8, statSync as statSync3, writeFileSync as writeFileSync4 } from "node:fs";
+import { accessSync as accessSync2, constants as constants2, existsSync as existsSync13, readFileSync as readFileSync9, statSync as statSync3, writeFileSync as writeFileSync5 } from "node:fs";
 import { delimiter as delimiter2, join as join14 } from "node:path";
 function readCwVersion(file) {
   try {
-    const match = /^CW_VERSION="([^"]+)"/m.exec(readFileSync8(file, "utf-8"));
+    const match = /^CW_VERSION="([^"]+)"/m.exec(readFileSync9(file, "utf-8"));
     return match ? match[1] : null;
   } catch {
     return null;
@@ -4137,9 +4225,9 @@ function compareVersions(a, b) {
 }
 function readCwBundle(dir) {
   try {
-    const { ref } = JSON.parse(readFileSync8(join14(dir, ".bundle.json"), "utf-8"));
+    const { ref } = JSON.parse(readFileSync9(join14(dir, ".bundle.json"), "utf-8"));
     const version = readCwVersion(join14(dir, "cw"));
-    if (!ref || !version || !existsSync12(join14(dir, "install.sh")))
+    if (!ref || !version || !existsSync13(join14(dir, "install.sh")))
       return null;
     return { dir, version, ref };
   } catch {
@@ -4187,7 +4275,7 @@ function pathWithCw(cwHome, pathVar) {
 }
 function readMarker(cwHome) {
   try {
-    return JSON.parse(readFileSync8(join14(cwHome, MARKER_FILE), "utf-8"));
+    return JSON.parse(readFileSync9(join14(cwHome, MARKER_FILE), "utf-8"));
   } catch {
     return null;
   }
@@ -4203,7 +4291,7 @@ async function ensureCw(options) {
   const run = options.run ?? runInstall;
   const bin = join14(cwHome, "bin", "cw");
   const bundle = readCwBundle(bundleDir);
-  const installed = existsSync12(bin) ? { version: readCwVersion(bin), sha256: sha256Of(bin) } : null;
+  const installed = existsSync13(bin) ? { version: readCwVersion(bin), sha256: sha256Of(bin) } : null;
   const decision = decideCwInstall({
     bundle,
     installed,
@@ -4214,10 +4302,10 @@ async function ensureCw(options) {
   if (decision.action === "skip" || !bundle)
     return { action: "skipped", message: decision.reason };
   const { code, output } = await run(join14(bundle.dir, "install.sh"), ["--no-shell"], { ...env, CW_HOME: cwHome });
-  if (code !== 0 || !existsSync12(bin))
+  if (code !== 0 || !existsSync13(bin))
     return { action: "failed", message: failureMessage2(output) };
   const marker = { version: bundle.version, ref: bundle.ref, sha256: sha256Of(bin) };
-  writeFileSync4(join14(cwHome, MARKER_FILE), JSON.stringify(marker, null, 2) + "\n");
+  writeFileSync5(join14(cwHome, MARKER_FILE), JSON.stringify(marker, null, 2) + "\n");
   return {
     action: decision.action === "install" ? "installed" : "updated",
     version: bundle.version,
@@ -4231,7 +4319,7 @@ var init_cw_install = __esm({
     MARKER_FILE = ".forge-cw.json";
     INSTALL_TIMEOUT_MS2 = 12e4;
     ANSI_RE3 = /\u001b\[[0-9;?]*[A-Za-z]/g;
-    sha256Of = (file) => createHash2("sha256").update(readFileSync8(file)).digest("hex");
+    sha256Of = (file) => createHash2("sha256").update(readFileSync9(file)).digest("hex");
     runInstall = (script, args, env) => new Promise((resolve5) => {
       execFile5("bash", [script, ...args], { env, timeout: INSTALL_TIMEOUT_MS2, maxBuffer: 1024 * 1024 }, (err, stdout, stderr) => {
         const output = `${String(stdout)}${String(stderr)}`;
@@ -4244,6 +4332,52 @@ var init_cw_install = __esm({
   }
 });
 
+// ../core/dist/port-in-use.js
+function waitForListening(server) {
+  if (server.listening)
+    return Promise.resolve();
+  return new Promise((resolve5, reject) => {
+    const onError = (err) => {
+      server.off("listening", onListening);
+      reject(err);
+    };
+    const onListening = () => {
+      server.off("error", onError);
+      resolve5();
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+  });
+}
+async function probePort(port, timeoutMs = 1500) {
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/api/health`, { signal: AbortSignal.timeout(timeoutMs) });
+    const body = await res.json().catch(() => null);
+    return body?.status === "ok" && typeof body.modules === "number" ? "forge" : "other";
+  } catch (err) {
+    return err.name === "TimeoutError" ? "unresponsive" : "other";
+  }
+}
+function portInUseMessage(port, holder) {
+  const next = `Start on another port with --port ${port + 1} (or FORGE_PORT=${port + 1}).`;
+  const find = `Find it with: lsof -nP -iTCP:${port} -sTCP:LISTEN`;
+  if (holder === "forge")
+    return `Forge is already running at http://localhost:${port}.`;
+  if (holder === "unresponsive") {
+    return [
+      `Port ${port} is taken by a process that does not answer, often a Forge suspended with Ctrl+Z.`,
+      `${find}, then bring it back with \`fg\` in its terminal or stop it with \`kill <pid>\`.`,
+      next
+    ].join("\n  ");
+  }
+  return [`Port ${port} is in use by another program.`, find, next].join("\n  ");
+}
+var init_port_in_use = __esm({
+  "../core/dist/port-in-use.js"() {
+    "use strict";
+  }
+});
+
 // ../core/dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
@@ -4269,10 +4403,13 @@ __export(dist_exports, {
   getForgeDir: () => getForgeDir,
   liveframeRoutes: () => liveframeRoutes,
   pathWithCw: () => pathWithCw,
+  portInUseMessage: () => portInUseMessage,
+  probePort: () => probePort,
   quietSqliteWarning: () => quietSqliteWarning,
   resolveListenOptions: () => resolveListenOptions,
   skillRoutes: () => skillRoutes,
-  supports: () => supports
+  supports: () => supports,
+  waitForListening: () => waitForListening
 });
 var init_dist = __esm({
   "../core/dist/index.js"() {
@@ -4295,11 +4432,12 @@ var init_dist = __esm({
     init_pty_routes();
     init_liveframe_routes();
     init_liveframe();
+    init_port_in_use();
   }
 });
 
 // src/index.ts
-import { existsSync as existsSync13 } from "node:fs";
+import { existsSync as existsSync14 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
 import { join as join15 } from "node:path";
 function parseArgs(argv) {
@@ -4313,10 +4451,10 @@ function parseArgs(argv) {
   return out;
 }
 var packageRoot = join15(import.meta.dirname, "..");
-var isCheckout = existsSync13(join15(packageRoot, "src"));
+var isCheckout = existsSync14(join15(packageRoot, "src"));
 var consoleDist = isCheckout ? join15(packageRoot, "../console/dist") : join15(packageRoot, "console");
 async function main() {
-  const { ensureForgeDir: ensureForgeDir2, createForgeServer: createForgeServer2, createDatabase: createDatabase2, resolveListenOptions: resolveListenOptions2, ensureCw: ensureCw2, pathWithCw: pathWithCw2, quietSqliteWarning: quietSqliteWarning2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+  const { ensureForgeDir: ensureForgeDir2, createForgeServer: createForgeServer2, createDatabase: createDatabase2, resolveListenOptions: resolveListenOptions2, ensureCw: ensureCw2, pathWithCw: pathWithCw2, quietSqliteWarning: quietSqliteWarning2, waitForListening: waitForListening2, probePort: probePort2, portInUseMessage: portInUseMessage2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
   quietSqliteWarning2();
   const args = parseArgs(process.argv.slice(2));
   const { forgeDir, created } = ensureForgeDir2();
@@ -4347,14 +4485,31 @@ async function main() {
     localOnly
   });
   const { serveStatic } = await import("@hono/node-server/serve-static");
-  const { readFileSync: readFileSync9 } = await import("node:fs");
-  if (existsSync13(join15(consoleDist, "index.html"))) {
+  const { readFileSync: readFileSync10 } = await import("node:fs");
+  if (existsSync14(join15(consoleDist, "index.html"))) {
     server.app.use("/*", serveStatic({ root: consoleDist }));
-    const indexHtml = readFileSync9(join15(consoleDist, "index.html"), "utf-8");
+    const indexHtml = readFileSync10(join15(consoleDist, "index.html"), "utf-8");
     server.app.get("*", (c) => c.html(indexHtml));
   }
   const { serve } = await import("@hono/node-server");
   const httpServer = serve({ fetch: server.app.fetch, port, hostname: host });
+  try {
+    await waitForListening2(httpServer);
+  } catch (err) {
+    if (err.code !== "EADDRINUSE") throw err;
+    const holder = await probePort2(port);
+    console.log(`
+  ${portInUseMessage2(port, holder)}
+`);
+    if (holder === "forge" && args.open && process.env.FORGE_NO_OPEN !== "1") {
+      try {
+        const open = (await import("open")).default;
+        await open(`http://localhost:${port}`);
+      } catch {
+      }
+    }
+    process.exit(holder === "forge" ? 0 : 1);
+  }
   server.attachTerminalWs(httpServer);
   console.log(`
   Forge Console running at http://localhost:${port}
@@ -4373,4 +4528,7 @@ ${authToken ? "  Auth: bearer token required\n" : ""}
     }
   }
 }
-main().catch(console.error);
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forge-cw",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "A visual dashboard for your coding agents on Claude Code, Codex, Pi or OpenCode. Installs CW for you.",
   "license": "MIT",
   "type": "module",
@@ -39,8 +39,8 @@
     "@types/node": "^22.0.0",
     "esbuild": "^0.25.0",
     "typescript": "^5.8.0",
-    "@forge-dev/core": "0.1.0",
-    "@forge-dev/console": "0.1.0"
+    "@forge-dev/console": "0.1.0",
+    "@forge-dev/core": "0.1.0"
   },
   "scripts": {
     "build": "tsc",