chatroom-cli 1.37.1 → 1.37.3

package/dist/index.js

@@ -11035,7 +11035,13 @@ class CopilotStreamReader {
 }
 var DONE_MARKER = "Done.", SKIP_PREFIXES;
 var init_copilot_stream_reader = __esm(() => {
-  SKIP_PREFIXES = ["Total usage est:", "API time spent:", "Total session time:", "Total code changes:", "Breakdown by AI model:"];
+  SKIP_PREFIXES = [
+    "Total usage est:",
+    "API time spent:",
+    "Total session time:",
+    "Total code changes:",
+    "Breakdown by AI model:"
+  ];
 });
 
 // src/infrastructure/services/remote-agents/copilot/copilot-agent-service.ts
@@ -14048,11 +14054,21 @@ function getErrorMessage(error) {
     }
     if (error.data !== null && typeof error.data === "object") {
       const data = error.data;
-      return data.message ?? data.code ?? String(error.data);
+      const base = data.message ?? data.code ?? String(error.data);
+      const parts = [base];
+      if (Array.isArray(data.fields) && data.fields.length > 0) {
+        parts.push(`  offending fields: ${data.fields.join(", ")}`);
+      }
+      return parts.join(`
+`);
     }
     return String(error.data);
   }
   if (error instanceof Error) {
+    if (error.message.includes("Server Error")) {
+      return `${error.message}
+  hint: ${SERVER_ERROR_HINT}`;
+    }
     return error.message;
   }
   if (error === null || error === undefined) {
@@ -14060,8 +14076,10 @@ function getErrorMessage(error) {
   }
   return String(error);
 }
+var SERVER_ERROR_HINT;
 var init_convex_error = __esm(() => {
   init_values();
+  SERVER_ERROR_HINT = "This is a generic server error — likely a backend arg-validator rejection or a CLI/backend version mismatch." + " Verify the CLI and backend are on the same commit (run `pnpm install` and check `git log -1 origin/master`).";
 });
 
 // src/commands/auth-status/index.ts
@@ -53659,18 +53677,171 @@ var init_cli = __esm(() => {
 var BACKEND_ERROR_CODES, FATAL_ERROR_CODES, NON_FATAL_ERROR_CODES;
 var init_errorCodes = __esm(() => {
   BACKEND_ERROR_CODES = {
-    PARTICIPANT_NOT_FOUND: "PARTICIPANT_NOT_FOUND",
-    CHATROOM_NOT_FOUND: "CHATROOM_NOT_FOUND",
     SESSION_INVALID: "SESSION_INVALID",
-    CONTEXT_NO_HANDOFF_SINCE_LAST_CONTEXT: "CONTEXT_NO_HANDOFF_SINCE_LAST_CONTEXT"
+    FEATURE_DISABLED: "FEATURE_DISABLED",
+    NOT_AUTHENTICATED: "NOT_AUTHENTICATED",
+    UNAUTHORIZED: "UNAUTHORIZED",
+    FORBIDDEN: "FORBIDDEN",
+    ACCESS_DENIED: "ACCESS_DENIED",
+    AUTH_FAILED: "AUTH_FAILED",
+    EMAIL_ALREADY_EXISTS: "EMAIL_ALREADY_EXISTS",
+    NO_GOOGLE_ACCOUNT: "NO_GOOGLE_ACCOUNT",
+    GOOGLE_ACCOUNT_IN_USE: "GOOGLE_ACCOUNT_IN_USE",
+    INVALID_USER_TYPE: "INVALID_USER_TYPE",
+    USER_TYPE_MISMATCH: "USER_TYPE_MISMATCH",
+    USER_NOT_FOUND: "USER_NOT_FOUND",
+    OAUTH_ERROR: "OAUTH_ERROR",
+    LOGIN_ERROR: "LOGIN_ERROR",
+    CHATROOM_NOT_FOUND: "CHATROOM_NOT_FOUND",
+    TEAM_REQUIRED: "TEAM_REQUIRED",
+    CONFIGURATION_ERROR: "CONFIGURATION_ERROR",
+    PARTICIPANT_NOT_FOUND: "PARTICIPANT_NOT_FOUND",
+    CONTEXT_NO_HANDOFF_SINCE_LAST_CONTEXT: "CONTEXT_NO_HANDOFF_SINCE_LAST_CONTEXT",
+    CONTEXT_NOT_FOUND: "CONTEXT_NOT_FOUND",
+    CONTEXT_RESTRICTED: "CONTEXT_RESTRICTED",
+    INVALID_ROLE: "INVALID_ROLE",
+    INVALID_CONTENT: "INVALID_CONTENT",
+    MISSING_CLASSIFICATION: "MISSING_CLASSIFICATION",
+    MESSAGE_NOT_CLASSIFIED: "MESSAGE_NOT_CLASSIFIED",
+    VALIDATION_ERROR: "VALIDATION_ERROR",
+    UNKNOWN_PARAM: "UNKNOWN_PARAM",
+    INVALID_CONVERSION: "INVALID_CONVERSION",
+    INVALID_STATE: "INVALID_STATE",
+    INVALID_STDIN_FORMAT: "INVALID_STDIN_FORMAT",
+    MISSING_STDIN: "MISSING_STDIN",
+    MISSING_SPECIFICATION: "MISSING_SPECIFICATION",
+    TASK_NOT_FOUND: "TASK_NOT_FOUND",
+    INVALID_TASK: "INVALID_TASK",
+    QUEUED_MESSAGE_NOT_FOUND: "QUEUED_MESSAGE_NOT_FOUND",
+    INVALID_TASK_STATUS: "INVALID_TASK_STATUS",
+    TASK_INVALID_TRANSITION: "TASK_INVALID_TRANSITION",
+    TASK_MISSING_REQUIRED_FIELD: "TASK_MISSING_REQUIRED_FIELD",
+    TASK_VALIDATION_FAILED: "TASK_VALIDATION_FAILED",
+    BACKLOG_ITEM_NOT_FOUND: "BACKLOG_ITEM_NOT_FOUND",
+    BACKLOG_ITEM_WRONG_CHATROOM: "BACKLOG_ITEM_WRONG_CHATROOM",
+    BACKLOG_INVALID_TRANSITION: "BACKLOG_INVALID_TRANSITION",
+    BACKLOG_MISSING_REQUIRED_FIELD: "BACKLOG_MISSING_REQUIRED_FIELD",
+    BACKLOG_VALIDATION_FAILED: "BACKLOG_VALIDATION_FAILED",
+    CONTENT_EMPTY: "CONTENT_EMPTY",
+    REASON_EMPTY: "REASON_EMPTY",
+    NOT_AUTHORIZED_MACHINE: "NOT_AUTHORIZED_MACHINE",
+    COMMAND_NOT_FOUND: "COMMAND_NOT_FOUND",
+    COMMAND_NOT_DISCOVERED: "COMMAND_NOT_DISCOVERED",
+    RUN_NOT_FOUND: "RUN_NOT_FOUND",
+    RUN_WRONG_MACHINE: "RUN_WRONG_MACHINE",
+    COMMAND_NOT_RUNNING: "COMMAND_NOT_RUNNING",
+    TOO_MANY_COMMANDS: "TOO_MANY_COMMANDS",
+    INVALID_STATE_TRANSITION: "INVALID_STATE_TRANSITION",
+    OUTPUT_CHUNK_TOO_LARGE: "OUTPUT_CHUNK_TOO_LARGE",
+    NOT_FOUND: "NOT_FOUND",
+    INVALID_BOT_TOKEN: "INVALID_BOT_TOKEN",
+    WEBHOOK_REGISTRATION_FAILED: "WEBHOOK_REGISTRATION_FAILED",
+    WEBHOOK_REMOVAL_FAILED: "WEBHOOK_REMOVAL_FAILED",
+    WORKFLOW_REQUIRED: "WORKFLOW_REQUIRED",
+    ALREADY_CONNECTED: "ALREADY_CONNECTED",
+    CONNECT_ERROR: "CONNECT_ERROR",
+    UNSAFE_DISCONNECT: "UNSAFE_DISCONNECT",
+    HANDOFF_RESTRICTED: "HANDOFF_RESTRICTED",
+    CHATROOM_NO_TEAM_ID: "CHATROOM_NO_TEAM_ID",
+    SKILL_NOT_FOUND_OR_DISABLED: "SKILL_NOT_FOUND_OR_DISABLED",
+    MISSING_FEATURE_METADATA: "MISSING_FEATURE_METADATA",
+    COMMAND_NAME_EMPTY: "COMMAND_NAME_EMPTY",
+    SAVED_COMMAND_NOT_FOUND: "SAVED_COMMAND_NOT_FOUND",
+    COMMAND_TYPE_IMMUTABLE: "COMMAND_TYPE_IMMUTABLE",
+    NAME_REQUIRED: "NAME_REQUIRED",
+    ATTENDANCE_NOT_FOUND: "ATTENDANCE_NOT_FOUND",
+    ATTENDANCE_DELETE_UNAUTHORIZED: "ATTENDANCE_DELETE_UNAUTHORIZED",
+    ITEM_NOT_FOUND: "ITEM_NOT_FOUND",
+    INVALID_ITEM: "INVALID_ITEM",
+    INVALID_ITEM_STATUS: "INVALID_ITEM_STATUS",
+    INVALID_MESSAGE: "INVALID_MESSAGE",
+    MESSAGE_NOT_FOUND: "MESSAGE_NOT_FOUND",
+    CONFLICT: "CONFLICT"
   };
   FATAL_ERROR_CODES = [
     BACKEND_ERROR_CODES.PARTICIPANT_NOT_FOUND,
     BACKEND_ERROR_CODES.CHATROOM_NOT_FOUND,
-    BACKEND_ERROR_CODES.SESSION_INVALID
+    BACKEND_ERROR_CODES.SESSION_INVALID,
+    BACKEND_ERROR_CODES.NOT_AUTHENTICATED,
+    BACKEND_ERROR_CODES.UNAUTHORIZED,
+    BACKEND_ERROR_CODES.FORBIDDEN,
+    BACKEND_ERROR_CODES.ACCESS_DENIED,
+    BACKEND_ERROR_CODES.AUTH_FAILED,
+    BACKEND_ERROR_CODES.NO_GOOGLE_ACCOUNT,
+    BACKEND_ERROR_CODES.GOOGLE_ACCOUNT_IN_USE,
+    BACKEND_ERROR_CODES.USER_TYPE_MISMATCH,
+    BACKEND_ERROR_CODES.INVALID_USER_TYPE,
+    BACKEND_ERROR_CODES.FEATURE_DISABLED
   ];
   NON_FATAL_ERROR_CODES = [
-    BACKEND_ERROR_CODES.CONTEXT_NO_HANDOFF_SINCE_LAST_CONTEXT
+    BACKEND_ERROR_CODES.CONTEXT_NO_HANDOFF_SINCE_LAST_CONTEXT,
+    BACKEND_ERROR_CODES.CONTEXT_NOT_FOUND,
+    BACKEND_ERROR_CODES.CONTEXT_RESTRICTED,
+    BACKEND_ERROR_CODES.HANDOFF_RESTRICTED,
+    BACKEND_ERROR_CODES.BACKLOG_ITEM_NOT_FOUND,
+    BACKEND_ERROR_CODES.TASK_NOT_FOUND,
+    BACKEND_ERROR_CODES.QUEUED_MESSAGE_NOT_FOUND,
+    BACKEND_ERROR_CODES.ITEM_NOT_FOUND,
+    BACKEND_ERROR_CODES.MESSAGE_NOT_FOUND,
+    BACKEND_ERROR_CODES.CONTEXT_NOT_FOUND,
+    BACKEND_ERROR_CODES.SAVED_COMMAND_NOT_FOUND,
+    BACKEND_ERROR_CODES.RUN_NOT_FOUND,
+    BACKEND_ERROR_CODES.COMMAND_NOT_FOUND,
+    BACKEND_ERROR_CODES.ATTENDANCE_NOT_FOUND,
+    BACKEND_ERROR_CODES.USER_NOT_FOUND,
+    BACKEND_ERROR_CODES.NOT_FOUND,
+    BACKEND_ERROR_CODES.CONTENT_EMPTY,
+    BACKEND_ERROR_CODES.REASON_EMPTY,
+    BACKEND_ERROR_CODES.NAME_REQUIRED,
+    BACKEND_ERROR_CODES.COMMAND_NAME_EMPTY,
+    BACKEND_ERROR_CODES.MISSING_CLASSIFICATION,
+    BACKEND_ERROR_CODES.MESSAGE_NOT_CLASSIFIED,
+    BACKEND_ERROR_CODES.INVALID_CONTENT,
+    BACKEND_ERROR_CODES.INVALID_ROLE,
+    BACKEND_ERROR_CODES.INVALID_TASK,
+    BACKEND_ERROR_CODES.INVALID_TASK_STATUS,
+    BACKEND_ERROR_CODES.INVALID_ITEM,
+    BACKEND_ERROR_CODES.INVALID_ITEM_STATUS,
+    BACKEND_ERROR_CODES.INVALID_MESSAGE,
+    BACKEND_ERROR_CODES.INVALID_STATE,
+    BACKEND_ERROR_CODES.INVALID_CONVERSION,
+    BACKEND_ERROR_CODES.INVALID_STDIN_FORMAT,
+    BACKEND_ERROR_CODES.INVALID_BOT_TOKEN,
+    BACKEND_ERROR_CODES.INVALID_STATE_TRANSITION,
+    BACKEND_ERROR_CODES.TASK_INVALID_TRANSITION,
+    BACKEND_ERROR_CODES.TASK_MISSING_REQUIRED_FIELD,
+    BACKEND_ERROR_CODES.TASK_VALIDATION_FAILED,
+    BACKEND_ERROR_CODES.BACKLOG_INVALID_TRANSITION,
+    BACKEND_ERROR_CODES.BACKLOG_ITEM_WRONG_CHATROOM,
+    BACKEND_ERROR_CODES.BACKLOG_MISSING_REQUIRED_FIELD,
+    BACKEND_ERROR_CODES.BACKLOG_VALIDATION_FAILED,
+    BACKEND_ERROR_CODES.SKILL_NOT_FOUND_OR_DISABLED,
+    BACKEND_ERROR_CODES.MISSING_FEATURE_METADATA,
+    BACKEND_ERROR_CODES.MISSING_SPECIFICATION,
+    BACKEND_ERROR_CODES.MISSING_STDIN,
+    BACKEND_ERROR_CODES.UNKNOWN_PARAM,
+    BACKEND_ERROR_CODES.VALIDATION_ERROR,
+    BACKEND_ERROR_CODES.OUTPUT_CHUNK_TOO_LARGE,
+    BACKEND_ERROR_CODES.TOO_MANY_COMMANDS,
+    BACKEND_ERROR_CODES.COMMAND_NOT_DISCOVERED,
+    BACKEND_ERROR_CODES.COMMAND_NOT_RUNNING,
+    BACKEND_ERROR_CODES.RUN_WRONG_MACHINE,
+    BACKEND_ERROR_CODES.COMMAND_TYPE_IMMUTABLE,
+    BACKEND_ERROR_CODES.NOT_AUTHORIZED_MACHINE,
+    BACKEND_ERROR_CODES.ATTENDANCE_DELETE_UNAUTHORIZED,
+    BACKEND_ERROR_CODES.CONFLICT,
+    BACKEND_ERROR_CODES.EMAIL_ALREADY_EXISTS,
+    BACKEND_ERROR_CODES.ALREADY_CONNECTED,
+    BACKEND_ERROR_CODES.CONNECT_ERROR,
+    BACKEND_ERROR_CODES.UNSAFE_DISCONNECT,
+    BACKEND_ERROR_CODES.CONFIGURATION_ERROR,
+    BACKEND_ERROR_CODES.CHATROOM_NO_TEAM_ID,
+    BACKEND_ERROR_CODES.TEAM_REQUIRED,
+    BACKEND_ERROR_CODES.WEBHOOK_REGISTRATION_FAILED,
+    BACKEND_ERROR_CODES.WEBHOOK_REMOVAL_FAILED,
+    BACKEND_ERROR_CODES.OAUTH_ERROR,
+    BACKEND_ERROR_CODES.LOGIN_ERROR,
+    BACKEND_ERROR_CODES.WORKFLOW_REQUIRED
   ];
 });
 
@@ -55094,6 +55265,7 @@ async function updateBacklog(chatroomId, options, deps) {
   try {
     await d.backend.mutation(api.backlog.updateBacklogItem, {
       sessionId,
+      chatroomId,
       itemId: options.backlogItemId,
       content: options.content.trim()
     });
@@ -55347,7 +55519,11 @@ function parseSections(input, requiredSections, optionalSections) {
   let match;
   while ((match = regex.exec(input)) !== null) {
     const sectionName = match[1].replace(/^---/, "").replace(/---$/, "");
-    markers.push({ section: sectionName, index: match.index + match[0].length, matchStart: match.index });
+    markers.push({
+      section: sectionName,
+      index: match.index + match[0].length,
+      matchStart: match.index
+    });
   }
   for (let i2 = 0;i2 < markers.length; i2++) {
     const start = markers[i2].index;
@@ -59059,7 +59235,7 @@ async function onCommandRun(ctx, event) {
       } else {
         child.kill("SIGKILL");
       }
-    }, FORCE_KILL_DELAY_MS);
+    }, SIGTERM_GRACE_PERIOD_MS);
   }, DEFAULT_COMMAND_TIMEOUT_MS);
   timeoutTimer.unref?.();
   const tracked = {
@@ -59129,13 +59305,42 @@ async function onCommandRun(ctx, event) {
     }
   });
 }
+function killProcess(child, signal) {
+  const pid = child.pid;
+  if (pid) {
+    try {
+      process.kill(-pid, signal);
+      return;
+    } catch {}
+  }
+  try {
+    child.kill(signal);
+  } catch {}
+}
+function waitForExit(runIdStr, ms) {
+  return new Promise((resolve5) => {
+    const interval = 100;
+    let elapsed = 0;
+    const timer = setInterval(() => {
+      if (!runningProcesses.has(runIdStr)) {
+        clearInterval(timer);
+        resolve5(true);
+        return;
+      }
+      elapsed += interval;
+      if (elapsed >= ms) {
+        clearInterval(timer);
+        resolve5(false);
+      }
+    }, interval);
+  });
+}
 async function onCommandStop(ctx, event) {
   const runIdStr = event.runId.toString();
   const tracked = runningProcesses.get(runIdStr);
   if (!tracked) {
-    console.log(`[${formatTimestamp()}] ⚠️ No running process found for run: ${runIdStr}`);
+    console.log(`[${formatTimestamp()}] ⚠️ No running process found for run: ${runIdStr} — marking as stopped`);
     pendingStops.set(runIdStr, Date.now());
-    console.log(`[${formatTimestamp()}] \uD83D\uDCDD Registered pending stop for run: ${runIdStr}`);
     try {
       await ctx.deps.backend.mutation(api.commands.updateRunStatus, {
         sessionId: ctx.sessionId,
@@ -59143,9 +59348,8 @@ async function onCommandStop(ctx, event) {
         runId: event.runId,
         status: "stopped"
       });
-      console.log(`[${formatTimestamp()}] \uD83D\uDCDD Marked orphaned run as stopped: ${runIdStr}`);
     } catch (err) {
-      console.warn(`[${formatTimestamp()}] ⚠️ Failed to mark orphaned run as stopped (will retry): ${getErrorMessage(err)}`);
+      console.warn(`[${formatTimestamp()}] ⚠️ Failed to mark run as stopped (will retry): ${getErrorMessage(err)}`);
       throw err;
     }
     return;
@@ -59155,30 +59359,26 @@ async function onCommandStop(ctx, event) {
     clearTimeout(tracked.timeoutTimer);
     tracked.timeoutTimer = null;
   }
-  const pid = tracked.process.pid;
-  if (pid) {
-    try {
-      process.kill(-pid, "SIGTERM");
-    } catch {
-      tracked.process.kill("SIGTERM");
-    }
-  } else {
-    tracked.process.kill("SIGTERM");
-  }
-  setTimeout(() => {
-    if (!runningProcesses.has(runIdStr))
-      return;
+  killProcess(tracked.process, "SIGTERM");
+  const exitedAfterSigterm = await waitForExit(runIdStr, SIGTERM_GRACE_PERIOD_MS);
+  if (!exitedAfterSigterm) {
     console.log(`[${formatTimestamp()}] \uD83D\uDD2A Force-killing process: ${runIdStr}`);
-    if (pid) {
-      try {
-        process.kill(-pid, "SIGKILL");
-      } catch {
-        tracked.process.kill("SIGKILL");
-      }
-    } else {
-      tracked.process.kill("SIGKILL");
+    killProcess(tracked.process, "SIGKILL");
+    const exitedAfterSigkill = await waitForExit(runIdStr, 1000);
+    if (!exitedAfterSigkill) {
+      console.error(`[${formatTimestamp()}] ❌ Failed to stop process for run: ${runIdStr} — process did not exit after SIGKILL`);
     }
-  }, FORCE_KILL_DELAY_MS);
+  }
+  try {
+    await ctx.deps.backend.mutation(api.commands.updateRunStatus, {
+      sessionId: ctx.sessionId,
+      machineId: ctx.machineId,
+      runId: event.runId,
+      status: "stopped"
+    });
+  } catch (err) {
+    console.warn(`[${formatTimestamp()}] ⚠️ Failed to mark run as stopped in backend: ${getErrorMessage(err)}`);
+  }
 }
 async function shutdownAllCommands(ctx) {
   if (runningProcesses.size === 0)
@@ -59219,7 +59419,7 @@ async function shutdownAllCommands(ctx) {
   runningProcesses.clear();
   console.log(`[${formatTimestamp()}] All commands stopped`);
 }
-var runningProcesses, pendingStops, PENDING_STOP_TTL_MS = 60000, OUTPUT_FLUSH_INTERVAL_MS = 3000, MAX_BUFFER_SIZE, DEFAULT_COMMAND_TIMEOUT_MS, FORCE_KILL_DELAY_MS = 5000;
+var runningProcesses, pendingStops, PENDING_STOP_TTL_MS = 60000, OUTPUT_FLUSH_INTERVAL_MS = 3000, MAX_BUFFER_SIZE, DEFAULT_COMMAND_TIMEOUT_MS, SIGTERM_GRACE_PERIOD_MS = 5000;
 var init_command_runner = __esm(() => {
   init_api3();
   init_convex_error();
@@ -59278,329 +59478,6 @@ function harnessCapabilitiesFingerprint(harnesses, versions) {
   return `${h}::${v3}`;
 }
 
-// src/infrastructure/local-api/routes/identity.ts
-async function handleIdentity(_req, ctx) {
-  const identity = {
-    machineId: ctx.machineId,
-    hostname: ctx.config?.hostname ?? "unknown",
-    os: ctx.config?.os ?? "unknown",
-    version: getVersion()
-  };
-  return {
-    status: 200,
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify(identity)
-  };
-}
-var identityRoute;
-var init_identity = __esm(() => {
-  init_version();
-  identityRoute = {
-    method: "GET",
-    path: "/api/identity",
-    handler: handleIdentity
-  };
-});
-
-// src/infrastructure/local-api/routes/shared-utils.ts
-import { exec as exec5 } from "node:child_process";
-import { access as access4 } from "node:fs/promises";
-function jsonResponse(status, body) {
-  return {
-    status,
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify(body)
-  };
-}
-async function parseWorkingDir(req) {
-  let body = {};
-  try {
-    if (req.body) {
-      body = JSON.parse(req.body);
-    }
-  } catch {
-    return { ok: false, response: jsonResponse(400, { success: false, error: "Invalid JSON body" }) };
-  }
-  const { workingDir } = body;
-  if (!workingDir || typeof workingDir !== "string" || workingDir.trim() === "") {
-    return { ok: false, response: jsonResponse(400, { success: false, error: "workingDir is required" }) };
-  }
-  try {
-    await access4(workingDir);
-  } catch {
-    return {
-      ok: false,
-      response: jsonResponse(400, { success: false, error: `Directory not found: ${workingDir}` })
-    };
-  }
-  return { ok: true, workingDir };
-}
-function escapeShellArg(arg) {
-  return `"${arg.replace(/"/g, "\\\"")}"`;
-}
-function resolveWhichCommand(name) {
-  return process.platform === "win32" ? `where ${name}` : `which ${name}`;
-}
-function isCliAvailable(cliName) {
-  return new Promise((resolve5) => {
-    exec5(resolveWhichCommand(cliName), (err) => {
-      resolve5(!err);
-    });
-  });
-}
-function execFireAndForget(command, logTag) {
-  exec5(command, (err) => {
-    if (err) {
-      console.warn(`[${logTag}] exec failed: ${err.message}`);
-    }
-  });
-}
-var init_shared_utils = () => {};
-
-// src/infrastructure/local-api/routes/open-finder.ts
-function resolveOpenCommand(platform) {
-  switch (platform) {
-    case "darwin":
-      return "open";
-    case "win32":
-      return "explorer";
-    default:
-      return "xdg-open";
-  }
-}
-async function handleOpenFinder(req) {
-  const parsed = await parseWorkingDir(req);
-  if (!parsed.ok)
-    return parsed.response;
-  const cmd = resolveOpenCommand(process.platform);
-  execFireAndForget(`${cmd} ${escapeShellArg(parsed.workingDir)}`, "open-finder");
-  return jsonResponse(200, { success: true });
-}
-var openFinderRoute;
-var init_open_finder = __esm(() => {
-  init_shared_utils();
-  openFinderRoute = {
-    method: "POST",
-    path: "/api/open-finder",
-    handler: (req) => handleOpenFinder(req)
-  };
-});
-
-// src/infrastructure/local-api/routes/open-github-desktop.ts
-async function handleOpenGitHubDesktop(req) {
-  const parsed = await parseWorkingDir(req);
-  if (!parsed.ok)
-    return parsed.response;
-  const available = await isCliAvailable("github");
-  if (!available) {
-    return jsonResponse(200, { success: false, error: "GitHub Desktop CLI not found" });
-  }
-  execFireAndForget(`github ${escapeShellArg(parsed.workingDir)}`, "open-github-desktop");
-  return jsonResponse(200, { success: true });
-}
-var openGitHubDesktopRoute;
-var init_open_github_desktop = __esm(() => {
-  init_shared_utils();
-  openGitHubDesktopRoute = {
-    method: "POST",
-    path: "/api/open-github-desktop",
-    handler: (req) => handleOpenGitHubDesktop(req)
-  };
-});
-
-// src/infrastructure/local-api/routes/open-vscode.ts
-async function handleOpenVSCode(req) {
-  const parsed = await parseWorkingDir(req);
-  if (!parsed.ok)
-    return parsed.response;
-  const available = await isCliAvailable("code");
-  if (!available) {
-    return jsonResponse(200, { success: false, error: CODE_CLI_NOT_FOUND });
-  }
-  execFireAndForget(`code ${escapeShellArg(parsed.workingDir)}`, "open-vscode");
-  return jsonResponse(200, { success: true });
-}
-var CODE_CLI_NOT_FOUND = "VS Code CLI (code) not found. Install via: VS Code → Cmd+Shift+P → 'Shell Command: Install code in PATH'", openVSCodeRoute;
-var init_open_vscode = __esm(() => {
-  init_shared_utils();
-  openVSCodeRoute = {
-    method: "POST",
-    path: "/api/open-vscode",
-    handler: (req) => handleOpenVSCode(req)
-  };
-});
-
-// src/infrastructure/local-api/cors.ts
-function applyCorsHeaders(response) {
-  return {
-    ...response,
-    headers: {
-      ...CORS_HEADERS,
-      ...response.headers ?? {}
-    }
-  };
-}
-function buildPreflightResponse() {
-  return {
-    status: 204,
-    headers: CORS_HEADERS,
-    body: ""
-  };
-}
-var CORS_HEADERS;
-var init_cors = __esm(() => {
-  CORS_HEADERS = {
-    "Access-Control-Allow-Origin": "*",
-    "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
-    "Access-Control-Allow-Headers": "Content-Type",
-    "Access-Control-Allow-Private-Network": "true"
-  };
-});
-
-// src/infrastructure/local-api/router.ts
-class LocalApiRouter {
-  routes = [];
-  registerRoute(route) {
-    this.routes.push(route);
-  }
-  async handleRequest(req, ctx) {
-    if (req.method === "OPTIONS") {
-      return buildPreflightResponse();
-    }
-    const pathname = req.url.split("?")[0] ?? req.url;
-    const route = this.routes.find((r) => r.method === req.method && r.path === pathname);
-    let response;
-    if (route) {
-      try {
-        response = await route.handler(req, ctx);
-      } catch (error) {
-        response = {
-          status: 500,
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ error: "Internal server error" })
-        };
-      }
-    } else {
-      response = {
-        status: 404,
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ error: "Not found" })
-      };
-    }
-    return applyCorsHeaders(response);
-  }
-}
-var init_router = __esm(() => {
-  init_cors();
-});
-
-// src/infrastructure/local-api/server.ts
-import { createServer } from "node:http";
-function readBody(req) {
-  return new Promise((resolve5, reject) => {
-    const chunks = [];
-    req.on("data", (chunk) => chunks.push(chunk));
-    req.on("end", () => resolve5(Buffer.concat(chunks).toString("utf-8")));
-    req.on("error", reject);
-  });
-}
-async function normalizeRequest(req) {
-  const body = await readBody(req);
-  const headers = {};
-  for (const [key, value] of Object.entries(req.headers)) {
-    if (typeof value === "string") {
-      headers[key] = value;
-    } else if (Array.isArray(value)) {
-      headers[key] = value.join(", ");
-    }
-  }
-  return {
-    method: (req.method ?? "GET").toUpperCase(),
-    url: req.url ?? "/",
-    headers,
-    body: body || undefined
-  };
-}
-function writeResponse(res, status, headers, body) {
-  res.writeHead(status, headers);
-  res.end(body);
-}
-function createRouter() {
-  const router = new LocalApiRouter;
-  router.registerRoute(identityRoute);
-  router.registerRoute(openFinderRoute);
-  router.registerRoute(openGitHubDesktopRoute);
-  router.registerRoute(openVSCodeRoute);
-  return router;
-}
-function resolvePort() {
-  const envPort = process.env.CHATROOM_LOCAL_API_PORT;
-  if (envPort) {
-    const parsed = parseInt(envPort, 10);
-    if (!isNaN(parsed) && parsed > 0 && parsed < 65536) {
-      return parsed;
-    }
-  }
-  return LOCAL_API_PORT;
-}
-function ts() {
-  return new Date().toISOString().replace("T", " ").slice(0, 19);
-}
-async function startLocalApi(ctx, port = resolvePort()) {
-  const router = createRouter();
-  const server2 = createServer(async (req, res) => {
-    try {
-      const localReq = await normalizeRequest(req);
-      const localRes = await router.handleRequest(localReq, ctx);
-      writeResponse(res, localRes.status, { "Content-Type": "application/json", ...localRes.headers ?? {} }, localRes.body);
-    } catch {
-      writeResponse(res, 500, { "Content-Type": "application/json" }, JSON.stringify({ error: "Internal server error" }));
-    }
-  });
-  await new Promise((resolve5) => {
-    server2.listen(port, "127.0.0.1", () => {
-      console.log(`[${ts()}] \uD83C\uDF10 Local API started on http://localhost:${port}`);
-      resolve5();
-    });
-    server2.on("error", (err) => {
-      if (err.code === "EADDRINUSE") {
-        console.warn(`[${ts()}] ⚠️  Local API port ${port} already in use — skipping local API`);
-      } else {
-        console.warn(`[${ts()}] ⚠️  Local API failed to start: ${err.message}`);
-      }
-      resolve5();
-    });
-  });
-  const stop2 = () => new Promise((resolve5, reject) => {
-    if (!server2.listening) {
-      resolve5();
-      return;
-    }
-    server2.close((err) => {
-      if (err) {
-        reject(err);
-      } else {
-        console.log(`[${ts()}] \uD83C\uDF10 Local API stopped`);
-        resolve5();
-      }
-    });
-  });
-  return { stop: stop2 };
-}
-var LOCAL_API_PORT = 19847;
-var init_server3 = __esm(() => {
-  init_identity();
-  init_open_finder();
-  init_open_github_desktop();
-  init_open_vscode();
-  init_router();
-});
-
-// src/infrastructure/local-api/index.ts
-var init_local_api = __esm(() => {
-  init_server3();
-});
-
 // src/events/daemon/event-bus.ts
 class DaemonEventBus {
   listeners = new Map;
@@ -59643,15 +59520,15 @@ function onAgentExited(ctx, payload) {
 
 // src/events/daemon/agent/on-agent-started.ts
 function onAgentStarted(ctx, payload) {
-  const ts2 = formatTimestamp();
-  console.log(`[${ts2}] \uD83D\uDFE2 Agent started: ${payload.role} (PID: ${payload.pid}, harness: ${payload.harness})`);
+  const ts = formatTimestamp();
+  console.log(`[${ts}] \uD83D\uDFE2 Agent started: ${payload.role} (PID: ${payload.pid}, harness: ${payload.harness})`);
 }
 var init_on_agent_started = () => {};
 
 // src/events/daemon/agent/on-agent-stopped.ts
 function onAgentStopped(ctx, payload) {
-  const ts2 = formatTimestamp();
-  console.log(`[${ts2}] \uD83D\uDD34 Agent stopped: ${payload.role} (PID: ${payload.pid})`);
+  const ts = formatTimestamp();
+  console.log(`[${ts}] \uD83D\uDD34 Agent stopped: ${payload.role} (PID: ${payload.pid})`);
 }
 var init_on_agent_stopped = () => {};
 
@@ -59780,7 +59657,7 @@ class CrashLoopTracker {
     const key = `${chatroomId}:${role.toLowerCase()}`;
     const windowStart = now - CRASH_LOOP_WINDOW_MS;
     const raw = this.history.get(key) ?? [];
-    const recent = raw.filter((ts2) => ts2 >= windowStart);
+    const recent = raw.filter((ts) => ts >= windowStart);
     const restartCount = recent.length;
     if (restartCount >= CRASH_LOOP_MAX_RESTARTS) {
       return {
@@ -59823,7 +59700,7 @@ class CrashLoopTracker {
     const key = `${chatroomId}:${role.toLowerCase()}`;
     const windowStart = now - CRASH_LOOP_WINDOW_MS;
     const raw = this.history.get(key) ?? [];
-    return raw.filter((ts2) => ts2 >= windowStart).length;
+    return raw.filter((ts) => ts >= windowStart).length;
   }
 }
 var CRASH_LOOP_MAX_RESTARTS = 10, CRASH_LOOP_WINDOW_MS, BACKOFF_INTERVALS;
@@ -60542,8 +60419,6 @@ async function initDaemon() {
       registerEventListeners(ctx);
       logStartup(ctx, availableModels);
       await recoverState(ctx);
-      const localApiHandle = await startLocalApi(ctx);
-      ctx.stopLocalApi = localApiHandle.stop;
       return ctx;
     } catch (error) {
       if (isNetworkError(error)) {
@@ -60566,7 +60441,6 @@ var AUTH_POLL_INTERVAL_MS2 = 2000, AUTH_WAIT_TIMEOUT_MS, CONNECTION_RETRY_INTERV
 var init_init2 = __esm(() => {
   init_state_recovery();
   init_api3();
-  init_local_api();
   init_register_listeners();
   init_storage();
   init_client2();
@@ -60618,7 +60492,7 @@ var init_on_daemon_shutdown = __esm(() => {
 });
 
 // src/infrastructure/git/git-writer.ts
-import { exec as exec6 } from "node:child_process";
+import { exec as exec5 } from "node:child_process";
 import { promisify as promisify5 } from "node:util";
 async function runGit2(args, cwd) {
   try {
@@ -60682,7 +60556,7 @@ async function gitPull(workingDir) {
 }
 var execAsync4;
 var init_git_writer = __esm(() => {
-  execAsync4 = promisify5(exec6);
+  execAsync4 = promisify5(exec5);
 });
 
 // src/infrastructure/git/index.ts
@@ -60692,8 +60566,29 @@ var init_git = __esm(() => {
 });
 
 // src/infrastructure/local-actions/execute-local-action.ts
-import { access as access5 } from "node:fs/promises";
-function resolveOpenCommand2(platform) {
+import { exec as exec6 } from "node:child_process";
+import { access as access4 } from "node:fs/promises";
+function escapeShellArg(arg) {
+  return `"${arg.replace(/"/g, "\\\"")}"`;
+}
+function resolveWhichCommand(name) {
+  return process.platform === "win32" ? `where ${name}` : `which ${name}`;
+}
+function isCliAvailable(cliName) {
+  return new Promise((resolve5) => {
+    exec6(resolveWhichCommand(cliName), (err) => {
+      resolve5(!err);
+    });
+  });
+}
+function execFireAndForget(command, logTag) {
+  exec6(command, (err) => {
+    if (err) {
+      console.warn(`[${logTag}] exec failed: ${err.message}`);
+    }
+  });
+}
+function resolveOpenCommand(platform) {
   switch (platform) {
     case "darwin":
       return "open";
@@ -60705,7 +60600,7 @@ function resolveOpenCommand2(platform) {
 }
 async function executeLocalAction(action, workingDir) {
   try {
-    await access5(workingDir);
+    await access4(workingDir);
   } catch {
     return { success: false, error: `Directory not found: ${workingDir}` };
   }
@@ -60722,7 +60617,7 @@ async function executeLocalAction(action, workingDir) {
       return { success: true };
     }
     case "open-finder": {
-      const cmd = resolveOpenCommand2(process.platform);
+      const cmd = resolveOpenCommand(process.platform);
       execFireAndForget(`${cmd} ${escapeShellArg(workingDir)}`, "open-finder");
       return { success: true };
     }
@@ -60771,7 +60666,6 @@ async function executeLocalAction(action, workingDir) {
   }
 }
 var init_execute_local_action = __esm(() => {
-  init_shared_utils();
   init_git();
 });
 
@@ -60846,32 +60740,32 @@ async function refreshModels(ctx) {
 }
 function evictStaleDedupEntries(tracker) {
   const evictBefore = Date.now() - AGENT_REQUEST_DEADLINE_MS;
-  for (const [id, ts2] of tracker.commandIds) {
-    if (ts2 < evictBefore)
+  for (const [id, ts] of tracker.commandIds) {
+    if (ts < evictBefore)
       tracker.commandIds.delete(id);
   }
-  for (const [id, ts2] of tracker.pingIds) {
-    if (ts2 < evictBefore)
+  for (const [id, ts] of tracker.pingIds) {
+    if (ts < evictBefore)
       tracker.pingIds.delete(id);
   }
-  for (const [id, ts2] of tracker.gitRefreshIds) {
-    if (ts2 < evictBefore)
+  for (const [id, ts] of tracker.gitRefreshIds) {
+    if (ts < evictBefore)
       tracker.gitRefreshIds.delete(id);
   }
-  for (const [id, ts2] of tracker.capabilitiesRefreshIds) {
-    if (ts2 < evictBefore)
+  for (const [id, ts] of tracker.capabilitiesRefreshIds) {
+    if (ts < evictBefore)
       tracker.capabilitiesRefreshIds.delete(id);
   }
-  for (const [id, ts2] of tracker.localActionIds) {
-    if (ts2 < evictBefore)
+  for (const [id, ts] of tracker.localActionIds) {
+    if (ts < evictBefore)
       tracker.localActionIds.delete(id);
   }
-  for (const [id, ts2] of tracker.commandRunIds) {
-    if (ts2 < evictBefore)
+  for (const [id, ts] of tracker.commandRunIds) {
+    if (ts < evictBefore)
       tracker.commandRunIds.delete(id);
   }
-  for (const [id, ts2] of tracker.commandStopIds) {
-    if (ts2 < evictBefore)
+  for (const [id, ts] of tracker.commandStopIds) {
+    if (ts < evictBefore)
       tracker.commandStopIds.delete(id);
   }
   evictStalePendingStops();
@@ -61007,9 +60901,6 @@ async function startCommandLoop(ctx) {
     if (observedSyncSubscriptionHandle)
       observedSyncSubscriptionHandle.stop();
     await onDaemonShutdown(ctx);
-    if (ctx.stopLocalApi) {
-      await ctx.stopLocalApi().catch(() => {});
-    }
     releaseLock();
     process.exit(0);
   };
@@ -61865,7 +61756,11 @@ backlogCommand.command("update").description("Update the content of an existing
     process.exit(1);
   }
   const { updateBacklog: updateBacklog2 } = await Promise.resolve().then(() => (init_backlog(), exports_backlog));
-  await updateBacklog2(options.chatroomId, { role: options.role, backlogItemId: options.backlogItemId, content });
+  await updateBacklog2(options.chatroomId, {
+    role: options.role,
+    backlogItemId: options.backlogItemId,
+    content
+  });
 });
 backlogCommand.command("complete").description("Mark a backlog item as complete. Use --force for stuck in_progress/pending tasks.").requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--role <role>", "Your role").requiredOption("--backlog-item-id <id>", "Backlog item ID to complete").option("-f, --force", "Force complete a stuck in_progress or pending task").action(async (options) => {
   await maybeRequireAuth();
@@ -62168,5 +62063,5 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=1C43E3169710F16B64756E2164756E21
+//# debugId=B38A342DEDB6508164756E2164756E21
 //# sourceMappingURL=index.js.map