@nocville/npc 0.0.0-stage → 0.2.0

package/dist/cjs/npcs/claude-code/state-machine.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventName = eventName;
+exports.claudeTransition = claudeTransition;
+exports.processHookEvent = processHookEvent;
+const activity_js_1 = require("../agent-common/activity.js");
+const hook_runner_js_1 = require("../agent-common/hook-runner.js");
+const session_js_1 = require("../agent-common/session.js");
+/** Resolve the event name from either the real or legacy field. */
+function eventName(event) {
+    return (0, hook_runner_js_1.hookEventName)(event);
+}
+const working = (activity, warn = false) => ({
+    state: 'WORKING',
+    activity,
+    status: warn ? 'warning' : 'healthy',
+    mood: warn ? 'concerned' : 'happy',
+});
+const waiting = (activity) => ({
+    state: 'WAITING',
+    activity,
+    status: 'warning',
+    mood: 'concerned',
+});
+const idle = (activity) => ({
+    state: 'IDLE',
+    activity,
+    status: 'healthy',
+    mood: 'idle',
+});
+/** Notification types that mean "the human needs to act". */
+const WAITING_NOTIFICATIONS = new Set([
+    'permission_prompt',
+    'elicitation_dialog',
+    'elicitation_url_dialog',
+    'agent_needs_input',
+]);
+/**
+ * Map one Claude Code hook event to a phase + activity line.
+ * Event names / payload fields per code.claude.com/docs/en/hooks.
+ * Prompt text is never read (privacy); tool inputs are summarized, not echoed.
+ */
+function claudeTransition(event, prev) {
+    const name = eventName(event);
+    const cwd = (typeof event.cwd === 'string' && event.cwd) || prev?.projectDir;
+    const keep = prev?.state ?? 'IDLE';
+    switch (name) {
+        case 'SessionStart':
+            return idle('Ready for a task');
+        case 'UserPromptSubmit':
+            return working(activity_js_1.THINKING);
+        case 'PreToolUse': {
+            const activity = (0, activity_js_1.describeToolUse)(event.tool_name, event.tool_input, cwd);
+            if ((0, activity_js_1.isQuestionTool)(event.tool_name))
+                return waiting(activity);
+            return working(activity);
+        }
+        case 'PostToolUse':
+        case 'PostToolBatch':
+            // Tool finished — still working; keep showing the same activity.
+            return { ...working(undefined), quiet: prev?.state === 'WORKING' };
+        case 'PostToolUseFailure':
+            return working((0, activity_js_1.failureText)(event.tool_name), true);
+        case 'PermissionRequest': {
+            const what = event.tool_name ? (0, activity_js_1.describeToolUse)(event.tool_name, event.tool_input, cwd) : '';
+            return waiting(what ? `Needs your approval: ${what}` : 'Needs your approval');
+        }
+        case 'Notification': {
+            const type = typeof event.notification_type === 'string' ? event.notification_type : '';
+            if (type === 'idle_prompt')
+                return idle('Done — waiting for next task');
+            if (type === 'permission_prompt')
+                return waiting('Needs your approval');
+            if (WAITING_NOTIFICATIONS.has(type) || !type)
+                return waiting('Waiting for you');
+            // auth_success, agent_completed, quota_* … → informational only.
+            return {
+                state: keep,
+                status: prev?.status ?? 'healthy',
+                mood: prev?.mood ?? 'idle',
+                quiet: true,
+            };
+        }
+        case 'Stop':
+            return idle('Done — waiting for next task');
+        case 'StopFailure':
+            return { ...idle('Stopped with an error'), status: 'warning', mood: 'concerned' };
+        case 'SubagentStart':
+            return working('Delegating to a subagent');
+        case 'SubagentStop':
+            return working('Subagent finished');
+        case 'PreCompact':
+            return working('Compacting context');
+        case 'SessionEnd':
+            return {
+                state: 'IDLE',
+                activity: 'Session ended',
+                status: 'unknown',
+                mood: 'idle',
+                offline: true,
+            };
+        default:
+            return {
+                state: keep,
+                status: prev?.status ?? 'healthy',
+                mood: prev?.mood ?? 'idle',
+                quiet: true,
+            };
+    }
+}
+/**
+ * Derive the NPC status output from a hook event (state + presentation).
+ * Kept for library consumers; the hook runner uses `claudeTransition` directly.
+ */
+function processHookEvent(event, currentState) {
+    const t = claudeTransition(event, currentState);
+    const { subStatus, behavior } = (0, session_js_1.phasePresentation)(t.state, t.offline);
+    return {
+        state: t.state,
+        output: {
+            status: t.status,
+            mood: t.mood,
+            message: t.activity ?? currentState?.activity?.[0] ?? '',
+            subStatus,
+            behavior,
+            offline: t.offline,
+        },
+    };
+}
+//# sourceMappingURL=state-machine.js.map

package/dist/cjs/npcs/codex/defaults.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CODEX_DEFAULTS = void 0;
+exports.codexHome = codexHome;
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+exports.CODEX_DEFAULTS = {
+    /** Hook-mode per-session state (shared with the watcher to avoid double pushes). */
+    stateDir: (0, node_path_1.join)((0, node_os_1.tmpdir)(), 'nocville-codex'),
+    stateFileMaxAge: 24 * 60 * 60 * 1000,
+    /** Watchdog-backed sessions become unknown after three minutes without a heartbeat. */
+    heartbeatSeconds: 90,
+    minPushGapMs: 1500,
+    hookTimeoutSeconds: 10,
+    /** Watcher: Codex session rollout logs. */
+    sessionsDir: (0, node_path_1.join)(process.env['CODEX_HOME'] ?? (0, node_path_1.join)((0, node_os_1.homedir)(), '.codex'), 'sessions'),
+    /** Watcher: poll interval for new sessions / appended lines. */
+    pollMs: 1000,
+    /**
+     * Watcher: a session whose rollout file hasn't grown for this long is treated
+     * as ended (offline push). Matches Codex's own 30-minute idle SessionEnd.
+     */
+    idleTimeoutMs: 30 * 60 * 1000,
+    /** Watcher: bytes read from the end of an already-active rollout on discovery. */
+    initialTailBytes: 256 * 1024,
+    /** Watcher: max bytes read per tick per session before skipping ahead to the tail. */
+    maxReadBytes: 8 * 1024 * 1024,
+};
+function codexHome() {
+    return process.env['CODEX_HOME'] ?? (0, node_path_1.join)((0, node_os_1.homedir)(), '.codex');
+}
+//# sourceMappingURL=defaults.js.map

package/dist/cjs/npcs/codex/hook-handler.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CODEX_HOOK_SPEC = exports.CODEX_ADAPTER = void 0;
+exports.codexServiceId = codexServiceId;
+exports.codexTransition = codexTransition;
+exports.handleCodexHookEvent = handleCodexHookEvent;
+const activity_js_1 = require("../agent-common/activity.js");
+const hook_runner_js_1 = require("../agent-common/hook-runner.js");
+const session_js_1 = require("../agent-common/session.js");
+const defaults_js_1 = require("./defaults.js");
+exports.CODEX_ADAPTER = {
+    command: 'codex',
+    label: 'Codex',
+    family: 'codex',
+    stateDir: defaults_js_1.CODEX_DEFAULTS.stateDir,
+    heartbeatSeconds: defaults_js_1.CODEX_DEFAULTS.heartbeatSeconds,
+    processNames: ['codex'],
+};
+/**
+ * Codex session ids are UUIDv7 (time-ordered): the leading chars are shared by
+ * sessions started close together, so key the serviceId on the random tail.
+ */
+function codexServiceId(sessionId, cwd) {
+    const hex = sessionId.replace(/[^A-Za-z0-9]/g, '');
+    return (0, session_js_1.sanitizeServiceId)(`codex-${(0, session_js_1.projectNameOf)(cwd)}-${hex.slice(-8) || 'session'}`);
+}
+const working = (activity, warn = false) => ({
+    state: 'WORKING',
+    activity,
+    status: warn ? 'warning' : 'healthy',
+    mood: warn ? 'concerned' : 'happy',
+});
+const waiting = (activity) => ({
+    state: 'WAITING',
+    activity,
+    status: 'warning',
+    mood: 'concerned',
+});
+const idle = (activity) => ({
+    state: 'IDLE',
+    activity,
+    status: 'healthy',
+    mood: 'idle',
+});
+/**
+ * Map one Codex hook event to a phase + activity line. Events and payload
+ * fields per the Codex hooks reference (developers.openai.com/codex/hooks):
+ * SessionStart, SessionEnd, UserPromptSubmit, PreToolUse, PostToolUse,
+ * PermissionRequest, Stop, Interrupt, PreCompact, PostCompact, SubagentStart,
+ * SubagentStop. Bash/apply_patch carry `tool_input.command`.
+ */
+function codexTransition(event, prev) {
+    const name = (0, hook_runner_js_1.hookEventName)(event);
+    const cwd = (typeof event.cwd === 'string' && event.cwd) || prev?.projectDir;
+    const keep = prev?.state ?? 'IDLE';
+    switch (name) {
+        case 'SessionStart':
+            return idle('Ready for a task');
+        case 'UserPromptSubmit':
+            return working(activity_js_1.THINKING);
+        case 'PreToolUse': {
+            const activity = (0, activity_js_1.describeToolUse)(event.tool_name, event.tool_input, cwd);
+            return (0, activity_js_1.isQuestionTool)(event.tool_name) ? waiting(activity) : working(activity);
+        }
+        case 'PostToolUse':
+        case 'PostCompact':
+            return { ...working(undefined), quiet: prev?.state === 'WORKING' };
+        case 'PostToolUseFailure':
+            return working((0, activity_js_1.failureText)(event.tool_name), true);
+        case 'PermissionRequest': {
+            const what = event.tool_name ? (0, activity_js_1.describeToolUse)(event.tool_name, event.tool_input, cwd) : '';
+            return waiting(what ? `Needs your approval: ${what}` : 'Needs your approval');
+        }
+        case 'Stop':
+            return idle('Done — waiting for next task');
+        case 'Interrupt':
+            return idle('Interrupted — waiting for you');
+        case 'PreCompact':
+            return working('Compacting context');
+        case 'SubagentStart':
+            return working('Delegating to a subagent');
+        case 'SubagentStop':
+            return working('Subagent finished');
+        case 'SessionEnd':
+            return {
+                state: 'IDLE',
+                activity: 'Session ended',
+                status: 'unknown',
+                mood: 'idle',
+                offline: true,
+            };
+        default:
+            return {
+                state: keep,
+                status: prev?.status ?? 'healthy',
+                mood: prev?.mood ?? 'idle',
+                quiet: true,
+            };
+    }
+}
+exports.CODEX_HOOK_SPEC = {
+    adapter: exports.CODEX_ADAPTER,
+    serviceIdFor: codexServiceId,
+    transition: codexTransition,
+};
+/**
+ * Handle a single Codex hook event (stdin JSON unless `rawInput` is given).
+ * In-process push by default; the CLI passes `mode: 'detach'`. Never throws.
+ */
+async function handleCodexHookEvent(config, rawInput, opts = {}) {
+    await (0, hook_runner_js_1.runAgentHook)(exports.CODEX_HOOK_SPEC, config, rawInput ?? (0, hook_runner_js_1.readStdin)(), {
+        minPushGapMs: defaults_js_1.CODEX_DEFAULTS.minPushGapMs,
+        ...opts,
+    });
+}
+//# sourceMappingURL=hook-handler.js.map

package/dist/cjs/npcs/codex/index.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodexWatcher = exports.describeExecScript = exports.parseRolloutLine = exports.CODEX_HOOK_EVENTS = exports.installCodexHooksInto = exports.uninstallCodexHooks = exports.setupCodexHooks = exports.handleCodexHookEvent = exports.codexServiceId = exports.codexTransition = exports.CODEX_ADAPTER = exports.CODEX_DEFAULTS = void 0;
+exports.handleCodexCommand = handleCodexCommand;
+const config_js_1 = require("../../core/config.js");
+const hook_runner_js_1 = require("../agent-common/hook-runner.js");
+const watchdog_js_1 = require("../agent-common/watchdog.js");
+const session_js_1 = require("../agent-common/session.js");
+const defaults_js_1 = require("./defaults.js");
+const hook_handler_js_1 = require("./hook-handler.js");
+const setup_js_1 = require("./setup.js");
+const watcher_js_1 = require("./watcher.js");
+var defaults_js_2 = require("./defaults.js");
+Object.defineProperty(exports, "CODEX_DEFAULTS", { enumerable: true, get: function () { return defaults_js_2.CODEX_DEFAULTS; } });
+var hook_handler_js_2 = require("./hook-handler.js");
+Object.defineProperty(exports, "CODEX_ADAPTER", { enumerable: true, get: function () { return hook_handler_js_2.CODEX_ADAPTER; } });
+Object.defineProperty(exports, "codexTransition", { enumerable: true, get: function () { return hook_handler_js_2.codexTransition; } });
+Object.defineProperty(exports, "codexServiceId", { enumerable: true, get: function () { return hook_handler_js_2.codexServiceId; } });
+Object.defineProperty(exports, "handleCodexHookEvent", { enumerable: true, get: function () { return hook_handler_js_2.handleCodexHookEvent; } });
+var setup_js_2 = require("./setup.js");
+Object.defineProperty(exports, "setupCodexHooks", { enumerable: true, get: function () { return setup_js_2.setupCodexHooks; } });
+Object.defineProperty(exports, "uninstallCodexHooks", { enumerable: true, get: function () { return setup_js_2.uninstallCodexHooks; } });
+Object.defineProperty(exports, "installCodexHooksInto", { enumerable: true, get: function () { return setup_js_2.installCodexHooksInto; } });
+Object.defineProperty(exports, "CODEX_HOOK_EVENTS", { enumerable: true, get: function () { return setup_js_2.CODEX_HOOK_EVENTS; } });
+var rollout_js_1 = require("./rollout.js");
+Object.defineProperty(exports, "parseRolloutLine", { enumerable: true, get: function () { return rollout_js_1.parseRolloutLine; } });
+Object.defineProperty(exports, "describeExecScript", { enumerable: true, get: function () { return rollout_js_1.describeExecScript; } });
+var watcher_js_2 = require("./watcher.js");
+Object.defineProperty(exports, "CodexWatcher", { enumerable: true, get: function () { return watcher_js_2.CodexWatcher; } });
+/**
+ * codex subcommands: setup | uninstall | hook | flush | watch | cleanup.
+ * `hook`/`flush` are invoked by Codex / ourselves and stay silent on stdout.
+ */
+async function handleCodexCommand(opts) {
+    const { subcommand, config, flags } = opts;
+    switch (subcommand) {
+        case 'setup': {
+            if (flags['uninstall']) {
+                (0, setup_js_1.uninstallCodexHooks)();
+                break;
+            }
+            const ok = (0, setup_js_1.setupCodexHooks)({
+                apiUrl: (0, config_js_1.stringFlag)(flags, 'api-url') ?? process.env['NOCVILLE_API_URL'],
+                apiKey: (0, config_js_1.stringFlag)(flags, 'api-key') ?? process.env['NOCVILLE_API_KEY'],
+                map: (0, config_js_1.stringFlag)(flags, 'map'),
+                cliPath: process.argv[1],
+            });
+            if (!ok)
+                process.exitCode = 1;
+            break;
+        }
+        case 'uninstall':
+            (0, setup_js_1.uninstallCodexHooks)();
+            break;
+        case 'hook':
+            await (0, hook_handler_js_1.handleCodexHookEvent)(config, (0, hook_runner_js_1.readStdin)(), { mode: 'detach' });
+            break;
+        case 'watchdog':
+            await (0, watchdog_js_1.runWatchdog)(hook_handler_js_1.CODEX_ADAPTER, config, opts.args?.[0]);
+            break;
+        case 'flush':
+            await (0, hook_runner_js_1.runFlushCommand)(hook_handler_js_1.CODEX_ADAPTER, config, opts.args?.[0], (0, config_js_1.numberFlag)(flags, 'delay'), flags['stats'] === true);
+            break;
+        case 'watch': {
+            console.error('codex watch is a fallback for Codex builds without hooks; prefer `nocville-npc codex setup`.');
+            if (!config.apiKey) {
+                console.error('Error: no API key — run `nocville-npc init --api-key=<key>` or pass --api-key');
+                process.exitCode = 1;
+                return;
+            }
+            const idleMin = (0, config_js_1.numberFlag)(flags, 'idle-timeout');
+            const watcher = new watcher_js_1.CodexWatcher(config, {
+                sessionsDir: (0, config_js_1.stringFlag)(flags, 'sessions-dir'),
+                idleTimeoutMs: idleMin !== undefined ? idleMin * 60_000 : undefined,
+                includeExec: (0, config_js_1.boolFlag)(flags, 'include-exec') ?? false,
+                pollMs: (0, config_js_1.numberFlag)(flags, 'poll-interval'),
+            });
+            await watcher.start();
+            break;
+        }
+        case 'cleanup': {
+            const removed = await (0, session_js_1.cleanupSessionStates)(defaults_js_1.CODEX_DEFAULTS.stateDir, defaults_js_1.CODEX_DEFAULTS.stateFileMaxAge);
+            console.log(`Cleanup complete: ${removed} stale file(s) removed`);
+            break;
+        }
+        default:
+            console.error(`Unknown codex subcommand: ${subcommand}`);
+            console.error('Available subcommands: setup, uninstall, watch, hook, cleanup');
+            process.exitCode = 1;
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/cjs/npcs/codex/rollout.js

@@ -0,0 +1,246 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeExecScript = describeExecScript;
+exports.parseRolloutLine = parseRolloutLine;
+// Unsupported, best-effort fallback: Codex rollout logs are an internal format. Prefer hooks.
+const activity_js_1 = require("../agent-common/activity.js");
+const isObj = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+const s = (v) => (typeof v === 'string' && v ? v : undefined);
+function stripFileUrl(p) {
+    return p.replace(/^file:\/\//, '');
+}
+/** Pull a JS/JSON string property (`cmd:"…"` / `"cmd": "…"`) out of a script. */
+function scriptString(script, key) {
+    const re = new RegExp(`["']?${key}["']?\\s*:\\s*"((?:[^"\\\\]|\\\\.)*)"`);
+    const m = script.match(re);
+    if (!m)
+        return undefined;
+    try {
+        return JSON.parse(`"${m[1]}"`);
+    }
+    catch {
+        return m[1];
+    }
+}
+/** Tool helpers inside exec scripts that carry nothing worth showing. */
+const QUIET_SCRIPT_TOOLS = new Set(['write_stdin', 'wait', 'clock__curr_time', 'get_goal']);
+/**
+ * Describe a Codex "exec" code-mode script (`text(await tools.exec_command({cmd:"…"}))`)
+ * by its first tool call. Returns null for no-op helpers.
+ */
+function describeExecScript(script, cwd) {
+    const m = script.match(/tools\.([A-Za-z0-9_]+)\s*\(/);
+    if (!m)
+        return 'Running code';
+    const tool = m[1];
+    if (QUIET_SCRIPT_TOOLS.has(tool))
+        return null;
+    switch (tool) {
+        case 'exec_command': {
+            const cmd = scriptString(script, 'cmd') ?? scriptString(script, 'command');
+            const short = cmd ? (0, activity_js_1.shortCommand)(cmd) : '';
+            return short ? `Running ${short}` : 'Running a command';
+        }
+        case 'apply_patch': {
+            // The patch is embedded as a JS string with escaped newlines.
+            return (0, activity_js_1.editingFiles)((0, activity_js_1.patchFiles)(script.replace(/\\n/g, '\n')), cwd);
+        }
+        case 'view_image':
+            return 'Viewing an image';
+        case 'update_plan':
+            return 'Planning';
+        case 'web__run':
+        case 'web_search':
+            return 'Browsing the web';
+        case 'image_gen__imagegen':
+            return 'Generating an image';
+        case 'spawn_agent':
+            return 'Delegating to a subagent';
+        default:
+            return (0, activity_js_1.describeToolUse)(tool.includes('__') ? `mcp__${tool}` : tool, {}, cwd);
+    }
+}
+function parseArgs(raw) {
+    if (isObj(raw))
+        return raw;
+    if (typeof raw === 'string') {
+        try {
+            const parsed = JSON.parse(raw);
+            if (isObj(parsed))
+                return parsed;
+        }
+        catch {
+            return { input: raw };
+        }
+    }
+    return {};
+}
+/** Describe a `function_call` / `custom_tool_call` response item. */
+function describeCall(name, rawArgs, cwd) {
+    switch (name) {
+        case 'exec':
+            return typeof rawArgs === 'string' ? describeExecScript(rawArgs, cwd) : 'Running code';
+        case 'wait':
+        case 'write_stdin':
+        case 'list_agents':
+            return null;
+        case 'send_message':
+        case 'followup_task':
+            return 'Coordinating subagents';
+        case 'apply_patch': {
+            const args = parseArgs(rawArgs);
+            const patch = s(args['input']) ?? s(args['patch']) ?? (typeof rawArgs === 'string' ? rawArgs : '');
+            return (0, activity_js_1.editingFiles)((0, activity_js_1.patchFiles)(patch), cwd);
+        }
+        case 'shell':
+        case 'local_shell':
+        case 'exec_command':
+        case 'container.exec': {
+            const args = parseArgs(rawArgs);
+            return (0, activity_js_1.describeToolUse)('Bash', { command: args['command'] ?? args['cmd'] }, cwd);
+        }
+        default:
+            return (0, activity_js_1.describeToolUse)(name, parseArgs(rawArgs), cwd);
+    }
+}
+function approvalText(payload, cwd) {
+    const cmd = payload['command'];
+    if (cmd) {
+        const short = (0, activity_js_1.shortCommand)(cmd);
+        if (short)
+            return `Needs your approval: Running ${short}`;
+    }
+    const changes = payload['changes'];
+    if (isObj(changes)) {
+        return `Needs your approval: ${(0, activity_js_1.editingFiles)(Object.keys(changes).map(stripFileUrl), cwd)}`;
+    }
+    return 'Needs your approval';
+}
+function parseEventMsg(payload, cwd) {
+    const type = s(payload['type']) ?? '';
+    switch (type) {
+        case 'task_started':
+        case 'user_message':
+            return { kind: 'working', activity: activity_js_1.THINKING };
+        case 'task_complete':
+            return { kind: 'idle', activity: 'Done — waiting for next task' };
+        case 'turn_aborted':
+            return { kind: 'idle', activity: 'Interrupted — waiting for you' };
+        case 'exec_command_begin': {
+            const short = (0, activity_js_1.shortCommand)(payload['command']);
+            return { kind: 'working', activity: short ? `Running ${short}` : 'Running a command' };
+        }
+        case 'patch_apply_begin': {
+            const changes = isObj(payload['changes']) ? Object.keys(payload['changes']) : [];
+            return { kind: 'working', activity: (0, activity_js_1.editingFiles)(changes.map(stripFileUrl), cwd) };
+        }
+        case 'web_search_begin':
+            return { kind: 'working', activity: 'Searching the web' };
+        case 'request_user_input':
+            return { kind: 'waiting', activity: 'Has a question for you' };
+        case 'item_started': {
+            const item = isObj(payload['item']) ? payload['item'] : {};
+            const itemType = s(item['type']);
+            if (itemType === 'CommandExecution') {
+                const short = (0, activity_js_1.shortCommand)(item['command']);
+                return { kind: 'working', activity: short ? `Running ${short}` : 'Running a command' };
+            }
+            if (itemType === 'FileChange' && isObj(item['changes'])) {
+                return {
+                    kind: 'working',
+                    activity: (0, activity_js_1.editingFiles)(Object.keys(item['changes']).map(stripFileUrl), cwd),
+                };
+            }
+            return null;
+        }
+        case 'item_completed': {
+            // Newer builds log file edits only on completion; still the best signal.
+            const item = isObj(payload['item']) ? payload['item'] : {};
+            if (s(item['type']) === 'FileChange' && isObj(item['changes'])) {
+                return {
+                    kind: 'working',
+                    activity: (0, activity_js_1.editingFiles)(Object.keys(item['changes']).map(stripFileUrl), cwd),
+                };
+            }
+            return null;
+        }
+        default:
+            if (/approval_request$/.test(type) || type === 'request_permissions') {
+                return { kind: 'waiting', activity: approvalText(payload, cwd) };
+            }
+            return null;
+    }
+}
+function parseResponseItem(payload, cwd) {
+    const type = s(payload['type']) ?? '';
+    if (type === 'custom_tool_call' || type === 'function_call') {
+        const name = s(payload['name']) ?? '';
+        const activity = describeCall(name, payload['input'] ?? payload['arguments'], cwd);
+        return activity ? { kind: 'working', activity } : null;
+    }
+    if (type === 'local_shell_call') {
+        const action = isObj(payload['action']) ? payload['action'] : {};
+        const short = (0, activity_js_1.shortCommand)(action['command']);
+        return { kind: 'working', activity: short ? `Running ${short}` : 'Running a command' };
+    }
+    if (type === 'web_search_call')
+        return { kind: 'working', activity: 'Searching the web' };
+    return null;
+}
+/** Parse one rollout line into a signal (or null when it carries nothing useful). */
+function parseRolloutLine(line, cwd) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed[0] !== '{')
+        return null;
+    let rec;
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (!isObj(parsed))
+            return null;
+        rec = parsed;
+    }
+    catch {
+        return null;
+    }
+    const type = s(rec['type']) ?? '';
+    const payload = isObj(rec['payload']) ? rec['payload'] : {};
+    switch (type) {
+        case 'session_meta': {
+            const meta = isObj(payload['meta']) ? payload['meta'] : payload; // older nesting
+            const sessionId = s(meta['id']) ?? s(meta['session_id']);
+            if (!sessionId)
+                return null;
+            const source = meta['source'];
+            const threadSource = s(meta['thread_source']);
+            const subagent = (isObj(source) && 'subagent' in source) ||
+                threadSource === 'subagent' ||
+                threadSource === 'guardian_review';
+            const exec = source === 'exec' || s(meta['originator']) === 'codex_exec';
+            return { kind: 'meta', sessionId, cwd: s(meta['cwd']), subagent, exec };
+        }
+        case 'turn_context': {
+            const c = s(payload['cwd']);
+            return c ? { kind: 'cwd', cwd: c } : null;
+        }
+        case 'event_msg':
+            return parseEventMsg(payload, cwd);
+        case 'response_item':
+            return parseResponseItem(payload, cwd);
+        case 'function_call':
+        case 'custom_tool_call':
+        case 'local_shell_call':
+        case 'web_search_call':
+            // 2025-era rollouts wrote response items unwrapped.
+            return parseResponseItem(rec, cwd);
+        case '': {
+            // 2025-era first line: bare `{ id, timestamp, instructions }` session header.
+            const id = s(rec['id']);
+            return id && s(rec['timestamp'])
+                ? { kind: 'meta', sessionId: id, subagent: false, exec: false }
+                : null;
+        }
+        default:
+            return null;
+    }
+}
+//# sourceMappingURL=rollout.js.map