hivehq 2.0.0

package/dist/src/server/orchestrator-autostart.d.ts

@@ -0,0 +1,42 @@
+import type { AgentLaunchConfigInput } from './agent-run-store.js';
+interface AutostartPort {
+    startAgent: (workspaceId: string, agentId: string, input: {
+        hivePort: string;
+    }) => Promise<{
+        runId: string;
+        status: string;
+        exitCode: number | null;
+    }>;
+    getLiveRun: (runId: string) => {
+        status: string;
+        exitCode: number | null;
+    };
+    peekAgentLaunchConfig: (workspaceId: string, agentId: string) => AgentLaunchConfigInput | undefined;
+}
+export interface OrchestratorStartResult {
+    ok: boolean;
+    error: string | null;
+    run_id: string | null;
+}
+/**
+ * Translate an early-exit terminal state to a human-friendly error string.
+ *
+ * Two cases land here:
+ *   - exit 127 (POSIX) / 9009 (Windows cmd.exe): shell saying "command not
+ *     found" — the most common real case when the configured CLI is missing,
+ *     because node-pty does NOT throw sync ENOENT for missing binaries; it
+ *     spawns successfully and the child dies via onExit.
+ *   - any other non-zero exit: surface the raw code so we don't lie about the
+ *     cause.
+ */
+export declare const formatEarlyExitError: (command: string, exitCode: number | null) => string;
+/**
+ * Wraps `store.startAgent` so spawn failures never bubble up: callers always
+ * receive a structured result. The HTTP layer uses this to keep workspace
+ * creation green even when the orchestrator binary is missing.
+ */
+export declare const autostartOrchestrator: (port: AutostartPort, workspaceId: string, orchestratorId: string, hivePort: string) => Promise<OrchestratorStartResult>;
+export declare const autostartAgent: (port: AutostartPort, workspaceId: string, agentId: string, hivePort: string, options: {
+    missingConfigError: string;
+}) => Promise<OrchestratorStartResult>;
+export {};

package/dist/src/server/orchestrator-autostart.js

@@ -0,0 +1,114 @@
+import { getStartupCommandExecutable } from './startup-command-parser.js';
+// SETTLE_WAIT_MS: how long we wait before declaring autostart "ok". Must be
+// long enough to observe an early exit when the child shell prints
+// "command not found" then dies with exit 127 (POSIX) or 9009 (Windows)
+// — typically <100ms in practice. 800ms balances reliability vs the perceived
+// workspace-create latency cost.
+const SETTLE_WAIT_MS = process.platform === 'win32' ? 2000 : 800;
+const POLL_INTERVAL_MS = 25;
+// Shells emit a "command not found" exit code when the requested binary is
+// missing on PATH. node-pty does NOT raise a synchronous spawn error for that
+// case — the PTY just dies almost immediately via onExit. We translate that to
+// the same UX string as the sync-ENOENT path so the user gets one consistent
+// message. POSIX shells use 127; Windows cmd.exe uses 9009.
+const COMMAND_NOT_FOUND_EXIT_CODES = new Set([127, 9009]);
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const isErrnoException = (error) => error instanceof Error && typeof error.code === 'string';
+/**
+ * Format a friendly error message that surfaces the actual binary name when
+ * spawn fails with ENOENT (e.g. `claude CLI not found in PATH`).
+ */
+const formatStartError = (error, command) => {
+    if (isErrnoException(error) && error.code === 'ENOENT' && command) {
+        return `${command} CLI not found in PATH`;
+    }
+    if (error instanceof Error)
+        return error.message;
+    return String(error);
+};
+/**
+ * Translate an early-exit terminal state to a human-friendly error string.
+ *
+ * Two cases land here:
+ *   - exit 127 (POSIX) / 9009 (Windows cmd.exe): shell saying "command not
+ *     found" — the most common real case when the configured CLI is missing,
+ *     because node-pty does NOT throw sync ENOENT for missing binaries; it
+ *     spawns successfully and the child dies via onExit.
+ *   - any other non-zero exit: surface the raw code so we don't lie about the
+ *     cause.
+ */
+export const formatEarlyExitError = (command, exitCode) => {
+    if (exitCode !== null && COMMAND_NOT_FOUND_EXIT_CODES.has(exitCode)) {
+        return `${command} CLI not found in PATH`;
+    }
+    return `${command} failed to start (exit ${exitCode ?? 'null'})`;
+};
+const getLaunchErrorCommand = (config) => {
+    if (config.presetAugmentationDisabled) {
+        const startupCommand = config.args?.at(-1);
+        const executable = startupCommand ? getStartupCommandExecutable(startupCommand) : null;
+        if (executable)
+            return executable;
+    }
+    return config.interactiveCommand ?? config.command;
+};
+/**
+ * Wraps `store.startAgent` so spawn failures never bubble up: callers always
+ * receive a structured result. The HTTP layer uses this to keep workspace
+ * creation green even when the orchestrator binary is missing.
+ */
+export const autostartOrchestrator = async (port, workspaceId, orchestratorId, hivePort) => {
+    return autostartAgent(port, workspaceId, orchestratorId, hivePort, {
+        missingConfigError: 'No orchestrator launch config available (set HIVE_ORCHESTRATOR_COMMAND or seed a role template)',
+    });
+};
+export const autostartAgent = async (port, workspaceId, agentId, hivePort, options) => {
+    const config = port.peekAgentLaunchConfig(workspaceId, agentId);
+    if (!config) {
+        return {
+            ok: false,
+            error: options.missingConfigError,
+            run_id: null,
+        };
+    }
+    try {
+        const run = await port.startAgent(workspaceId, agentId, { hivePort });
+        // node-pty often doesn't throw on missing binaries — it spawns then exits
+        // fast via onExit with a non-zero code. Poll briefly so we surface the
+        // failure synchronously in the response instead of returning a fake "ok".
+        //
+        // Loop condition is "until we hit a terminal state OR deadline". Earlier
+        // versions exited as soon as `status === 'running'`, which missed the case
+        // where bash prints `command not found` (status flips to running) and then
+        // exits 127 a few ms later. The tighter loop catches that path.
+        let exitCode = run.exitCode;
+        let status = run.status;
+        const deadline = Date.now() + SETTLE_WAIT_MS;
+        while (status !== 'exited' && status !== 'error' && Date.now() < deadline) {
+            await sleep(POLL_INTERVAL_MS);
+            try {
+                const live = port.getLiveRun(run.runId);
+                status = live.status;
+                exitCode = live.exitCode;
+            }
+            catch {
+                break;
+            }
+        }
+        if (status === 'error' || (status === 'exited' && (exitCode ?? 0) !== 0)) {
+            return {
+                ok: false,
+                error: formatEarlyExitError(getLaunchErrorCommand(config), exitCode),
+                run_id: run.runId,
+            };
+        }
+        return { ok: true, error: null, run_id: run.runId };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            error: formatStartError(error, getLaunchErrorCommand(config)),
+            run_id: null,
+        };
+    }
+};

package/dist/src/server/orchestrator-launch.d.ts

@@ -0,0 +1,24 @@
+import type { AgentLaunchConfigInput } from './agent-run-store.js';
+import type { SettingsStore } from './settings-store.js';
+interface ConfigurePort {
+    configureAgentLaunch: (workspaceId: string, agentId: string, input: AgentLaunchConfigInput) => void;
+    peekAgentLaunchConfig: (workspaceId: string, agentId: string) => AgentLaunchConfigInput | undefined;
+}
+/**
+ * Resolve the orchestrator's launch config in priority order:
+ * 1. Explicit startup command pasted by the user. It runs through their shell
+ *    so aliases/functions like `ccs --resume ...` can expand.
+ * 2. Explicit workspace-create command preset chosen by the user.
+ * 3. `HIVE_ORCHESTRATOR_COMMAND` env var (with optional `HIVE_ORCHESTRATOR_ARGS_JSON`).
+ *    Tests use this to inject a dummy CLI like `bash -c 'echo queen up; sleep 60'`
+ *    so autostart can run end-to-end without depending on a real `claude` binary.
+ * 4. The seeded `orchestrator` role template (defaults to `claude`).
+ * Returns `undefined` when neither source has a usable command.
+ */
+export declare const resolveOrchestratorLaunchConfig: (settings: SettingsStore, commandPresetId?: string | null, startupCommand?: string | null) => AgentLaunchConfigInput | undefined;
+/**
+ * Idempotent: only seeds when no existing launch config is present for the
+ * orchestrator (prevents stomping on user-customized configs across restarts).
+ */
+export declare const seedOrchestratorLaunchConfig: (port: ConfigurePort, settings: SettingsStore, workspaceId: string, commandPresetId?: string | null, startupCommand?: string | null) => void;
+export {};

package/dist/src/server/orchestrator-launch.js

@@ -0,0 +1,71 @@
+import { resolveCommandPresetLaunchConfig, resolveStartupCommandLaunchConfig, } from './agent-launch-resolver.js';
+import { getOrchestratorId } from './workspace-store-support.js';
+const parseArgsEnv = (raw) => {
+    if (raw === undefined)
+        return undefined;
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return [];
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (Array.isArray(parsed) && parsed.every((item) => typeof item === 'string'))
+            return parsed;
+    }
+    catch {
+        return trimmed.split(/\s+/);
+    }
+    return undefined;
+};
+/**
+ * Resolve the orchestrator's launch config in priority order:
+ * 1. Explicit startup command pasted by the user. It runs through their shell
+ *    so aliases/functions like `ccs --resume ...` can expand.
+ * 2. Explicit workspace-create command preset chosen by the user.
+ * 3. `HIVE_ORCHESTRATOR_COMMAND` env var (with optional `HIVE_ORCHESTRATOR_ARGS_JSON`).
+ *    Tests use this to inject a dummy CLI like `bash -c 'echo queen up; sleep 60'`
+ *    so autostart can run end-to-end without depending on a real `claude` binary.
+ * 4. The seeded `orchestrator` role template (defaults to `claude`).
+ * Returns `undefined` when neither source has a usable command.
+ */
+export const resolveOrchestratorLaunchConfig = (settings, commandPresetId = null, startupCommand = null) => {
+    const trimmedStartupCommand = startupCommand?.trim();
+    if (trimmedStartupCommand) {
+        return resolveStartupCommandLaunchConfig(settings, trimmedStartupCommand, commandPresetId);
+    }
+    if (commandPresetId) {
+        return resolveCommandPresetLaunchConfig(settings, commandPresetId);
+    }
+    const envCommand = process.env.HIVE_ORCHESTRATOR_COMMAND;
+    if (envCommand) {
+        return {
+            command: envCommand,
+            args: parseArgsEnv(process.env.HIVE_ORCHESTRATOR_ARGS_JSON) ?? [],
+            commandPresetId: null,
+        };
+    }
+    const template = settings.listRoleTemplates().find((entry) => entry.roleType === 'orchestrator');
+    if (!template)
+        return undefined;
+    // Intentionally NOT binding to the `claude` command preset here: the preset
+    // also wires session-id capture which can claim alice/bob workers' session
+    // ids in tests / multi-agent setups. Users who want resume + yolo args can
+    // re-configure via POST /api/workspaces/:wsId/agents/:agentId/config.
+    return {
+        command: template.defaultCommand,
+        args: template.defaultArgs,
+        commandPresetId: null,
+    };
+};
+/**
+ * Idempotent: only seeds when no existing launch config is present for the
+ * orchestrator (prevents stomping on user-customized configs across restarts).
+ */
+export const seedOrchestratorLaunchConfig = (port, settings, workspaceId, commandPresetId = null, startupCommand = null) => {
+    const orchestratorId = getOrchestratorId(workspaceId);
+    if (port.peekAgentLaunchConfig(workspaceId, orchestratorId))
+        return;
+    const config = resolveOrchestratorLaunchConfig(settings, commandPresetId, startupCommand);
+    if (!config)
+        return;
+    port.configureAgentLaunch(workspaceId, orchestratorId, config);
+};

package/dist/src/server/package-version.d.ts

@@ -0,0 +1,17 @@
+export declare const PACKAGE_NAME = "hivehq";
+/**
+ * Canonical argv for the upgrade command. Sharing one source between the
+ * server's install hint (`version-service.ts`) and the CLI upgrade path
+ * (`hive-update.ts`) keeps the two from drifting if the package name ever
+ * moves.
+ */
+export declare const INSTALL_COMMAND_ARGS: readonly ["install", "-g", "hivehq@latest"];
+export declare const INSTALL_COMMAND_DISPLAY: string;
+/**
+ * Windows ships npm as `npm.cmd` (a batch shim); Node's `child_process.spawn`
+ * will not resolve `.cmd` without `shell: true` or an explicit suffix, so the
+ * default `'npm'` produces ENOENT on Windows. Use this helper any time you
+ * spawn npm directly.
+ */
+export declare const getNpmCommand: (platform?: NodeJS.Platform) => string;
+export declare const readPackageVersion: () => string;

package/dist/src/server/package-version.js

@@ -0,0 +1,32 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+export const PACKAGE_NAME = 'hivehq';
+/**
+ * Canonical argv for the upgrade command. Sharing one source between the
+ * server's install hint (`version-service.ts`) and the CLI upgrade path
+ * (`hive-update.ts`) keeps the two from drifting if the package name ever
+ * moves.
+ */
+export const INSTALL_COMMAND_ARGS = ['install', '-g', `${PACKAGE_NAME}@latest`];
+export const INSTALL_COMMAND_DISPLAY = `npm ${INSTALL_COMMAND_ARGS.join(' ')}`;
+/**
+ * Windows ships npm as `npm.cmd` (a batch shim); Node's `child_process.spawn`
+ * will not resolve `.cmd` without `shell: true` or an explicit suffix, so the
+ * default `'npm'` produces ENOENT on Windows. Use this helper any time you
+ * spawn npm directly.
+ */
+export const getNpmCommand = (platform = process.platform) => platform === 'win32' ? 'npm.cmd' : 'npm';
+export const readPackageVersion = () => {
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for (let depth = 0; depth < 8; depth += 1) {
+        const candidate = join(dir, 'package.json');
+        if (existsSync(candidate)) {
+            const parsed = JSON.parse(readFileSync(candidate, 'utf8'));
+            if (typeof parsed.version === 'string')
+                return parsed.version;
+        }
+        dir = dirname(dir);
+    }
+    return 'unknown';
+};

package/dist/src/server/path-canonicalization.d.ts

@@ -0,0 +1,3 @@
+export declare const realpathNative: (path: string) => string;
+export declare const normalizeFilesystemIdentity: (path: string, platform?: NodeJS.Platform) => string;
+export declare const sameFilesystemPath: (left: string, right: string, platform?: NodeJS.Platform) => boolean;

package/dist/src/server/path-canonicalization.js

@@ -0,0 +1,29 @@
+import { realpathSync } from 'node:fs';
+import { posix, resolve, win32 } from 'node:path';
+export const realpathNative = (path) => {
+    try {
+        return realpathSync.native(path);
+    }
+    catch (error) {
+        if (error?.code === 'ENOSYS')
+            return realpathSync(path);
+        throw error;
+    }
+};
+export const normalizeFilesystemIdentity = (path, platform = process.platform) => {
+    const resolveForPlatform = platform === 'win32' ? win32.resolve : posix.resolve;
+    let resolved;
+    if (platform === process.platform) {
+        try {
+            resolved = realpathNative(path);
+        }
+        catch {
+            resolved = resolve(path);
+        }
+    }
+    else {
+        resolved = resolveForPlatform(path);
+    }
+    return platform === 'win32' ? resolved.toLowerCase() : resolved;
+};
+export const sameFilesystemPath = (left, right, platform = process.platform) => normalizeFilesystemIdentity(left, platform) === normalizeFilesystemIdentity(right, platform);

package/dist/src/server/platform-path.d.ts

@@ -0,0 +1,4 @@
+export declare const expandHomePath: (path: string) => string;
+export declare const arePathsEqual: (left: string, right: string, platform?: NodeJS.Platform) => boolean;
+export declare const containsPathMarker: (haystack: string, marker: string, platform?: NodeJS.Platform) => boolean;
+export declare const indexOfPathMarker: (haystack: string, marker: string, platform?: NodeJS.Platform) => number;

package/dist/src/server/platform-path.js

@@ -0,0 +1,26 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const toForwardSlashes = (path) => path.replace(/\\/g, '/');
+const normalizeForWin32 = (path) => toForwardSlashes(path).toLowerCase();
+export const expandHomePath = (path) => {
+    if (path === '~')
+        return homedir();
+    const match = /^~[\\/](.*)$/u.exec(path);
+    if (!match)
+        return path;
+    const rest = match[1] ?? '';
+    if (!rest)
+        return homedir();
+    return join(homedir(), ...rest.split(/[\\/]+/u).filter(Boolean));
+};
+export const arePathsEqual = (left, right, platform = process.platform) => {
+    if (platform === 'win32')
+        return normalizeForWin32(left) === normalizeForWin32(right);
+    return left === right;
+};
+export const containsPathMarker = (haystack, marker, platform = process.platform) => indexOfPathMarker(haystack, marker, platform) !== -1;
+export const indexOfPathMarker = (haystack, marker, platform = process.platform) => {
+    if (platform === 'win32')
+        return normalizeForWin32(haystack).indexOf(normalizeForWin32(marker));
+    return haystack.indexOf(marker);
+};

package/dist/src/server/post-start-input-writer.d.ts

@@ -0,0 +1,6 @@
+import type { AgentManager } from './agent-manager.js';
+export declare const toBracketedPasteSubmission: (text: string) => string;
+export declare const isInteractiveAgentCommand: (command: string) => boolean;
+export declare const hasInteractivePromptReady: (output: string, command?: string) => boolean;
+export declare const hasBracketedPasteAcknowledgement: (output: string, baselineLength: number) => boolean;
+export declare const createPostStartInputWriter: (agentManager: AgentManager, command: string) => ((runId: string, text: string) => Promise<void>);

package/dist/src/server/post-start-input-writer.js

@@ -0,0 +1,242 @@
+import { normalizeExecutableToken } from './startup-command-parser.js';
+const INTERACTIVE_COMMANDS = new Set(['claude', 'codex', 'gemini', 'hermes', 'opencode']);
+const READY_CHECK_INTERVAL_MS = 50;
+const READY_TIMEOUT_MS = 3000;
+const MIN_SUBMIT_AFTER_PASTE_DELAY_MS = 600;
+const MAX_SUBMIT_AFTER_PASTE_DELAY_MS = 1500;
+const PASTE_CHARS_PER_DELAY_MS = 4;
+const PASTE_ACK_CHECK_INTERVAL_MS = 50;
+const PASTE_ACK_SETTLE_DELAY_MS = 100;
+const CODEX_PASTE_ACK_SETTLE_DELAY_MS = 250;
+const PASTE_ACK_TIMEOUT_MS = 3000;
+// Codex can take several seconds to render "[Pasted Content ...]" on Windows
+// conpty for large bracketed-paste payloads. Keep Claude's shorter fallback,
+// but give Codex enough time to use the ack-gated path in normal operation.
+const CODEX_PASTE_ACK_TIMEOUT_MS = 10000;
+// Codex only emits "[Pasted Content ...]" for sufficiently large pastes. Short
+// Hive report/status/user-input payloads are usually rendered literally in the
+// input box, so waiting for an acknowledgement there degrades into the 10s
+// timeout before Enter is sent.
+const CODEX_PASTE_ACK_MIN_CHARS = 2000;
+const CODEX_SUBMIT_RETRY_DELAY_MS = 500;
+const COMMANDS_WITH_BRACKETED_PASTE = new Set(['claude', 'codex', 'hermes', 'opencode']);
+const COMMANDS_WAITING_FOR_PASTE_ACK = new Set(['claude', 'codex']);
+const BRACKETED_PASTE_END = '\u001b[201~';
+const PASTE_ACK_PATTERN = /(?:^|[\r\n])\s*(?:[❯›]\s*)?\[(?:Pasted text #\d+[^\]]*|Pasted Content [\d,]+ chars)\]/u;
+const PASTE_ACK_ONLY_DELTA_PATTERN = /^[\s\r\n]*(?:[❯›]\s*)?\[(?:Pasted text #\d+[^\]]*|Pasted Content [\d,]+ chars)\]\s*(?:[❯›]\s*)?$/u;
+const ESCAPE = String.fromCharCode(27);
+const BELL = String.fromCharCode(7);
+const TERMINAL_CONTROL_PATTERN = new RegExp(`${ESCAPE}\\[[0-?]*[ -/]*[@-~]|${ESCAPE}\\][^${BELL}${ESCAPE}]*(?:${BELL}|${ESCAPE}\\\\)`, 'gu');
+export const toBracketedPasteSubmission = (text) => `\u001b[200~${text}\u001b[201~`;
+const toError = (error) => (error instanceof Error ? error : new Error(String(error)));
+const createRunInactiveError = (runId) => new Error(`Run became inactive before input was submitted: ${runId}`);
+const getSubmitAfterPasteDelayMs = (text) => Math.min(MAX_SUBMIT_AFTER_PASTE_DELAY_MS, Math.max(MIN_SUBMIT_AFTER_PASTE_DELAY_MS, Math.ceil(text.length / PASTE_CHARS_PER_DELAY_MS)));
+export const isInteractiveAgentCommand = (command) => {
+    const brand = normalizeExecutableToken(command);
+    return brand !== null && INTERACTIVE_COMMANDS.has(brand);
+};
+const getCommandName = (command) => normalizeExecutableToken(command) ?? '';
+const hasGeminiPromptReady = (output) => /\bType your message\b/u.test(output);
+const getLastNonEmptyTerminalLine = (output) => {
+    const normalized = output.replace(/\r/g, '\n').replace(TERMINAL_CONTROL_PATTERN, '');
+    for (const line of normalized.split('\n').reverse()) {
+        if (line.trim().length > 0)
+            return line.trim();
+    }
+    return '';
+};
+const hasBarePromptLine = (output) => /^[❯›]$/u.test(getLastNonEmptyTerminalLine(output));
+const hasCodexChoicePrompt = (output, command) => getCommandName(command) === 'codex' && /^[❯›]\s+\S/u.test(getLastNonEmptyTerminalLine(output));
+export const hasInteractivePromptReady = (output, command = '') => {
+    const commandName = getCommandName(command);
+    return hasBarePromptLine(output) || (commandName === 'gemini' && hasGeminiPromptReady(output));
+};
+export const hasBracketedPasteAcknowledgement = (output, baselineLength) => {
+    const outputAfterPaste = output.slice(baselineLength);
+    const pasteEndIndex = outputAfterPaste.lastIndexOf(BRACKETED_PASTE_END);
+    const acknowledgementOutput = pasteEndIndex === -1
+        ? outputAfterPaste
+        : outputAfterPaste.slice(pasteEndIndex + BRACKETED_PASTE_END.length);
+    return PASTE_ACK_PATTERN.test(acknowledgementOutput);
+};
+const onlyPasteAcknowledgementWasAppended = (before, after) => after.startsWith(before) && PASTE_ACK_ONLY_DELTA_PATTERN.test(after.slice(before.length));
+const shouldWaitForPasteAck = (command, text) => {
+    const commandName = getCommandName(command);
+    if (commandName === 'codex')
+        return text.length >= CODEX_PASTE_ACK_MIN_CHARS;
+    return COMMANDS_WAITING_FOR_PASTE_ACK.has(commandName);
+};
+const retriesSubmit = (command) => getCommandName(command) === 'codex';
+const getPasteAckSettleDelayMs = (command) => getCommandName(command) === 'codex' ? CODEX_PASTE_ACK_SETTLE_DELAY_MS : PASTE_ACK_SETTLE_DELAY_MS;
+const getPasteAckTimeoutMs = (command) => getCommandName(command) === 'codex' ? CODEX_PASTE_ACK_TIMEOUT_MS : PASTE_ACK_TIMEOUT_MS;
+const usesBracketedPaste = (command) => COMMANDS_WITH_BRACKETED_PASTE.has(getCommandName(command));
+const canTimeoutBeforePromptReady = (command) => getCommandName(command) !== 'gemini';
+const isWritableRunStatus = (status) => status === undefined || status === 'starting' || status === 'running';
+const writeIfRunWritable = (agentManager, runId, text) => {
+    let run;
+    try {
+        run = agentManager.getRun(runId);
+    }
+    catch {
+        return false;
+    }
+    if (!isWritableRunStatus(run.status))
+        return false;
+    agentManager.writeInput(runId, text);
+    return true;
+};
+const submitPastedInteractiveInput = (agentManager, runId, text, baselineLength, waitForPasteAck, pasteAckSettleDelayMs, pasteAckTimeoutMs, retrySubmit, onDone, onError) => {
+    const pastedAt = Date.now();
+    const minDelay = getSubmitAfterPasteDelayMs(text);
+    let acknowledgedAt = null;
+    const getWritableOutput = () => {
+        try {
+            const run = agentManager.getRun(runId);
+            return isWritableRunStatus(run.status) ? run.output : null;
+        }
+        catch {
+            return null;
+        }
+    };
+    const getRunOutputState = () => {
+        try {
+            const run = agentManager.getRun(runId);
+            return { output: run.output, writable: isWritableRunStatus(run.status) };
+        }
+        catch {
+            return null;
+        }
+    };
+    const submit = (retryAfterSubmit) => {
+        try {
+            const outputBeforeSubmit = retryAfterSubmit ? getWritableOutput() : null;
+            if (!writeIfRunWritable(agentManager, runId, '\r')) {
+                onError(createRunInactiveError(runId));
+                return;
+            }
+            if (!retryAfterSubmit) {
+                onDone();
+                return;
+            }
+            setTimeout(() => {
+                try {
+                    const runAfterSubmit = getRunOutputState();
+                    if (runAfterSubmit === null) {
+                        onDone();
+                        return;
+                    }
+                    if (outputBeforeSubmit !== null &&
+                        hasBracketedPasteAcknowledgement(runAfterSubmit.output, baselineLength) &&
+                        onlyPasteAcknowledgementWasAppended(outputBeforeSubmit, runAfterSubmit.output)) {
+                        if (!runAfterSubmit.writable || !writeIfRunWritable(agentManager, runId, '\r')) {
+                            onError(createRunInactiveError(runId));
+                            return;
+                        }
+                    }
+                }
+                catch (error) {
+                    onError(toError(error));
+                    return;
+                }
+                onDone();
+            }, CODEX_SUBMIT_RETRY_DELAY_MS);
+        }
+        catch (error) {
+            // The PTY may have exited between paste and submit.
+            onError(toError(error));
+        }
+    };
+    const trySubmit = () => {
+        if (!waitForPasteAck) {
+            submit(false);
+            return;
+        }
+        const output = getWritableOutput();
+        if (output === null) {
+            onError(createRunInactiveError(runId));
+            return;
+        }
+        if (acknowledgedAt === null && hasBracketedPasteAcknowledgement(output, baselineLength)) {
+            acknowledgedAt = Date.now();
+        }
+        const elapsed = Date.now() - pastedAt;
+        const ackSettled = acknowledgedAt !== null && Date.now() - acknowledgedAt >= pasteAckSettleDelayMs;
+        const submitAfterAck = ackSettled && elapsed >= minDelay;
+        const submitAfterTimeout = elapsed >= pasteAckTimeoutMs;
+        if (submitAfterAck || submitAfterTimeout) {
+            submit(retrySubmit && submitAfterTimeout);
+            return;
+        }
+        setTimeout(trySubmit, PASTE_ACK_CHECK_INTERVAL_MS);
+    };
+    setTimeout(trySubmit, minDelay);
+};
+export const createPostStartInputWriter = (agentManager, command) => {
+    if (!isInteractiveAgentCommand(command)) {
+        return (runId, text) => {
+            // Synchronous write; an EPIPE/inactive failure still throws synchronously
+            // (before the promise is returned), preserving the dispatcher's contract.
+            if (!writeIfRunWritable(agentManager, runId, `${text}\r`)) {
+                throw createRunInactiveError(runId);
+            }
+            return Promise.resolve();
+        };
+    }
+    return (runId, text) => {
+        let resolveDone;
+        let rejectDone;
+        const rejectableDone = new Promise((resolve, reject) => {
+            resolveDone = resolve;
+            rejectDone = reject;
+        });
+        const startedAt = Date.now();
+        let isInitialAttempt = true;
+        const tryWrite = () => {
+            let output;
+            try {
+                const run = agentManager.getRun(runId);
+                output = isWritableRunStatus(run.status) ? run.output : null;
+            }
+            catch {
+                rejectDone(createRunInactiveError(runId));
+                return;
+            }
+            if (output === null) {
+                rejectDone(createRunInactiveError(runId));
+                return;
+            }
+            if (hasInteractivePromptReady(output, command) ||
+                (!hasCodexChoicePrompt(output, command) &&
+                    canTimeoutBeforePromptReady(command) &&
+                    Date.now() - startedAt >= READY_TIMEOUT_MS)) {
+                const baselineLength = output.length;
+                const input = usesBracketedPaste(command) ? toBracketedPasteSubmission(text) : text;
+                try {
+                    if (!writeIfRunWritable(agentManager, runId, input)) {
+                        rejectDone(createRunInactiveError(runId));
+                        return;
+                    }
+                }
+                catch (error) {
+                    if (isInitialAttempt)
+                        throw error;
+                    rejectDone(toError(error));
+                    return;
+                }
+                submitPastedInteractiveInput(agentManager, runId, text, baselineLength, shouldWaitForPasteAck(command, text), getPasteAckSettleDelayMs(command), getPasteAckTimeoutMs(command), retriesSubmit(command), resolveDone, rejectDone);
+                return;
+            }
+            setTimeout(tryWrite, READY_CHECK_INTERVAL_MS);
+        };
+        try {
+            // Called outside the Promise executor so an initial-attempt throw
+            // propagates synchronously to the caller (preserving the dispatcher's
+            // synchronous-throw contract) instead of becoming a rejection.
+            tryWrite();
+        }
+        finally {
+            isInitialAttempt = false;
+        }
+        return rejectableDone;
+    };
+};

package/dist/src/server/preset-launch-support.d.ts

@@ -0,0 +1,6 @@
+import type { AgentLaunchConfigInput } from './agent-run-store.js';
+import type { CommandPresetRecord } from './command-preset-store.js';
+import type { SessionCaptureSnapshot } from './session-capture.js';
+type BoundPreset = Pick<CommandPresetRecord, 'resumeArgsTemplate' | 'sessionIdCapture' | 'yoloArgsTemplate'> & Partial<Pick<CommandPresetRecord, 'command' | 'id'>>;
+export declare const withPresetResumeArgs: (config: AgentLaunchConfigInput, preset: BoundPreset | null | undefined, lastSessionId: string | undefined, cwd?: string, discriminator?: SessionCaptureSnapshot["discriminator"], onInvalidSessionId?: (sessionId: string) => void) => AgentLaunchConfigInput;
+export {};