overlord-cli 0.2605290912.0 → 0.2605291450.0

package/bin/_cli/direct-launch.mjs

@@ -39,7 +39,9 @@ const VALUE_FLAGS = new Set([
   'ssh-command',
   'remote-working-directory',
   'server-multiplexer',
-  'tmux-command'
+  'tmux-command',
+  'feed-post-id',
+  'initial-question'
 ]);
 
 const BOOLEAN_FLAGS = new Set(['personal', 'for-human', 'allow-uninstalled']);
@@ -52,7 +54,9 @@ const FORWARDED_VALUE_FLAGS = [
   'ssh-command',
   'remote-working-directory',
   'server-multiplexer',
-  'tmux-command'
+  'tmux-command',
+  'feed-post-id',
+  'initial-question'
 ];
 
 export function isBuiltinLaunchAgent(name) {
@@ -212,7 +216,7 @@ Overlord flags:
   --model <identifier>          Preferred model (sets the ticket delegate and is forwarded to the agent)
   --thinking <level>            Agent reasoning/effort level
   --flag <value>                Extra agent flag (repeatable)
-  --pre-command <command>       Command to run before the agent binary (e.g. ollama)
+  --pre-command <command>       Shell command to run before the agent binary (e.g. ollama, agent-pod)
   --project-id <uuid>           Target project (skips working-directory resolution)
   --personal                    Create the ticket in your personal project
   --for-human                   Create a human-review ticket

package/bin/_cli/launcher.mjs

@@ -6,6 +6,7 @@
  */
 
 import { execFileSync } from 'node:child_process';
+import crypto from 'node:crypto';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
@@ -90,12 +91,21 @@ function buildAgyLaunchArgv({ contextFile, scratchDir, mode, sessionId, extraArg
   return argv;
 }
 
-async function fetchContext(platformUrl, bearerToken, localSecret, organizationId, ticketId, agent) {
+async function fetchContext(platformUrl, bearerToken, localSecret, organizationId, ticketId, agent, options = {}) {
   const params = new URLSearchParams({
     context: 'cli',
     agent,
     instructionMode: getInstructionMode(agent)
   });
+  if (options.launchMode === 'ask') params.set('mode', 'ask');
+  if (options.sessionId) params.set('sessionId', options.sessionId);
+  if (options.workspace) params.set('workspace', options.workspace);
+  if (options.feedPostId) {
+    params.set('feedPostId', options.feedPostId);
+    if (typeof options.initialQuestion === 'string') {
+      params.set('initialQuestion', options.initialQuestion);
+    }
+  }
   const url = `${platformUrl}/api/protocol/context/${ticketId}?${params.toString()}`;
   const response = await fetch(url, {
     headers: buildAuthHeaders(bearerToken, localSecret, organizationId)
@@ -107,7 +117,10 @@ async function fetchContext(platformUrl, bearerToken, localSecret, organizationI
     );
   }
 
-  return response.text();
+  const context = await response.text();
+  const workingDirectory = response.headers.get('X-Working-Directory') ?? '';
+  const humanTicketId = response.headers.get('X-Ticket-Id') ?? '';
+  return { context, workingDirectory, humanTicketId };
 }
 
 const agentIdentifierMap = {
@@ -124,24 +137,53 @@ const supportedAgents = ['claude', 'codex', 'cursor', 'antigravity', 'opencode',
 // Re-exported under clearer names for the direct-launch dispatcher in index.mjs.
 export { supportedAgents as BUILTIN_LAUNCH_AGENTS, agentIdentifierMap };
 
+/** @internal Test-only overrides for launcher subprocess calls. */
+export const launcherTestHooks = {
+  execFileSync: null,
+  shell: null,
+  platform: null
+};
+
 function shellQuote(value) {
   return `'${String(value).replace(/'/g, `'\\''`)}'`;
 }
 
+function resolveLauncherShell() {
+  const platform = launcherTestHooks.platform ?? process.platform;
+  if (platform === 'win32') {
+    return null;
+  }
+  return launcherTestHooks.shell ?? process.env.SHELL ?? 'sh';
+}
+
 /**
  * Run an agent binary, optionally routed through a user-defined pre-command
- * (e.g. `ollama` to run claude-code through Ollama). When a pre-command is set,
- * its first token becomes the executable and the agent binary + args follow it:
- *   preCommand="ollama"  →  ollama claude <args...>
+ * (e.g. `ollama` to run claude-code through Ollama). On POSIX shells, execute
+ * the wrapper through the user's interactive login shell so aliases, functions,
+ * and PATH customizations are available:
+ *   preCommand="agent-pod"  →  $SHELL -ilc 'agent-pod codex <args...>'
+ *
+ * The shell must be interactive (`-i`), not just a login shell (`-l`): zsh only
+ * sources ~/.zshrc — and bash only sources ~/.bashrc — for interactive shells.
+ * Wrappers like agent-pod are commonly installed as a shell alias in ~/.zshrc
+ * (its documented default), so a plain `-lc` login shell never sees them and
+ * fails with `command not found`.
  */
 function execAgentBinary(binary, args, opts, preCommand) {
+  const exec = launcherTestHooks.execFileSync ?? execFileSync;
   const pre = typeof preCommand === 'string' ? preCommand.trim() : '';
   if (pre) {
+    const shell = resolveLauncherShell();
+    if (shell) {
+      const command = [pre, shellQuote(binary), ...args.map(arg => shellQuote(arg))].join(' ');
+      exec(shell, ['-ilc', command], opts);
+      return;
+    }
     const preTokens = pre.split(/\s+/).filter(Boolean);
-    execFileSync(preTokens[0], [...preTokens.slice(1), binary, ...args], opts);
+    exec(preTokens[0], [...preTokens.slice(1), binary, ...args], opts);
     return;
   }
-  execFileSync(binary, args, opts);
+  exec(binary, args, opts);
 }
 
 function toTomlString(value) {
@@ -279,11 +321,13 @@ Options:
   --model <identifier>              Preferred model identifier
   --thinking <level>                Agent reasoning/effort level
   --flag <value>                    Extra agent flag (repeatable)
-  --pre-command <command>           Command to run before the agent binary (e.g. ollama)
+  --pre-command <command>           Shell command to run before the agent binary (e.g. ollama, agent-pod)
   --ssh-command <command>           Launch remotely over SSH by running ovld on the target host
   --remote-working-directory <path> Change to this path on the remote host before launch
   --server-multiplexer <none|tmux>  Wrap remote launches in tmux
   --tmux-command <template>         Remote tmux template; use {script} as the placeholder
+  --feed-post-id <uuid>             Include a feed post in the context (desktop feed discuss)
+  --initial-question <text>         First user question for feed discuss (paired with --feed-post-id)
 
 Notes:
   - ovld launch is the primary user-facing launcher.
@@ -370,7 +414,10 @@ async function runAgent(agent, mode = 'run', options = {}) {
     options.organizationId,
     organizationId
   );
-  if (options.sshCommand?.trim()) {
+  const launchSessionId = crypto.randomUUID();
+  const isRemote = Boolean(options.sshCommand?.trim());
+
+  if (isRemote) {
     const remoteCommand = buildRemoteLaunchCommand(agent, {
       ...options,
       organizationId: resolvedLaunchOrganizationId
@@ -385,18 +432,40 @@ async function runAgent(agent, mode = 'run', options = {}) {
     }
   }
 
-  const context = await fetchContext(
+  const { context, workingDirectory: apiWorkingDirectory, humanTicketId } = await fetchContext(
     platformUrl,
     bearerToken,
     localSecret,
     resolvedLaunchOrganizationId,
     ticketId,
-    agent
+    agent,
+    {
+      launchMode: options.launchMode,
+      sessionId: launchSessionId,
+      workspace: isRemote ? 'ssh' : undefined,
+      feedPostId: options.feedPostId,
+      initialQuestion: options.initialQuestion
+    }
   );
 
+  if (humanTicketId) {
+    process.env.TICKET_ID = humanTicketId;
+  }
+
+  if (!options.workingDirectory && apiWorkingDirectory) {
+    try {
+      process.chdir(apiWorkingDirectory);
+    } catch {
+      // Best-effort; the agent will run in the current directory.
+    }
+  }
+
   const childEnv = withLaunchTempEnv({
     ...process.env,
     AGENT_IDENTIFIER: agentIdentifierMap[agent],
+    OVERLORD_LAUNCH_SESSION_ID: launchSessionId,
+    OVERLORD_MODEL_IDENTIFIER: options.model ?? '',
+    MODEL_IDENTIFIER: options.model ?? '',
     ...(resolvedLaunchOrganizationId
       ? { OVERLORD_ORGANIZATION_ID: String(resolvedLaunchOrganizationId) }
       : {})
@@ -568,19 +637,27 @@ async function runCustomAgent(args) {
     flags['organization-id'],
     organizationId
   );
+  const launchSessionId = crypto.randomUUID();
+  const feedPostId = typeof flags['feed-post-id'] === 'string' ? flags['feed-post-id'].trim() : '';
+  const initialQuestion = typeof flags['initial-question'] === 'string' ? flags['initial-question'].trim() : '';
   // Custom agents have no Overlord plugin/bundle; use the generic "claude" context.
-  const context = await fetchContext(
+  const { context } = await fetchContext(
     platformUrl,
     bearerToken,
     localSecret,
     resolvedLaunchOrganizationId,
     resolvedTicketId,
-    'claude'
+    'claude',
+    {
+      sessionId: launchSessionId,
+      ...(feedPostId ? { feedPostId, initialQuestion } : {})
+    }
   );
 
   const childEnv = withLaunchTempEnv({
     ...process.env,
     AGENT_IDENTIFIER: 'custom',
+    OVERLORD_LAUNCH_SESSION_ID: launchSessionId,
     ...(resolvedLaunchOrganizationId
       ? { OVERLORD_ORGANIZATION_ID: String(resolvedLaunchOrganizationId) }
       : {})
@@ -639,7 +716,9 @@ export async function runLauncherCommand(command, args) {
         : '',
     serverMultiplexer:
       flags['server-multiplexer'] === 'tmux' ? 'tmux' : 'none',
-    tmuxCommand: typeof flags['tmux-command'] === 'string' ? flags['tmux-command'].trim() : ''
+    tmuxCommand: typeof flags['tmux-command'] === 'string' ? flags['tmux-command'].trim() : '',
+    feedPostId: typeof flags['feed-post-id'] === 'string' ? flags['feed-post-id'].trim() : '',
+    initialQuestion: typeof flags['initial-question'] === 'string' ? flags['initial-question'].trim() : ''
   };
 
   if (normalizedCommand === 'run') {

package/bin/_cli/runner.mjs

@@ -8,11 +8,13 @@ import path from 'node:path';
 
 const OVLD_ENTRY = process.argv[1];
 const DEVICE_FILE = path.join(os.homedir(), '.ovld', 'device.json');
+const DEFAULT_TMUX_COMMAND = 'tmux new-session bash {script}';
 
 /** @internal Test-only overrides for protocol/launch subprocess calls. */
 export const runnerTestHooks = {
   execFileSync: null,
-  spawn: null
+  spawn: null,
+  platform: null
 };
 
 function printRunnerHelp(primaryCommand = 'ovld') {
@@ -131,9 +133,167 @@ export function buildLaunchArgs(launch) {
   }
   if (launch.serverMultiplexer === 'tmux') args.push('--server-multiplexer', 'tmux');
   if (launch.tmuxCommand) args.push('--tmux-command', launch.tmuxCommand);
+  if (launch.feedPostId) args.push('--feed-post-id', launch.feedPostId);
+  if (launch.initialQuestion) args.push('--initial-question', launch.initialQuestion);
   return args;
 }
 
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+
+function appleScriptString(value) {
+  return `"${String(value).replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+}
+
+function normalizeRunnerTerminalProfile(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+  return {
+    terminalApp: typeof value.terminalApp === 'string' ? value.terminalApp : 'default',
+    terminalLaunchMode:
+      typeof value.terminalLaunchMode === 'string' ? value.terminalLaunchMode : 'tab',
+    terminalCustomHotkey:
+      typeof value.terminalCustomHotkey === 'string' ? value.terminalCustomHotkey : '',
+    customTerminalApp:
+      typeof value.customTerminalApp === 'string' ? value.customTerminalApp : '',
+    terminalTmuxHostApp:
+      typeof value.terminalTmuxHostApp === 'string' ? value.terminalTmuxHostApp : 'terminal',
+    customTerminalTmuxHostApp:
+      typeof value.customTerminalTmuxHostApp === 'string'
+        ? value.customTerminalTmuxHostApp
+        : '',
+    terminalTmuxCommand:
+      typeof value.terminalTmuxCommand === 'string' && value.terminalTmuxCommand.trim()
+        ? value.terminalTmuxCommand
+        : DEFAULT_TMUX_COMMAND
+  };
+}
+
+function buildRunnerLaunchShellCommand(args, deviceFingerprint) {
+  return [
+    `export OVERLORD_DEVICE_FINGERPRINT=${shellQuote(deviceFingerprint)}`,
+    `exec ${shellQuote(process.execPath)} ${[OVLD_ENTRY, ...args].map(shellQuote).join(' ')}`
+  ].join('\n');
+}
+
+function writeRunnerLaunchScript(launchCommand) {
+  const dir = path.join(os.tmpdir(), 'ovld-runner');
+  fs.mkdirSync(dir, { recursive: true });
+  const scriptPath = path.join(
+    dir,
+    `launch-${process.pid}-${Date.now()}-${crypto.randomUUID()}.sh`
+  );
+  fs.writeFileSync(scriptPath, `#!/usr/bin/env bash\nset -e\n${launchCommand}\n`, {
+    mode: 0o700
+  });
+  return scriptPath;
+}
+
+function buildTmuxCommand(template, scriptPath) {
+  const resolvedTemplate =
+    typeof template === 'string' && template.trim().includes('{script}')
+      ? template.trim()
+      : DEFAULT_TMUX_COMMAND;
+  return resolvedTemplate.replaceAll('{script}', shellQuote(scriptPath));
+}
+
+function terminalAppName(profile) {
+  if (profile.terminalApp === 'custom') return profile.customTerminalApp.trim();
+  const appMap = {
+    default: 'Terminal',
+    terminal: 'Terminal',
+    iterm: 'iTerm',
+    warp: 'Warp',
+    ghostty: 'Ghostty',
+    alacritty: 'Alacritty',
+    kitty: 'Kitty',
+    hyper: 'Hyper'
+  };
+  return appMap[profile.terminalApp] ?? '';
+}
+
+export function buildRunnerTerminalOpenCommand(
+  profileValue,
+  launchCommand,
+  platform = process.platform
+) {
+  const profile = normalizeRunnerTerminalProfile(profileValue);
+  if (!profile) return null;
+
+  const command =
+    profile.terminalApp === 'tmux'
+      ? buildTmuxCommand(profile.terminalTmuxCommand, writeRunnerLaunchScript(launchCommand))
+      : launchCommand;
+
+  if (profile.terminalApp === 'tmux' && platform !== 'darwin') {
+    return command;
+  }
+
+  if (platform !== 'darwin') return null;
+
+  const appName =
+    profile.terminalApp === 'tmux'
+      ? terminalAppName({
+          ...profile,
+          terminalApp: profile.terminalTmuxHostApp,
+          customTerminalApp: profile.customTerminalTmuxHostApp
+        })
+      : terminalAppName(profile);
+  if (!appName) return null;
+
+  if (appName === 'iTerm') {
+    return [
+      'osascript',
+      '-e',
+      shellQuote('tell application "iTerm"'),
+      '-e',
+      shellQuote(`create window with default profile command ${appleScriptString(command)}`),
+      '-e',
+      shellQuote('activate'),
+      '-e',
+      shellQuote('end tell')
+    ].join(' ');
+  }
+
+  return [
+    'osascript',
+    '-e',
+    shellQuote(
+      `tell application ${appleScriptString(appName)} to do script ${appleScriptString(command)}`
+    ),
+    '-e',
+    shellQuote(`tell application ${appleScriptString(appName)} to activate`)
+  ].join(' ');
+}
+
+function spawnLaunchProcess(args, claim, deviceFingerprint) {
+  const spawnImpl = runnerTestHooks.spawn ?? spawn;
+  const launchCommand = buildRunnerLaunchShellCommand(args, deviceFingerprint);
+  const terminalCommand = buildRunnerTerminalOpenCommand(
+    claim.launch?.runnerTerminalProfile,
+    launchCommand,
+    runnerTestHooks.platform ?? process.platform
+  );
+
+  if (!terminalCommand) {
+    return {
+      child: spawnImpl(process.execPath, [OVLD_ENTRY, ...args], {
+        stdio: 'inherit',
+        env: { ...process.env, OVERLORD_DEVICE_FINGERPRINT: deviceFingerprint }
+      }),
+      completeOnClose: false
+    };
+  }
+
+  return {
+    child: spawnImpl('sh', ['-lc', terminalCommand], {
+      stdio: 'inherit',
+      env: { ...process.env, OVERLORD_DEVICE_FINGERPRINT: deviceFingerprint }
+    }),
+    completeOnClose: true
+  };
+}
+
 export async function launchClaimedRequest(claim, deviceFingerprint) {
   const requestId = claim.request?.id;
   if (!requestId || !claim.launch?.agent || !claim.launch?.ticketId) return false;
@@ -144,13 +304,10 @@ export async function launchClaimedRequest(claim, deviceFingerprint) {
   );
 
   await new Promise((resolve, reject) => {
-    const spawnImpl = runnerTestHooks.spawn ?? spawn;
-    const child = spawnImpl(process.execPath, [OVLD_ENTRY, ...args], {
-      stdio: 'inherit',
-      env: { ...process.env, OVERLORD_DEVICE_FINGERPRINT: deviceFingerprint }
-    });
+    const { child, completeOnClose } = spawnLaunchProcess(args, claim, deviceFingerprint);
 
     child.once('spawn', () => {
+      if (completeOnClose) return;
       try {
         completeLaunch(requestId, deviceFingerprint);
       } catch (error) {
@@ -168,6 +325,19 @@ export async function launchClaimedRequest(claim, deviceFingerprint) {
     });
 
     child.once('close', code => {
+      if (completeOnClose && (!code || code === 0)) {
+        try {
+          completeLaunch(requestId, deviceFingerprint);
+        } catch (error) {
+          process.stderr.write(`[runner] failed to mark request launched: ${error}\n`);
+        }
+      } else if (completeOnClose && code) {
+        try {
+          failLaunch(requestId, deviceFingerprint, `terminal launcher exited with code ${code}`);
+        } catch {
+          // Preserve the launcher exit below.
+        }
+      }
       if (code && code !== 0) {
         process.stderr.write(`[runner] launch process exited with code ${code}\n`);
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "overlord-cli",
-  "version": "0.2605290912.0",
+  "version": "0.2605291450.0",
   "description": "Overlord CLI — launch AI agents on tickets from anywhere",
   "homepage": "https://www.ovld.ai/docs/",
   "type": "module",