overlord-cli 0.2608211014.0 → 0.2608211436.0

package/dist/index.js

@@ -3311,6 +3311,48 @@ var init_terminal_launch_chord = __esm({
   }
 });
 
+// src/launch-settings.ts
+function launchSettingsPath(workspaceId, suffix = "") {
+  const id = workspaceId?.trim();
+  return id ? `/api/workspaces/${encodeURIComponent(id)}/launch-settings${suffix}` : `/api/launch-settings${suffix}`;
+}
+async function resolveLaunchSettingsWorkspaceId({
+  backend,
+  workspaceId
+}) {
+  const explicit = workspaceId?.trim();
+  if (explicit) return explicit;
+  const cached = cachedWorkspaceIds.get(backend);
+  if (cached !== void 0) return cached;
+  let resolved = null;
+  try {
+    const workspaces = await backend.get("/api/workspaces");
+    const rows = Array.isArray(workspaces) ? workspaces : [];
+    const ids = rows.map((row) => typeof row.id === "string" && row.id.trim() ? row.id.trim() : null).filter((id) => id !== null);
+    const active = rows.find((row) => row.isActive === true);
+    const activeId = active && typeof active.id === "string" && active.id.trim() ? active.id.trim() : null;
+    resolved = activeId ?? (ids.length === 1 ? ids[0] ?? null : null);
+  } catch {
+    resolved = null;
+  }
+  cachedWorkspaceIds.set(backend, resolved);
+  return resolved;
+}
+async function fetchLaunchSettings({
+  backend,
+  workspaceId
+}) {
+  const resolved = await resolveLaunchSettingsWorkspaceId({ backend, workspaceId });
+  return backend.get(launchSettingsPath(resolved));
+}
+var cachedWorkspaceIds;
+var init_launch_settings = __esm({
+  "src/launch-settings.ts"() {
+    "use strict";
+    cachedWorkspaceIds = /* @__PURE__ */ new WeakMap();
+  }
+});
+
 // src/terminal-profile-types.js
 var DEFAULT_TERMINAL_PROFILE, EMPTY_TERMINAL_PROFILE;
 var init_terminal_profile_types = __esm({
@@ -3350,9 +3392,10 @@ function readLegacyTerminalProfileFromToml() {
   };
 }
 async function fetchTerminalProfile({
-  backend
+  backend,
+  workspaceId
 }) {
-  const response = await backend.get("/api/launch-settings");
+  const response = await fetchLaunchSettings({ backend, workspaceId });
   const profile = terminalProfileFromResponse(response);
   return {
     ...profile,
@@ -3362,10 +3405,12 @@ async function fetchTerminalProfile({
 }
 async function saveTerminalProfile({
   backend,
-  profile
+  profile,
+  workspaceId
 }) {
+  const resolved = await resolveLaunchSettingsWorkspaceId({ backend, workspaceId });
   const response = await backend.patch({
-    path: "/api/launch-settings/terminal-profile",
+    path: launchSettingsPath(resolved, "/terminal-profile"),
     body: profile
   });
   const saved = terminalProfileFromResponse(response);
@@ -3388,6 +3433,7 @@ var init_terminal_profile = __esm({
     "use strict";
     init_dist();
     init_config();
+    init_launch_settings();
     init_terminal_launch_chord();
     init_terminal_profile_types();
   }
@@ -17263,6 +17309,8 @@ function readBinaryMtimeMs(resolvedPath) {
   }
 }
 function isLatchDiscoveryCacheFresh({ entry, resolvePath = resolveLatchExecutablePath }) {
+  if (entry.supportedProtocolVersion !== SUPPORTED_LATCH_PROTOCOL_VERSION)
+    return false;
   const { result } = entry;
   if (result.state === "not_installed") {
     return resolvePath(result.executable) === null;
@@ -17277,15 +17325,15 @@ function isLatchDiscoveryCacheFresh({ entry, resolvePath = resolveLatchExecutabl
 }
 function readLatchDiscoveryCacheFile(filePath) {
   if (!existsSync16(filePath))
-    return { version: 1, entries: {} };
+    return { version: 2, entries: {} };
   try {
     const parsed = JSON.parse(readFileSync15(filePath, "utf8"));
-    if (parsed.version !== 1 || !parsed.entries || typeof parsed.entries !== "object") {
-      return { version: 1, entries: {} };
+    if (parsed.version !== 2 || !parsed.entries || typeof parsed.entries !== "object") {
+      return { version: 2, entries: {} };
     }
-    return { version: 1, entries: parsed.entries };
+    return { version: 2, entries: parsed.entries };
   } catch {
-    return { version: 1, entries: {} };
+    return { version: 2, entries: {} };
   }
 }
 function writeLatchDiscoveryCacheFile({ filePath, cache: cache2 }) {
@@ -17305,6 +17353,7 @@ function discoverLatchForExecutionTarget({ executionTargetId, executable = DEFAU
   const binaryMtimeMs = result.state === "not_installed" ? null : readBinaryMtimeMs(result.resolvedPath);
   cache2.entries[key] = {
     result,
+    supportedProtocolVersion: SUPPORTED_LATCH_PROTOCOL_VERSION,
     binaryMtimeMs,
     cachedAt: result.checkedAt
   };
@@ -19137,12 +19186,14 @@ var init_branch_preparation = __esm({
 // src/discover-project-local.ts
 import path22 from "node:path";
 async function resolvePreferredExecutionTargetId({
-  backend
+  backend,
+  workspaceId
 }) {
   try {
-    const launchSettings = await backend.get(
-      "/api/launch-settings"
-    );
+    const launchSettings = await fetchLaunchSettings({
+      backend,
+      workspaceId
+    });
     return typeof launchSettings.executionTargetId === "string" ? launchSettings.executionTargetId : null;
   } catch {
     return null;
@@ -19330,6 +19381,7 @@ var init_discover_project_local = __esm({
     "use strict";
     init_project_metadata();
     init_errors();
+    init_launch_settings();
   }
 });
 
@@ -22843,12 +22895,15 @@ var init_session_key = __esm({
 var commands_exports = {};
 __export(commands_exports, {
   firstObjectiveId: () => firstObjectiveId,
+  launchFailureMessage: () => launchFailureMessage,
   queueableObjectiveId: () => queueableObjectiveId,
   resolveActiveObjectiveId: () => resolveActiveObjectiveId,
   resolveProtocolFileInputs: () => resolveProtocolFileInputs,
   runManagementCommand: () => runManagementCommand,
   runProtocolCommand: () => runProtocolCommand,
-  runRunnerOnce: () => runRunnerOnce
+  runRunnerOnce: () => runRunnerOnce,
+  sanitizeRunnerFailureMessage: () => sanitizeRunnerFailureMessage,
+  shouldRefuseInlineRunnerLaunch: () => shouldRefuseInlineRunnerLaunch
 });
 import { existsSync as existsSync29, readFileSync as readFileSync24 } from "node:fs";
 import os6 from "node:os";
@@ -23149,30 +23204,27 @@ function repeatedLaunchFlags(args, name) {
 }
 async function resolveTerminalLaunchSettings({
   runtime,
-  flags
+  flags,
+  workspaceId
 }) {
   if (flagBoolean(flags, "--no-terminal")) {
     return { terminalLauncher: null };
   }
   const override = flagValue(flags, "--terminal");
-  if (override) {
-    try {
-      const profile = await fetchTerminalProfile({ backend: runtime.backend });
-      return {
-        terminalLauncher: override,
-        terminalLaunchPlacement: profile.placement,
-        terminalLaunchChord: profile.chord,
-        terminalLaunchBackground: profile.background ?? false
-      };
-    } catch {
-      return { terminalLauncher: override };
-    }
-  }
   try {
-    const profile = await fetchTerminalProfile({ backend: runtime.backend });
-    return terminalProfileToLaunchSettings(profile);
-  } catch {
-    return { terminalLauncher: null };
+    const profile = await fetchTerminalProfile({ backend: runtime.backend, workspaceId });
+    if (!override) return terminalProfileToLaunchSettings(profile);
+    return {
+      terminalLauncher: override,
+      terminalLaunchPlacement: profile.placement,
+      terminalLaunchChord: profile.chord,
+      terminalLaunchBackground: profile.background ?? false
+    };
+  } catch (error) {
+    console.error(
+      `[overlord] Could not read your terminal profile (${error instanceof Error ? error.message : String(error)}). ${override ? `Launching with --terminal ${override} and default placement.` : "The agent will run inline in this process instead of a new terminal window/tab."}`
+    );
+    return override ? { terminalLauncher: override } : { terminalLauncher: null };
   }
 }
 function asRecord5(value) {
@@ -23189,11 +23241,17 @@ function parseLaunchEnvVarsValue(value) {
   }
   return vars;
 }
-async function readWorktreeBranchAutomationEnabled(runtime) {
+async function readWorktreeBranchAutomationEnabled(runtime, workspaceId) {
   try {
-    const settings = await runtime.backend.get("/api/launch-settings");
+    const settings = await fetchLaunchSettings({
+      backend: runtime.backend,
+      workspaceId
+    });
     return settings.worktreeBranchAutomationEnabled === true;
-  } catch {
+  } catch (error) {
+    console.error(
+      `[overlord] Could not read launch settings (${error instanceof Error ? error.message : String(error)}); continuing with worktree branch automation disabled.`
+    );
     return false;
   }
 }
@@ -23869,13 +23927,16 @@ async function runManagementCommand({
         `/api/missions/${encodeURIComponent(missionId)}`
       );
       const scopedRuntime = runtime;
+      const missionWorkspaceId = typeof asRecord5(mission).workspaceId === "string" ? asRecord5(mission).workspaceId : null;
       const terminal = await resolveTerminalLaunchSettings({
         runtime: scopedRuntime,
-        flags: parsed.flags
+        flags: parsed.flags,
+        workspaceId: missionWorkspaceId
       });
       const objectiveId = objectiveRef ? objectiveIdForRef(mission, objectiveRef) : resolveActiveObjectiveId(mission);
       const executionTargetId = await resolvePreferredExecutionTargetId({
-        backend: scopedRuntime.backend
+        backend: scopedRuntime.backend,
+        workspaceId: missionWorkspaceId
       });
       const missionProjectId = asRecord5(mission).projectId;
       const projectLaunchSettings = typeof missionProjectId === "string" ? await scopedRuntime.backend.get(`/api/projects/${encodeURIComponent(missionProjectId)}`).then((project) => ({
@@ -23893,7 +23954,10 @@ async function runManagementCommand({
           missionId,
           workingDirectory,
           objectiveId: objectiveId ?? void 0,
-          workspaceAutomationEnabled: await readWorktreeBranchAutomationEnabled(scopedRuntime),
+          workspaceAutomationEnabled: await readWorktreeBranchAutomationEnabled(
+            scopedRuntime,
+            missionWorkspaceId
+          ),
           dryRun,
           overrideBranch: flagValue(parsed.flags, "--branch"),
           noWorktree: flagBoolean(parsed.flags, "--no-worktree")
@@ -23926,7 +23990,13 @@ async function runManagementCommand({
         printJson({ plan: result.plan, status: result.status, signal: result.signal });
       }
       if (result.status && result.status !== 0) {
-        throw new CliError({ message: `Launch command exited with status ${result.status}` });
+        throw new CliError({
+          message: launchFailureMessage({
+            status: result.status,
+            execution: result.plan.execution,
+            terminal
+          })
+        });
       }
       return;
     }
@@ -24173,10 +24243,32 @@ async function runManagementCommand({
       throw new CliError({ message: `Unknown command: ${command}` });
   }
 }
+function sanitizeRunnerFailureMessage(value) {
+  const redacted = redactSecrets(value);
+  return redacted.length <= MAX_RUNNER_FAILURE_MESSAGE_LENGTH ? redacted : `${redacted.slice(0, MAX_RUNNER_FAILURE_MESSAGE_LENGTH)}\u2026 [truncated]`;
+}
+function launchFailureMessage({
+  status,
+  execution,
+  terminal
+}) {
+  const where = execution.terminal ? `in ${execution.terminal}${terminal.terminalLaunchPlacement ? ` (${terminal.terminalLaunchPlacement})` : ""}` : "inline (no terminal launcher resolved for this device)";
+  return sanitizeRunnerFailureMessage(
+    `Launch command exited with status ${status ?? "unknown"} running ${where}: ${execution.display}`
+  );
+}
 function isNoExecutionTargetRegisteredError(error) {
   const message = error instanceof Error ? error.message : String(error);
   return message.includes("(no_execution_target_registered)");
 }
+function shouldRefuseInlineRunnerLaunch({
+  dryRun,
+  terminalLauncher,
+  executionProvider,
+  stdoutIsTTY
+}) {
+  return !dryRun && !terminalLauncher && executionProvider !== "latch" && !stdoutIsTTY;
+}
 async function runRunnerOnce({
   runtime,
   parsed,
@@ -24248,7 +24340,12 @@ The runner will not register a target for you \u2014 declare this machine first,
       });
     }
     const launchConfig = asRecord5(requestRecord.launchConfig);
-    const terminal = await resolveTerminalLaunchSettings({ runtime, flags: parsed.flags });
+    const requestWorkspaceId = typeof requestRecord.workspaceId === "string" ? requestRecord.workspaceId : null;
+    const terminal = await resolveTerminalLaunchSettings({
+      runtime,
+      flags: parsed.flags,
+      workspaceId: requestWorkspaceId
+    });
     const missionId = String(requestRecord.missionId);
     const dryRun = flagBoolean(parsed.flags, "--dry-run");
     const prepared = await prepareMissionBranch({
@@ -24257,7 +24354,10 @@ The runner will not register a target for you \u2014 declare this machine first,
         missionId,
         workingDirectory: String(requestRecord.workingDirectory ?? process.cwd()),
         objectiveId: String(requestRecord.objectiveId ?? ""),
-        workspaceAutomationEnabled: await readWorktreeBranchAutomationEnabled(runtime),
+        workspaceAutomationEnabled: await readWorktreeBranchAutomationEnabled(
+          runtime,
+          requestWorkspaceId
+        ),
         dryRun,
         overrideBranch: flagValue(parsed.flags, "--branch"),
         noWorktree: flagBoolean(parsed.flags, "--no-worktree")
@@ -24270,6 +24370,16 @@ The runner will not register a target for you \u2014 declare this machine first,
       branchAutomation: prepared.branchAutomation
     });
     const launchSession = launchSessionSnapshotFromMetadata(asRecord5(requestRecord.metadata));
+    if (shouldRefuseInlineRunnerLaunch({
+      dryRun,
+      terminalLauncher: terminal.terminalLauncher,
+      executionProvider: launchSession?.executionProvider.kind,
+      stdoutIsTTY: process.stdout.isTTY
+    })) {
+      throw new CliError({
+        message: `Refusing to launch ${requestedAgent} inline: this runner has no TTY and no terminal launcher is configured for this device, so the agent would have nowhere to run. Set a terminal in Settings \u2192 Terminal & IDE (or run \`ovld setup\`), or select the Latch execution provider for this target, then re-run the objective.`
+      });
+    }
     const result = await launchAgent({
       runtime,
       options: {
@@ -24299,7 +24409,13 @@ The runner will not register a target for you \u2014 declare this machine first,
       console.error(`[overlord] ${result.viewerOpen.warning}`);
     }
     if (result.status && result.status !== 0) {
-      throw new CliError({ message: `Launch command exited with status ${result.status}` });
+      throw new CliError({
+        message: launchFailureMessage({
+          status: result.status,
+          execution: result.plan.execution,
+          terminal
+        })
+      });
     }
     await runtime.backend.post({
       path: `/api/runner/requests/${requestId}/launched`,
@@ -24322,7 +24438,9 @@ The runner will not register a target for you \u2014 declare this machine first,
     try {
       await runtime.backend.post({
         path: `/api/runner/requests/${requestId}/failed`,
-        body: { error: error instanceof Error ? error.message : String(error) }
+        body: {
+          error: sanitizeRunnerFailureMessage(error instanceof Error ? error.message : error)
+        }
       });
     } catch {
     }
@@ -24379,7 +24497,15 @@ async function runRunnerCommand({
   const intervalMs = Number.parseInt(flagValue(parsed.flags, "--poll-interval-ms") ?? "3000", 10);
   if (!json) console.log(`Runner started. Polling every ${intervalMs}ms for execution requests.`);
   while (true) {
-    const result = await runOnce();
+    let result = { launched: false, longPoll: false };
+    try {
+      result = await runOnce();
+    } catch (error) {
+      if (isNoExecutionTargetRegisteredError(error)) throw error;
+      console.error(
+        `[overlord] Runner poll failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
     if (!result.longPoll) await new Promise((resolve) => setTimeout(resolve, intervalMs));
   }
 }
@@ -24528,7 +24654,7 @@ Note: ${reinstallHint}`);
     message: "Usage: ovld runner service <install|start|stop|restart|status|uninstall> [--no-start] [--json]"
   });
 }
-var PROTOCOL_FILE_FLAGS, SESSION_KEY_SUBCOMMANDS, OBJECTIVE_SCOPED_SUBCOMMANDS;
+var PROTOCOL_FILE_FLAGS, SESSION_KEY_SUBCOMMANDS, OBJECTIVE_SCOPED_SUBCOMMANDS, MAX_RUNNER_FAILURE_MESSAGE_LENGTH;
 var init_commands = __esm({
   "src/commands.ts"() {
     "use strict";
@@ -24545,12 +24671,14 @@ var init_commands = __esm({
     init_errors();
     init_launch();
     init_launch_bootstrap();
+    init_launch_settings();
     init_native_session();
     init_org_setup();
     init_output();
     init_project_tmp();
     init_protocol_help();
     init_record_touched();
+    init_redact_secrets();
     init_resource_observations();
     init_runner_identity();
     init_runner_service();
@@ -24604,6 +24732,7 @@ var init_commands = __esm({
       "update-artifact",
       "write-context"
     ]);
+    MAX_RUNNER_FAILURE_MESSAGE_LENGTH = 1200;
   }
 });