import { spawn } from "node:child_process"; import type { OpenCodeClient } from "@opencode/client"; import type { TaskDatabase } from "./db.js"; import type { TaskExecConfig } from "./types.js"; import { expandPath } from "./tasks.js"; import { normalizePermissions } from "./permissions.js"; import { connectService, isMissingSession } from "./service.js"; export function hasTaskRunTimedOut(startedAt: string, timeoutMs: number, now = new Date()): boolean { return now.getTime() - new Date(startedAt).getTime() > timeoutMs; } export function isProcessAlive(pid: number): boolean { try { process.kill(pid, 0); return true; } catch { return false; } } export function spawnWorker(schedulerPath: string, runId: string, isOneoff: boolean): number { const args = [schedulerPath, "--exec-task", runId]; if (isOneoff) args.push("--oneoff"); const child = spawn(process.execPath, args, { detached: true, stdio: "ignore" }); child.unref(); if (!child.pid) throw new Error("Failed to spawn worker process"); return child.pid; } export function parseModel(value?: string) { if (!value) return undefined; const match = value.match(/^([^/#]+)\/([^#]+)(?:#([^#]+))?$/); if (!match) throw new Error(`Invalid model reference: ${value}`); return { providerID: match[1], id: match[2], ...(match[3] ? { variant: match[3] } : {}) }; } const PERMISSION_FEEDBACK = "This unattended task cannot ask for permission. The request was rejected. Continue without this action."; const FORM_FEEDBACK = "This unattended task cannot ask the user questions. Continue without an answer and make reasonable assumptions."; export async function runPrompt(client: OpenCodeClient, sessionID: string, text: string, signal?: AbortSignal): Promise { const controller = new AbortController(); const stream = client.event.subscribe({ signal: signal ? AbortSignal.any([controller.signal, signal]) : controller.signal })[Symbol.asyncIterator](); const owned = new Map>([[sessionID, Promise.resolve(true)]]); const owns = (id: string): Promise => { const known = owned.get(id); if (known) return known; const result = id === "global" ? Promise.resolve(false) : client.session.get({ sessionID: id }, { signal }) .then((session) => session.parentID ? owns(session.parentID) : false).catch(() => false); owned.set(id, result); return result; }; const reject = async (request: { id: string; sessionID: string }) => { await client.permission.reply({ sessionID: request.sessionID, requestID: request.id, decision: "reject", message: PERMISSION_FEEDBACK }, { signal }) .catch((error) => { if (error.name !== "PermissionNotFoundError") throw error; }); }; const cancel = async (form: { id: string; sessionID: string }) => { await client.session.form.cancel({ sessionID: form.sessionID, formID: form.id, message: FORM_FEEDBACK }, { signal }) .catch((error) => { if (error.name !== "FormAlreadySettledError" && error.name !== "FormNotFoundError") throw error; }); }; let failure: string | undefined; let consumed: Promise | undefined; let settled = false; try { if ((await stream.next()).done) throw new Error("Event stream disconnected before prompting"); consumed = (async () => { while (!controller.signal.aborted) { const next = await stream.next(); if (next.done) { if (!controller.signal.aborted) throw new Error("Event stream disconnected during task execution"); return; } const event = next.value; if (event.type === "permission.asked" && await owns(event.data.sessionID)) await reject(event.data); if (event.type === "form.created" && await owns(event.data.form.sessionID)) await cancel(event.data.form); if (event.type === "session.execution.failed" && event.data.sessionID === sessionID) failure = event.data.error.message; } })(); // Attach a handler immediately: execution can fail while prompt admission is in flight. void consumed.catch(() => {}); signal?.throwIfAborted(); await client.session.prompt({ sessionID, text }, { signal }); const [permissions, forms] = await Promise.all([ client.permission.list({ sessionID }, { signal }), client.session.form.list({ sessionID }, { signal }), ]); await Promise.all([...permissions.map(reject), ...forms.map(cancel)]); await Promise.race([client.session.wait({ sessionID }, { signal }), consumed]); settled = true; const session = await client.session.get({ sessionID }, { signal }); if (session.outcome !== "succeeded") { // The wait response and SSE arrive on separate connections; history covers an event still in flight. if (session.outcome === "failed" && !failure) { const messages = await client.message.list({ sessionID, limit: 10, order: "desc" }, { signal }); const idle = messages.data.find((message) => message.type === "idle" && message.error); if (idle?.type === "idle") failure = idle.error?.message; } throw new Error(failure ?? `Session ${session.outcome ?? "did not complete"}`); } } catch (error) { if (!settled) await client.session.interrupt({ sessionID }, { signal: AbortSignal.timeout(10_000) }).catch(console.error); throw error; } finally { controller.abort(); void stream.return?.().catch(() => {}); await consumed?.catch((error) => { if (!controller.signal.aborted) throw error; }); } } export async function execTaskAndUpdateDb( task: TaskExecConfig, runId: string, isOneoff: boolean, db: TaskDatabase, connect: (signal?: AbortSignal) => Promise = connectService, ): Promise { let sessionId: string | undefined; let error: string | undefined; let timer: ReturnType | undefined; const controller = new AbortController(); const terminate = () => controller.abort(new Error("Task worker interrupted")); process.on("SIGTERM", terminate); process.on("SIGINT", terminate); if (task.timeoutMs) timer = setTimeout(() => controller.abort(new Error(`Task timed out after ${task.timeoutMs}ms`)), task.timeoutMs); try { const client = await connect(controller.signal); const options = { signal: controller.signal }; const model = parseModel(task.model); const permissions = task.permission === undefined ? undefined : normalizePermissions(task.permission); const mapping = task.sessionName ? db.getSessionMapping(task.sessionName) : undefined; if (mapping) { try { sessionId = (await client.session.get({ sessionID: mapping.sessionId }, options)).id; } catch (cause) { if (!isMissingSession(cause)) throw cause; } } if (!sessionId) { sessionId = (await client.session.create({ location: { directory: expandPath(task.cwd) }, title: task.sessionName ?? `${task.name} - ${new Date().toISOString()}`, agent: task.agent, model, permissions, metadata: { opencodeTasks: { task: task.name, runId, oneoff: isOneoff } }, }, options)).id; } else { await client.session.update({ sessionID: sessionId, permissions: permissions ?? [], metadata: { opencodeTasks: { task: task.name, runId, oneoff: isOneoff } } }, options); if (task.agent) await client.session.switchAgent({ sessionID: sessionId, agent: task.agent }, options); if (model) await client.session.switchModel({ sessionID: sessionId, model }, options); } if (isOneoff) db.setOneoffTaskSessionId(runId, sessionId); else db.setTaskRunSessionId(runId, sessionId); if (task.sessionName) db.upsertSessionMapping(task.sessionName, sessionId, task.name); await runPrompt(client, sessionId, task.prompt, controller.signal); } catch (cause) { error = controller.signal.aborted ? controller.signal.reason.message : cause instanceof Error ? cause.message : String(cause); } finally { process.off("SIGTERM", terminate); process.off("SIGINT", terminate); if (timer) clearTimeout(timer); } const extra = { sessionId, error: error?.slice(0, 4096) }; if (isOneoff) db.updateOneoffTaskStatus(runId, error ? "failed" : "completed", extra); else db.completeTaskRun(runId, error ? "failed" : "completed", extra); }