overlord-cli 0.2607171335.0 → 0.2607191132.0

package/dist/index.js

@@ -13538,6 +13538,87 @@ var init_discover_project_local = __esm({
   }
 });
 
+// src/pre-launch.ts
+function substitutePreLaunchVariables(commands, variables) {
+  return commands.map(
+    (command) => command.replace(PLACEHOLDER_PATTERN, (match, name) => {
+      const value = variables[name];
+      return value === void 0 ? match : value;
+    })
+  ).map((command) => command.trim()).filter((command) => command.length > 0);
+}
+function substituteLaunchEnvVars(envVars, variables) {
+  const resolved = {};
+  for (const [rawKey, rawValue] of Object.entries(envVars)) {
+    const key = rawKey.trim();
+    if (!key) continue;
+    resolved[key] = rawValue.replace(PLACEHOLDER_PATTERN, (match, name) => {
+      const value = variables[name];
+      return value === void 0 ? match : value;
+    });
+  }
+  return resolved;
+}
+function resourcePaths(projectResources) {
+  if (!Array.isArray(projectResources)) return [];
+  const paths = [];
+  for (const entry of projectResources) {
+    if (entry && typeof entry === "object") {
+      const path27 = entry.path;
+      if (typeof path27 === "string" && path27.trim()) paths.push(path27.trim());
+    }
+  }
+  return paths;
+}
+function primaryResourcePath(projectResources) {
+  if (!Array.isArray(projectResources)) return "";
+  let currentPath = "";
+  for (const entry of projectResources) {
+    if (!entry || typeof entry !== "object") continue;
+    const record = entry;
+    const path27 = typeof record.path === "string" ? record.path.trim() : "";
+    if (!path27) continue;
+    if (record.isPrimary === true) return path27;
+    if (record.isCurrent === true && !currentPath) currentPath = path27;
+  }
+  return currentPath;
+}
+function buildPreLaunchVariables({
+  launchEnv = {},
+  projectResources,
+  workingDirectory,
+  contextFile,
+  tmpDir
+}) {
+  const paths = resourcePaths(projectResources);
+  const scratch = typeof tmpDir === "string" ? tmpDir.trim() : "";
+  const cwd = typeof workingDirectory === "string" ? workingDirectory.trim() : "";
+  const contextPath = typeof contextFile === "string" ? contextFile.trim() : "";
+  return {
+    // Optional Overlord env keys default to empty so documented placeholders
+    // resolve rather than remaining as literal `{VAR}` tokens.
+    OVERLORD_EXECUTION_REQUEST_ID: "",
+    OVERLORD_PROJECT_RESOURCES: "",
+    ...launchEnv,
+    OVERLORD_PROJECT_RESOURCES_PATHS: paths.join(" "),
+    OVERLORD_PROJECT_RESOURCES_PATHS_CSV: paths.join(","),
+    OVERLORD_PRIMARY_RESOURCE_PATH: primaryResourcePath(projectResources),
+    OVERLORD_WORKING_DIRECTORY: cwd,
+    OVERLORD_CONTEXT_FILE: contextPath,
+    OVERLORD_TMPDIR: scratch,
+    TMPDIR: scratch,
+    TMP: scratch,
+    TEMP: scratch
+  };
+}
+var PLACEHOLDER_PATTERN;
+var init_pre_launch = __esm({
+  "src/pre-launch.ts"() {
+    "use strict";
+    PLACEHOLDER_PATTERN = /\{([A-Z0-9_]+)\}/g;
+  }
+});
+
 // src/terminal-launcher.ts
 function shellQuote2(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
@@ -13583,24 +13664,31 @@ function agentShellCommand({
   const assignments = Object.entries(extraEnv).filter(([key, value]) => key.trim() && value.trim()).map(([key, value]) => `${key}=${shellQuote2(value)}`).join(" ");
   return assignments ? `env ${assignments} ${invocation}` : invocation;
 }
+function withPreLaunchCommands(agentCommand, preLaunchCommands) {
+  const pre = (preLaunchCommands ?? []).map((command) => command.trim()).filter(Boolean);
+  return pre.length > 0 ? `${pre.join("; ")}; ${agentCommand}` : agentCommand;
+}
 function terminalInnerCommand({
   workingDirectory,
   agentCommand,
-  extraEnv = {}
+  extraEnv = {},
+  preLaunchCommands
 }) {
   const exports = Object.entries({ ...tmpEnvFor(workingDirectory), ...extraEnv }).map(([key, value]) => `export ${key}=${shellQuote2(value)}`).join("; ");
-  return `cd ${shellQuote2(workingDirectory)} && ${exports}; ${agentCommand}`;
+  const invocation = withPreLaunchCommands(agentCommand, preLaunchCommands);
+  return `cd ${shellQuote2(workingDirectory)} && ${exports}; ${invocation}`;
 }
 function terminalLaunchScriptContent({
   command,
   args,
   workingDirectory,
   preCommand,
-  extraEnv = {}
+  extraEnv = {},
+  preLaunchCommands
 }) {
   const agentCommand = agentShellCommand({ command, args, preCommand });
   return `#!/usr/bin/env bash
-${terminalInnerCommand({ workingDirectory, agentCommand, extraEnv })}
+${terminalInnerCommand({ workingDirectory, agentCommand, extraEnv, preLaunchCommands })}
 `;
 }
 function terminalScriptCommand(scriptPath) {
@@ -13761,7 +13849,8 @@ function resolveLaunchExecution({
   terminalLaunchChord,
   terminalScriptPath,
   terminalLaunchBackground = false,
-  extraEnv = {}
+  extraEnv = {},
+  preLaunchCommands
 }) {
   const agentCommand = agentShellCommand({ command, args, preCommand });
   const genericAgentCommand = agentShellCommand({
@@ -13771,13 +13860,23 @@ function resolveLaunchExecution({
     extraEnv,
     includeEnvPrefix: true
   });
+  const hasPreLaunch = (preLaunchCommands ?? []).some((entry) => entry.trim().length > 0);
   const launcher = terminalLauncher?.trim();
   const placement = terminalLaunchPlacement ?? "window";
   const chordClause = resolveChordClause(terminalLaunchChord);
   if (!launcher) {
-    return preCommand?.trim() ? { command: agentCommand, args: [], useShell: true, terminal: null, display: agentCommand } : { command, args, useShell: false, terminal: null, display: agentCommand };
+    if (!preCommand?.trim() && !hasPreLaunch) {
+      return { command, args, useShell: false, terminal: null, display: agentCommand };
+    }
+    const inline = withPreLaunchCommands(agentCommand, preLaunchCommands);
+    return { command: inline, args: [], useShell: true, terminal: null, display: inline };
   }
-  const inner = terminalInnerCommand({ workingDirectory, agentCommand, extraEnv });
+  const inner = terminalInnerCommand({
+    workingDirectory,
+    agentCommand,
+    extraEnv,
+    preLaunchCommands
+  });
   const terminalInner = terminalScriptPath?.trim() ? terminalScriptCommand(terminalScriptPath.trim()) : inner;
   const builtin = resolveBuiltinTerminal(launcher);
   if (builtin === "terminal") {
@@ -13811,7 +13910,7 @@ function resolveLaunchExecution({
       display: `iTerm2 (${placement}) \u203A ${terminalInner}`
     };
   }
-  const genericTerminalCommand = terminalScriptPath?.trim() ? terminalScriptCommand(terminalScriptPath.trim()) : genericAgentCommand;
+  const genericTerminalCommand = terminalScriptPath?.trim() ? terminalScriptCommand(terminalScriptPath.trim()) : withPreLaunchCommands(genericAgentCommand, preLaunchCommands);
   const full = placement === "window" ? `${terminalLaunchBackground ? backgroundLauncher(launcher) : launcher} ${genericTerminalCommand}` : buildGenericPlacementShell({
     launcher,
     inner: genericTerminalCommand,
@@ -14000,6 +14099,16 @@ Execution request: ${options.executionRequestId}` : context.launchContext;
     executionRequestId: options.executionRequestId,
     projectResources
   });
+  const launchVariables = buildPreLaunchVariables({
+    launchEnv,
+    projectResources,
+    workingDirectory: options.workingDirectory,
+    contextFile,
+    tmpDir
+  });
+  const preLaunchCommands = options.preLaunchCommands && options.preLaunchCommands.length > 0 ? substitutePreLaunchVariables(options.preLaunchCommands, launchVariables) : [];
+  const resolvedEnvVars = options.launchEnvVars && Object.keys(options.launchEnvVars).length > 0 ? substituteLaunchEnvVars(options.launchEnvVars, launchVariables) : {};
+  const exportedEnv = { ...launchEnv, ...resolvedEnvVars };
   const prompt = launchContext.length > 4e3 ? `Read the Overlord context file at ${contextFile}, attach to mission ${context.displayId}, then immediately execute its current objective. Do not wait for more instructions.` : launchContext;
   const command = buildAgentCommand({
     agent: options.agent,
@@ -14023,7 +14132,8 @@ Execution request: ${options.executionRequestId}` : context.launchContext;
         args: command.args,
         workingDirectory: options.workingDirectory,
         preCommand: options.preCommand,
-        extraEnv: launchEnv
+        extraEnv: exportedEnv,
+        preLaunchCommands
       })
     );
     chmodSync3(terminalScriptPath, 448);
@@ -14038,7 +14148,8 @@ Execution request: ${options.executionRequestId}` : context.launchContext;
     terminalLaunchChord: options.terminalLaunchChord,
     terminalLaunchBackground: options.terminalLaunchBackground,
     terminalScriptPath,
-    extraEnv: launchEnv
+    extraEnv: exportedEnv,
+    preLaunchCommands
   });
   return {
     ...command,
@@ -14046,7 +14157,7 @@ Execution request: ${options.executionRequestId}` : context.launchContext;
     contextFile,
     workingDirectory: options.workingDirectory,
     execution,
-    env: launchEnv
+    env: exportedEnv
   };
 }
 async function launchAgent({
@@ -14080,6 +14191,7 @@ var init_launch = __esm({
   "src/launch.ts"() {
     "use strict";
     init_agent_binaries();
+    init_pre_launch();
     init_project_tmp();
     init_terminal_launcher();
     AGENT_HISTORY_EXCLUDED_EVENT_TYPES = /* @__PURE__ */ new Set([
@@ -16422,6 +16534,17 @@ async function resolveTerminalLaunchSettings({
 function asRecord2(value) {
   return value && typeof value === "object" ? value : {};
 }
+function parsePreLaunchCommandsValue(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+}
+function parseLaunchEnvVarsValue(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const vars = {};
+  for (const [key, raw] of Object.entries(value)) {
+    if (key.trim() && typeof raw === "string") vars[key] = raw;
+  }
+  return vars;
+}
 async function readWorktreeBranchAutomationEnabled(runtime) {
   try {
     const settings = await runtime.backend.get("/api/launch-settings");
@@ -16933,6 +17056,16 @@ async function runManagementCommand({
       const executionTargetId = await resolvePreferredExecutionTargetId({
         backend: scopedRuntime.backend
       });
+      const missionProjectId = asRecord2(mission).projectId;
+      const projectLaunchSettings = typeof missionProjectId === "string" ? await scopedRuntime.backend.get(`/api/projects/${encodeURIComponent(missionProjectId)}`).then((project) => ({
+        preLaunchCommands: parsePreLaunchCommandsValue(asRecord2(project).preLaunchCommands),
+        launchEnvVars: parseLaunchEnvVarsValue(asRecord2(project).launchEnvVars)
+      })).catch(() => ({
+        preLaunchCommands: [],
+        launchEnvVars: {}
+      })) : { preLaunchCommands: [], launchEnvVars: {} };
+      const preLaunchCommands = projectLaunchSettings.preLaunchCommands;
+      const launchEnvVars = projectLaunchSettings.launchEnvVars;
       const prepared = await prepareMissionBranch({
         runtime: scopedRuntime,
         options: {
@@ -16960,6 +17093,8 @@ async function runManagementCommand({
           thinking: flagValue(parsed.flags, "--thinking"),
           flags: repeatedFlagValues(rest, "--flag"),
           preCommand: flagValue(parsed.flags, "--pre-command"),
+          preLaunchCommands: preLaunchCommands.length > 0 ? preLaunchCommands : void 0,
+          launchEnvVars: Object.keys(launchEnvVars).length > 0 ? launchEnvVars : void 0,
           executionTargetId: executionTargetId ?? void 0,
           ...terminal,
           dryRun
@@ -17182,6 +17317,10 @@ async function runRunnerCommand({
           thinking: typeof requestRecord.requestedReasoningEffort === "string" ? requestRecord.requestedReasoningEffort : void 0,
           flags: Array.isArray(launchConfig.flags) ? launchConfig.flags.filter((value) => typeof value === "string") : [],
           preCommand: typeof launchConfig.preCommand === "string" ? launchConfig.preCommand : void 0,
+          preLaunchCommands: Array.isArray(requestRecord.preLaunchCommands) ? requestRecord.preLaunchCommands.filter(
+            (value) => typeof value === "string"
+          ) : void 0,
+          launchEnvVars: parseLaunchEnvVarsValue(requestRecord.launchEnvVars),
           executionRequestId: requestId,
           executionTargetId: executionTargetId || void 0,
           ...terminal,