doer-agent 0.4.2 → 0.4.4

package/dist/agent-git-rpc.js

@@ -0,0 +1,299 @@
+import { spawn } from "node:child_process";
+import { StringCodec } from "nats";
+const gitRpcCodec = StringCodec();
+function runLocalCommand(command, args, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk;
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk;
+        });
+        child.once("error", reject);
+        child.once("close", (code) => {
+            resolve({ code: code ?? 1, stdout, stderr });
+        });
+    });
+}
+function sanitizeGitRef(value) {
+    if (typeof value !== "string" || !value.trim()) {
+        return null;
+    }
+    const trimmed = value.trim();
+    if (trimmed.startsWith("-") || /\s/.test(trimmed) || trimmed.includes("..") || trimmed.includes(":")) {
+        throw new Error(`Invalid git ref: ${trimmed}`);
+    }
+    return trimmed;
+}
+function sanitizeGitPathspec(value) {
+    if (typeof value !== "string") {
+        throw new Error("Invalid pathspec");
+    }
+    const trimmed = value.trim().replace(/\\/g, "/");
+    if (!trimmed || trimmed.startsWith("-") || trimmed.includes("\0")) {
+        throw new Error(`Invalid pathspec: ${trimmed}`);
+    }
+    return trimmed;
+}
+function normalizeGitRpcRequest(args) {
+    const requestId = typeof args.request.requestId === "string" ? args.request.requestId.trim() : "";
+    const responseSubject = typeof args.request.responseSubject === "string" ? args.request.responseSubject.trim() : "";
+    const requestAgentId = typeof args.request.agentId === "string" ? args.request.agentId.trim() : "";
+    const targetPath = typeof args.request.targetPath === "string" ? args.request.targetPath.trim() : "";
+    if (!requestId || !responseSubject || !requestAgentId || requestAgentId !== args.agentId || !targetPath) {
+        throw new Error("invalid git rpc request");
+    }
+    const format = args.request.format === "name-only" ||
+        args.request.format === "name-status" ||
+        args.request.format === "stat" ||
+        args.request.format === "numstat" ||
+        args.request.format === "raw"
+        ? args.request.format
+        : "patch";
+    const ignoreWhitespace = args.request.ignoreWhitespace === "at-eol" ||
+        args.request.ignoreWhitespace === "change" ||
+        args.request.ignoreWhitespace === "all"
+        ? args.request.ignoreWhitespace
+        : "none";
+    const diffAlgorithm = args.request.diffAlgorithm === "minimal" ||
+        args.request.diffAlgorithm === "patience" ||
+        args.request.diffAlgorithm === "histogram"
+        ? args.request.diffAlgorithm
+        : "default";
+    const contextRaw = Number(args.request.contextLines);
+    const contextLines = Number.isFinite(contextRaw) ? Math.max(0, Math.min(200, Math.trunc(contextRaw))) : null;
+    const pathspecs = Array.isArray(args.request.pathspecs) ? args.request.pathspecs.map((item) => sanitizeGitPathspec(item)) : [];
+    return {
+        requestId,
+        responseSubject,
+        targetPath,
+        base: sanitizeGitRef(args.request.base),
+        target: sanitizeGitRef(args.request.target),
+        mergeBase: args.request.mergeBase === true,
+        staged: args.request.staged === true,
+        format,
+        contextLines,
+        ignoreWhitespace,
+        diffAlgorithm,
+        findRenames: args.request.findRenames === true,
+        pathspecs,
+    };
+}
+function buildAgentGitDiffArgs(repoRootAbs, request) {
+    const args = ["-C", repoRootAbs, "diff", "--no-color"];
+    const displayParts = ["git", "diff", "--no-color"];
+    if (request.staged) {
+        args.push("--cached");
+        displayParts.push("--cached");
+    }
+    if (typeof request.contextLines === "number") {
+        args.push(`-U${request.contextLines}`);
+        displayParts.push(`-U${request.contextLines}`);
+    }
+    if (request.ignoreWhitespace === "at-eol") {
+        args.push("--ignore-space-at-eol");
+        displayParts.push("--ignore-space-at-eol");
+    }
+    else if (request.ignoreWhitespace === "change") {
+        args.push("--ignore-space-change");
+        displayParts.push("--ignore-space-change");
+    }
+    else if (request.ignoreWhitespace === "all") {
+        args.push("--ignore-all-space");
+        displayParts.push("--ignore-all-space");
+    }
+    if (request.diffAlgorithm !== "default") {
+        args.push(`--diff-algorithm=${request.diffAlgorithm}`);
+        displayParts.push(`--diff-algorithm=${request.diffAlgorithm}`);
+    }
+    if (request.findRenames) {
+        args.push("--find-renames");
+        displayParts.push("--find-renames");
+    }
+    if (request.format === "name-only") {
+        args.push("--name-only");
+        displayParts.push("--name-only");
+    }
+    else if (request.format === "name-status") {
+        args.push("--name-status");
+        displayParts.push("--name-status");
+    }
+    else if (request.format === "stat") {
+        args.push("--stat");
+        displayParts.push("--stat");
+    }
+    else if (request.format === "numstat") {
+        args.push("--numstat");
+        displayParts.push("--numstat");
+    }
+    else if (request.format === "raw") {
+        args.push("--raw");
+        displayParts.push("--raw");
+    }
+    if (request.mergeBase) {
+        if (!request.base || !request.target) {
+            throw new Error("mergeBase mode requires both base and target");
+        }
+        const merged = `${request.base}...${request.target}`;
+        args.push(merged);
+        displayParts.push(merged);
+    }
+    else {
+        if (request.base) {
+            args.push(request.base);
+            displayParts.push(request.base);
+        }
+        if (request.target) {
+            args.push(request.target);
+            displayParts.push(request.target);
+        }
+    }
+    if (request.pathspecs.length > 0) {
+        args.push("--", ...request.pathspecs);
+        displayParts.push("--", ...request.pathspecs);
+    }
+    return { args, display: displayParts.join(" ") };
+}
+function buildUntrackedText(format, untrackedPaths) {
+    if (untrackedPaths.length === 0) {
+        return "";
+    }
+    if (format === "name-status" || format === "raw") {
+        return `${untrackedPaths.map((item) => `??\t${item}`).join("\n")}\n`;
+    }
+    if (format === "name-only") {
+        return `${untrackedPaths.join("\n")}\n`;
+    }
+    return `\n# Untracked files\n${untrackedPaths.join("\n")}\n`;
+}
+async function appendAgentLocalUntrackedDiff(repoRootAbs, request, baseOutput) {
+    const listArgs = ["-C", repoRootAbs, "ls-files", "--others", "--exclude-standard"];
+    if (request.pathspecs.length > 0) {
+        listArgs.push("--", ...request.pathspecs);
+    }
+    const listResult = await runLocalCommand("git", listArgs, repoRootAbs);
+    if (listResult.code !== 0) {
+        return { output: baseOutput, hasUntracked: false };
+    }
+    const untrackedPaths = listResult.stdout.split(/\r?\n/).map((item) => item.trim()).filter(Boolean);
+    if (untrackedPaths.length === 0) {
+        return { output: baseOutput, hasUntracked: false };
+    }
+    if (request.format !== "patch") {
+        return { output: `${baseOutput}${buildUntrackedText(request.format, untrackedPaths)}`, hasUntracked: true };
+    }
+    let output = baseOutput;
+    for (const relPath of untrackedPaths) {
+        const diffResult = await runLocalCommand("git", ["-C", repoRootAbs, "diff", "--no-color", "--no-index", "--", "/dev/null", relPath], repoRootAbs);
+        if (diffResult.code !== 0 && diffResult.code !== 1) {
+            throw new Error(diffResult.stderr.trim() || `Failed to render agent untracked diff: ${relPath}`);
+        }
+        if (diffResult.stdout) {
+            output += diffResult.stdout;
+            if (!output.endsWith("\n")) {
+                output += "\n";
+            }
+        }
+    }
+    return { output, hasUntracked: true };
+}
+function publishGitRpcResponse(args) {
+    args.nc.publish(args.responseSubject, gitRpcCodec.encode(JSON.stringify(args.payload)));
+}
+export async function handleGitRpcMessage(args) {
+    let requestId = "unknown";
+    let responseSubject = "";
+    try {
+        const payload = JSON.parse(gitRpcCodec.decode(args.msg.data));
+        const request = normalizeGitRpcRequest({ request: payload, agentId: args.agentId });
+        requestId = request.requestId;
+        responseSubject = request.responseSubject;
+        if (!request.targetPath.startsWith("/")) {
+            throw new Error("agent source requires an absolute directory path");
+        }
+        const topLevelResult = await runLocalCommand("git", ["-C", request.targetPath, "rev-parse", "--show-toplevel"], request.targetPath);
+        if (topLevelResult.code !== 0) {
+            publishGitRpcResponse({
+                nc: args.nc,
+                responseSubject,
+                payload: {
+                    requestId,
+                    ok: true,
+                    payload: {
+                        isGitRepo: false,
+                        mode: "git_diff",
+                        source: "agent",
+                        agent: { id: args.agentId, name: null },
+                        currentPath: request.targetPath,
+                        repoRoot: null,
+                        repoRelativePath: null,
+                        branch: null,
+                        gitDiff: {
+                            command: "git diff --no-color",
+                            format: "patch",
+                            output: "",
+                            outputTruncated: false,
+                        },
+                        message: "현재 경로가 Git 저장소가 아닙니다.",
+                    },
+                },
+            });
+            return;
+        }
+        const repoRootAbs = topLevelResult.stdout.trim();
+        const prefixResult = await runLocalCommand("git", ["-C", request.targetPath, "rev-parse", "--show-prefix"], request.targetPath);
+        const repoRelativePath = prefixResult.code === 0 ? (prefixResult.stdout.trim().replace(/\/$/, "") || ".") : ".";
+        const branchResult = await runLocalCommand("git", ["-C", repoRootAbs, "symbolic-ref", "--quiet", "--short", "HEAD"], repoRootAbs);
+        const detachedResult = branchResult.code === 0 ? null : await runLocalCommand("git", ["-C", repoRootAbs, "rev-parse", "--short", "HEAD"], repoRootAbs);
+        const branch = branchResult.code === 0 ? branchResult.stdout.trim() || null : detachedResult && detachedResult.code === 0 ? detachedResult.stdout.trim() || null : null;
+        const gitDiffArgs = buildAgentGitDiffArgs(repoRootAbs, request);
+        const gitDiffResult = await runLocalCommand("git", gitDiffArgs.args, repoRootAbs);
+        if (gitDiffResult.code !== 0) {
+            throw new Error(gitDiffResult.stderr.trim() || "Failed to run agent git diff");
+        }
+        const withUntracked = await appendAgentLocalUntrackedDiff(repoRootAbs, request, gitDiffResult.stdout);
+        publishGitRpcResponse({
+            nc: args.nc,
+            responseSubject,
+            payload: {
+                requestId,
+                ok: true,
+                payload: {
+                    isGitRepo: true,
+                    mode: "git_diff",
+                    source: "agent",
+                    agent: { id: args.agentId, name: null },
+                    currentPath: request.targetPath,
+                    repoRoot: repoRootAbs,
+                    repoRelativePath,
+                    branch,
+                    gitDiff: {
+                        command: withUntracked.hasUntracked ? `${gitDiffArgs.display} (+ untracked)` : gitDiffArgs.display,
+                        format: request.format,
+                        output: withUntracked.output,
+                        outputTruncated: false,
+                    },
+                },
+            },
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (responseSubject) {
+            publishGitRpcResponse({
+                nc: args.nc,
+                responseSubject,
+                payload: { requestId, ok: false, error: message },
+            });
+        }
+        args.onError(`git rpc failed requestId=${requestId} error=${message}`);
+    }
+}

package/dist/agent-jetstream.js

@@ -0,0 +1,120 @@
+import { AckPolicy, connect, DeliverPolicy, JSONCodec, RetentionPolicy, StorageType, } from "nats";
+export function normalizeNatsServers(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter((item) => typeof item === "string").map((v) => v.trim()).filter((v) => v.length > 0);
+}
+export function normalizeNatsToken(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    const auth = value;
+    const token = typeof auth.token === "string" ? auth.token.trim() : "";
+    return token.length > 0 ? token : null;
+}
+function formatNatsStatusData(value) {
+    if (value === null || value === undefined) {
+        return "null";
+    }
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        return String(value);
+    }
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+async function ensureJetStreamInfra(args) {
+    const streamInfo = await args.jsm.streams.info(args.stream).catch(() => null);
+    if (!streamInfo) {
+        await args.jsm.streams.add({
+            name: args.stream,
+            subjects: [args.subject],
+            storage: StorageType.File,
+            retention: RetentionPolicy.Limits,
+        });
+    }
+    if (args.durable) {
+        const consumerInfo = await args.jsm.consumers.info(args.stream, args.durable).catch(() => null);
+        if (!consumerInfo) {
+            await args.jsm.consumers.add(args.stream, {
+                durable_name: args.durable,
+                ack_policy: AckPolicy.Explicit,
+                deliver_policy: DeliverPolicy.All,
+                filter_subject: args.subject,
+                ack_wait: 30_000_000_000,
+            });
+        }
+    }
+}
+async function initJetStreamContext(args) {
+    const sanitized = args.sanitizeUserId(args.userId);
+    const stream = `DOER_AGENT_EVENTS_${sanitized}`;
+    const subject = `doer.agent.events.${sanitized}`;
+    const durable = `doer-agent-uploader-${sanitized}`;
+    const nc = await connect(args.token ? { servers: args.servers, token: args.token } : { servers: args.servers });
+    const jsm = await nc.jetstreamManager();
+    await ensureJetStreamInfra({ jsm, stream, subject, durable });
+    void (async () => {
+        try {
+            for await (const status of nc.status()) {
+                const statusType = typeof status.type === "string" ? status.type : "unknown";
+                if (statusType === "pingTimer") {
+                    continue;
+                }
+                const statusData = formatNatsStatusData(status.data);
+                args.onInfraError("nats status type=" + statusType + " data=" + statusData);
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            args.onInfraError(`nats status loop ended: ${message}`);
+        }
+    })();
+    return {
+        nc,
+        js: nc.jetstream(),
+        jsm,
+        codec: JSONCodec(),
+        subject,
+        stream,
+        durable,
+        servers: args.servers,
+    };
+}
+export async function connectBootstrapWithRetry(args) {
+    let attempt = 0;
+    while (true) {
+        attempt += 1;
+        try {
+            const natsBootstrap = await args.postJson(`${args.serverBaseUrl}/api/agent/nats`, {
+                userId: args.userId,
+                agentToken: args.agentToken,
+            });
+            const bootstrapRecord = natsBootstrap;
+            const natsServers = normalizeNatsServers(bootstrapRecord.servers);
+            if (natsServers.length === 0) {
+                throw new Error("No NATS servers configured by server");
+            }
+            const natsToken = normalizeNatsToken(bootstrapRecord.auth);
+            const jetstream = await initJetStreamContext({
+                userId: args.userId,
+                servers: natsServers,
+                token: natsToken,
+                sanitizeUserId: args.sanitizeUserId,
+                onInfraError: args.onInfraError,
+            });
+            args.onInfraError(`bootstrap ok servers=${natsServers.length} eventStream=${jetstream.stream} eventSubject=${jetstream.subject}`);
+            return { natsBootstrap, jetstream };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const retryMs = Math.min(30_000, 1000 * Math.max(1, attempt));
+            args.onError(`bootstrap failed: ${message} (retry in ${Math.floor(retryMs / 1000)}s, attempt=${attempt})`);
+            await args.sleep(retryMs);
+        }
+    }
+}

package/dist/agent-run-execution.js

@@ -0,0 +1,39 @@
+import path from "node:path";
+import { mkdir } from "node:fs/promises";
+export async function prepareCommandExecution(args) {
+    const shellPath = args.resolveShellPath();
+    const taskWorkspace = args.resolveTaskWorkspace(args.cwd);
+    const codexHome = args.resolveCodexHomePath();
+    await mkdir(codexHome, { recursive: true });
+    const codexAuth = await args.prepareCodexAuthBundle(args.codexAuthBundle);
+    const localAgentSettings = await args.readAgentSettingsConfig({ workspaceRoot: args.resolveWorkspaceRoot() });
+    const baseTaskEnvPatch = {
+        CODEX_HOME: codexHome,
+        DOER_USER_ID: args.userId,
+        DOER_AGENT_TASK_ID: args.taskId,
+        ...args.buildAgentSettingsEnvPatch(localAgentSettings),
+        ...args.runtimeEnvPatch,
+        ...(codexAuth?.envPatch ?? {}),
+        WORKSPACE: taskWorkspace,
+    };
+    const taskGitEnv = await args.prepareTaskGitEnv({
+        cwd: taskWorkspace,
+        baseEnvPatch: baseTaskEnvPatch,
+    });
+    const runtimeBinPath = path.join(args.agentProjectDir, "runtime/bin");
+    const taskPath = [runtimeBinPath, process.env.PATH || ""].filter(Boolean).join(path.delimiter);
+    return {
+        shellPath,
+        taskWorkspace,
+        taskPath,
+        env: {
+            ...process.env,
+            ...baseTaskEnvPatch,
+            ...taskGitEnv.envPatch,
+            PATH: taskPath,
+        },
+        taskGitMeta: taskGitEnv.meta ?? {},
+        codexAuthMeta: codexAuth?.meta ?? { codexAuthSynced: false },
+        codexAuthCleanup: codexAuth?.cleanup ?? (async () => { }),
+    };
+}

package/dist/agent-run-lifecycle.js

@@ -0,0 +1,67 @@
+export function createPendingRunSessionTracker(args) {
+    let closed = false;
+    let timer = null;
+    const stop = () => {
+        closed = true;
+        if (timer) {
+            clearInterval(timer);
+            timer = null;
+        }
+    };
+    const poll = async () => {
+        if (closed || args.task.sessionId) {
+            stop();
+            return;
+        }
+        const detected = await args.detectPendingRunSession().catch(() => null);
+        if (!detected) {
+            return;
+        }
+        await args.updateRunSessionMetadata(detected).catch(() => undefined);
+        if (args.task.sessionId) {
+            stop();
+        }
+    };
+    const start = () => {
+        if (closed || args.task.sessionId || timer) {
+            return;
+        }
+        timer = setInterval(() => {
+            void poll();
+        }, args.pollIntervalMs ?? 1000);
+    };
+    return { poll, start, stop };
+}
+export function attachManagedRunProcessLifecycle(args) {
+    args.child.once("error", (error) => {
+        args.stopPendingSessionPoll();
+        const message = error instanceof Error ? error.message : String(error);
+        args.task.status = "failed";
+        args.task.error = message;
+        args.task.finishedAt = args.formatTimestamp();
+        args.publishImmediateRunEvent({ nc: args.nc, userId: args.task.userId, task: args.task });
+        args.publishImmediateRunEvent({ nc: args.nc, userId: args.task.userId, task: args.task, type: "run.finished" });
+        void args.removeRunTask(args.task.id).catch(() => undefined);
+        void args.releaseRunStartSlot({ runId: args.task.id, sessionId: args.task.sessionId }).catch(() => undefined);
+        void args.codexAuthCleanup().catch(() => undefined);
+        args.writeRunStatus(args.task.id, `failed error=${message}`);
+    });
+    args.child.once("close", async (code, signal) => {
+        args.stopPendingSessionPoll();
+        const latest = await args.getStoredRun(args.task.id).catch(() => null);
+        if (latest?.cancelRequested) {
+            args.task.cancelRequested = true;
+        }
+        args.task.resultExitCode = typeof code === "number" ? code : null;
+        args.task.resultSignal = signal;
+        args.task.finishedAt = args.formatTimestamp();
+        args.task.status = args.task.cancelRequested ? "canceled" : (args.task.resultExitCode ?? 1) === 0 ? "completed" : "failed";
+        args.task.error = args.task.status === "failed" ? `Command exited with code ${args.task.resultExitCode ?? "null"}` : null;
+        args.publishImmediateRunEvent({ nc: args.nc, userId: args.task.userId, task: args.task });
+        args.publishImmediateRunEvent({ nc: args.nc, userId: args.task.userId, task: args.task, type: "run.finished" });
+        void args.removeRunTask(args.task.id).catch(() => undefined);
+        void args.releaseRunStartSlot({ runId: args.task.id, sessionId: args.task.sessionId }).catch(() => undefined);
+        void args.codexAuthCleanup().catch(() => undefined);
+        args.writeRunStatus(args.task.id, `completed status=${args.task.status} exitCode=${args.task.resultExitCode ?? "null"} signal=${args.task.resultSignal ?? "null"}`);
+    });
+}

package/dist/agent-run-rpc.js

@@ -0,0 +1,93 @@
+import { StringCodec } from "nats";
+const runRpcCodec = StringCodec();
+export function normalizeRunRpcRequest(args) {
+    const requestId = typeof args.request.requestId === "string" ? args.request.requestId.trim() : "";
+    if (!requestId) {
+        throw new Error("missing requestId");
+    }
+    const requestAgentId = typeof args.request.agentId === "string" ? args.request.agentId.trim() : "";
+    if (!requestAgentId || requestAgentId !== args.agentId) {
+        throw new Error("agent id mismatch");
+    }
+    const actionRaw = typeof args.request.action === "string" ? args.request.action.trim() : "";
+    const action = actionRaw === "cancel" || actionRaw === "get" || actionRaw === "list" ? actionRaw : "start";
+    const responseSubject = typeof args.request.responseSubject === "string" ? args.request.responseSubject.trim() : "";
+    if (!responseSubject) {
+        throw new Error("missing responseSubject");
+    }
+    const runId = typeof args.request.runId === "string" && args.request.runId.trim() ? args.request.runId.trim() : null;
+    const prompt = typeof args.request.prompt === "string" && args.request.prompt.trim() ? args.request.prompt.trim() : null;
+    const imagePaths = args.normalizeImagePaths(args.request.imagePaths);
+    const sessionId = typeof args.request.sessionId === "string" && args.request.sessionId.trim() ? args.request.sessionId.trim() : null;
+    const model = args.normalizeModel(args.request.model);
+    if (action === "start" && !prompt) {
+        throw new Error("missing prompt");
+    }
+    if ((action === "get" || action === "cancel") && !runId) {
+        throw new Error("missing runId");
+    }
+    const cwd = typeof args.request.cwd === "string" && args.request.cwd.trim() ? args.request.cwd.trim() : null;
+    const sinceSeqRaw = Number(args.request.sinceSeq);
+    const sinceSeq = Number.isInteger(sinceSeqRaw) && sinceSeqRaw >= 0 ? sinceSeqRaw : null;
+    const limitRaw = Number(args.request.limit);
+    const limit = Number.isFinite(limitRaw) ? Math.max(1, Math.min(Math.floor(limitRaw), 200)) : 50;
+    return {
+        requestId,
+        action,
+        runId,
+        prompt,
+        imagePaths,
+        sessionId,
+        model,
+        cwd,
+        responseSubject,
+        sinceSeq,
+        limit,
+        runtimeEnvPatch: args.normalizeEnvPatch(args.request.runtimeEnvPatch),
+        codexAuthBundle: args.normalizeCodexAuthBundle(args.request.codexAuth),
+    };
+}
+export function publishRunRpcResponse(args) {
+    args.nc.publish(args.responseSubject, runRpcCodec.encode(JSON.stringify(args.payload)));
+}
+export async function handleNonStartRunRpc(args) {
+    const { request } = args;
+    if (request.action === "list") {
+        const merged = (await args.listPersistedRunTasks())
+            .map((task) => args.cloneRunTask(task))
+            .sort((a, b) => Date.parse(b.updatedAt) - Date.parse(a.updatedAt))
+            .slice(0, request.limit);
+        publishRunRpcResponse({
+            nc: args.nc,
+            responseSubject: request.responseSubject,
+            payload: { requestId: request.requestId, ok: true, tasks: merged },
+        });
+        return;
+    }
+    const stored = request.runId ? await args.getStoredRun(request.runId) : null;
+    if (!stored || stored.agentId !== args.agentId || stored.userId !== args.userId) {
+        throw new Error("Run not found");
+    }
+    if (request.action === "cancel") {
+        if (stored.processPid === null) {
+            throw new Error("Run pid not found");
+        }
+        stored.cancelRequested = true;
+        stored.updatedAt = args.formatTimestamp();
+        await args.persistRunTask(stored);
+        args.publishImmediateRunEvent(stored);
+        args.writeRunStatus(stored.id, `cancel requested pid=${stored.processPid}`);
+        args.sendSignalToPid(stored.processPid, "SIGINT");
+        publishRunRpcResponse({
+            nc: args.nc,
+            responseSubject: request.responseSubject,
+            payload: { requestId: request.requestId, ok: true, task: args.cloneRunTask(stored) },
+        });
+        return;
+    }
+    publishRunRpcResponse({
+        nc: args.nc,
+        responseSubject: request.responseSubject,
+        payload: { requestId: request.requestId, ok: true, task: args.cloneRunTask(stored, request.sinceSeq) },
+    });
+}