@tea-agent/loop-agent 0.1.0

package/dist/executors/cursor-worker-client.js

@@ -0,0 +1,213 @@
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { DEFAULT_CURSOR_TIMEOUT_MS, } from './cursor-executor.js';
+const WORKER_MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
+const WORKER_ENTRY = path.join(WORKER_MODULE_DIR, '../cursor-worker-entry.ts');
+let workerProcess = null;
+let workerBoot = null;
+const pending = new Map();
+let nextId = 1;
+const DEFAULT_RPC_RESPONSE_GRACE_MS = 5_000;
+const CURSOR_WORKER_STOP_SIGNAL = 'SIGTERM';
+function getRpcResponseGraceMs() {
+    const raw = process.env.CURSOR_WORKER_RPC_GRACE_MS?.trim();
+    if (raw) {
+        const parsed = Number(raw);
+        if (Number.isFinite(parsed) && parsed >= 0)
+            return parsed;
+    }
+    return DEFAULT_RPC_RESPONSE_GRACE_MS;
+}
+export function isCursorWorkerEnabled() {
+    const raw = process.env.CURSOR_USE_WORKER?.trim().toLowerCase();
+    return raw === '1' || raw === 'true' || raw === 'yes';
+}
+/** True when this process should accept worker RPC (child), not delegate to a worker. */
+export function isCursorWorkerChild() {
+    return process.env.CURSOR_WORKER_CHILD === '1';
+}
+export function shouldUseCursorWorker(options) {
+    if (options?.runHook)
+        return false;
+    if (isCursorWorkerChild())
+        return false;
+    if (options?.useWorker === true)
+        return true;
+    return isCursorWorkerEnabled();
+}
+function workerScriptArgs() {
+    return ['--import', 'tsx/esm', WORKER_ENTRY];
+}
+export function getCursorWorkerEntryPath() {
+    return WORKER_ENTRY;
+}
+function dispatchResponse(line) {
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch {
+        return;
+    }
+    const waiter = pending.get(parsed.id);
+    if (!waiter)
+        return;
+    pending.delete(parsed.id);
+    waiter.resolve(parsed);
+}
+async function ensureWorkerProcess() {
+    if (workerProcess && !workerProcess.killed && workerProcess.exitCode === null) {
+        return workerProcess;
+    }
+    if (!workerBoot) {
+        workerBoot = new Promise((resolve, reject) => {
+            const child = spawn(process.execPath, workerScriptArgs(), {
+                cwd: process.cwd(),
+                env: { ...process.env, CURSOR_WORKER_CHILD: '1' },
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            workerProcess = child;
+            const rl = createInterface({ input: child.stdout });
+            rl.on('line', dispatchResponse);
+            child.stderr?.on('data', (chunk) => {
+                const text = chunk.toString('utf-8').trim();
+                if (text)
+                    process.stderr.write(`[cursor-worker] ${text}\n`);
+            });
+            child.on('error', (err) => {
+                workerBoot = null;
+                reject(err);
+            });
+            child.on('exit', (code) => {
+                if (workerProcess !== child)
+                    return;
+                workerProcess = null;
+                workerBoot = null;
+                for (const [, waiter] of pending) {
+                    waiter.reject(new Error(`cursor worker exited with code ${code ?? 'unknown'}`));
+                }
+                pending.clear();
+            });
+            // ping to confirm ready
+            const pingId = '__boot__';
+            const bootWaiter = new Promise((res, rej) => {
+                const timeout = setTimeout(() => rej(new Error('cursor worker boot timeout')), 30_000);
+                pending.set(pingId, {
+                    resolve: (response) => {
+                        clearTimeout(timeout);
+                        if (!response.ok) {
+                            rej(new Error('cursor worker ping failed'));
+                            return;
+                        }
+                        res();
+                    },
+                    reject: (err) => {
+                        clearTimeout(timeout);
+                        rej(err);
+                    },
+                });
+            });
+            child.stdin.write(`${JSON.stringify({ id: pingId, type: 'ping' })}\n`);
+            bootWaiter.then(() => resolve()).catch(reject);
+        });
+    }
+    await workerBoot;
+    if (!workerProcess)
+        throw new Error('cursor worker failed to start');
+    return workerProcess;
+}
+export async function stopCursorWorker(signal = CURSOR_WORKER_STOP_SIGNAL) {
+    const pid = workerProcess?.pid;
+    const hadLiveWorker = Boolean(workerProcess && workerProcess.exitCode === null && !workerProcess.killed);
+    if (hadLiveWorker && workerProcess) {
+        try {
+            workerProcess.kill(signal);
+        }
+        catch {
+            /* ignore ESRCH / race with natural exit */
+        }
+    }
+    workerProcess = null;
+    workerBoot = null;
+    for (const [, waiter] of pending) {
+        waiter.reject(new Error('cursor worker stopped'));
+    }
+    pending.clear();
+    return {
+        workerPid: pid,
+        workerTerminationAttempted: hadLiveWorker,
+        workerStopSignal: hadLiveWorker ? signal : undefined,
+    };
+}
+/** Test-only: reset module singletons between cases. */
+export async function resetCursorWorkerStateForTests() {
+    await stopCursorWorker();
+    nextId = 1;
+}
+export function isCursorWorkerRunning() {
+    return Boolean(workerProcess && workerProcess.exitCode === null && !workerProcess.killed);
+}
+export async function executeCursorTaskViaWorker(options) {
+    const child = await ensureWorkerProcess();
+    const id = `req-${nextId++}`;
+    const request = {
+        id,
+        type: 'execute',
+        task: options.task,
+        cwd: options.cwd,
+        model: options.model,
+        timeoutMs: options.timeoutMs,
+        runDir: options.runDir,
+        artifactDir: options.artifactDir,
+    };
+    const taskTimeoutMs = options.timeoutMs ?? DEFAULT_CURSOR_TIMEOUT_MS;
+    const rpcGraceMs = getRpcResponseGraceMs();
+    const responsePromise = new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            pending.delete(id);
+            void stopCursorWorker().then((stopResult) => {
+                resolve({
+                    id,
+                    ok: true,
+                    result: {
+                        ok: false,
+                        status: 'timeout',
+                        failureCategory: 'timeout',
+                        model: options.model ?? 'default',
+                        durationMs: taskTimeoutMs,
+                        stdout: '',
+                        stderr: `cursor worker request timeout after ${taskTimeoutMs}ms`,
+                        details: {
+                            timedOut: true,
+                            timeoutKind: 'rpc',
+                            cancelDeferred: true,
+                            cancelAttempted: false,
+                            workerPid: stopResult.workerPid,
+                            workerTerminationAttempted: stopResult.workerTerminationAttempted,
+                            workerStopSignal: stopResult.workerStopSignal,
+                            workerRestartDeferred: true,
+                        },
+                    },
+                });
+            });
+        }, taskTimeoutMs + rpcGraceMs);
+        pending.set(id, {
+            resolve: (value) => {
+                clearTimeout(timer);
+                resolve(value);
+            },
+            reject: (err) => {
+                clearTimeout(timer);
+                reject(err);
+            },
+        });
+    });
+    child.stdin.write(`${JSON.stringify(request)}\n`);
+    const response = await responsePromise;
+    if (!response.ok) {
+        throw new Error(response.error);
+    }
+    return response.result;
+}

package/dist/executors/cursor-worker-protocol.js

@@ -0,0 +1,18 @@
+export function parseWorkerRequestLine(line) {
+    const parsed = JSON.parse(line);
+    if (!parsed || typeof parsed !== 'object' || !('id' in parsed) || !('type' in parsed)) {
+        throw new Error('invalid worker request');
+    }
+    if (parsed.type === 'ping')
+        return parsed;
+    if (parsed.type === 'execute') {
+        if (typeof parsed.task !== 'string' || typeof parsed.cwd !== 'string') {
+            throw new Error('execute request requires task and cwd');
+        }
+        return parsed;
+    }
+    throw new Error(`unknown worker request type: ${parsed.type}`);
+}
+export function serializeWorkerResponse(response) {
+    return `${JSON.stringify(response)}\n`;
+}

package/dist/executors/cursor-worker-server.js

@@ -0,0 +1,54 @@
+import { createInterface } from 'node:readline';
+import { executeCursorTask } from './cursor-executor.js';
+import { parseWorkerRequestLine, serializeWorkerResponse, } from './cursor-worker-protocol.js';
+export async function handleCursorWorkerRequest(request) {
+    if (request.type === 'ping') {
+        return {
+            id: request.id,
+            ok: true,
+            result: {
+                ok: true,
+                status: 'completed',
+                failureCategory: 'success',
+                model: 'worker',
+                durationMs: 0,
+                stdout: 'pong',
+                stderr: '',
+                details: { worker: true },
+            },
+        };
+    }
+    try {
+        const result = await executeCursorTask({
+            task: request.task,
+            cwd: request.cwd,
+            model: request.model,
+            timeoutMs: request.timeoutMs,
+            runDir: request.runDir,
+            artifactDir: request.artifactDir,
+        });
+        return { id: request.id, ok: true, result };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { id: request.id, ok: false, error: message };
+    }
+}
+export async function runCursorWorkerOnStreams(input, output) {
+    const rl = createInterface({ input, crlfDelay: Infinity });
+    for await (const line of rl) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        let response;
+        try {
+            const request = parseWorkerRequestLine(trimmed);
+            response = await handleCursorWorkerRequest(request);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            response = { id: 'unknown', ok: false, error: message };
+        }
+        output.write(serializeWorkerResponse(response));
+    }
+}

package/dist/executors/cursor-worker.js

@@ -0,0 +1,3 @@
+export * from "./cursor-worker-client.js";
+export * from "./cursor-worker-protocol.js";
+export * from "./cursor-worker-server.js";

package/dist/executors/cursor.js

@@ -0,0 +1,6 @@
+export * from "./cursor-artifacts.js";
+export * from "./cursor-execution-log.js";
+export * from "./cursor-executor-artifacts.js";
+export * from "./cursor-executor.js";
+export * from "./cursor-run.js";
+export * from "./cursor-tool.js";

package/dist/executors/dag-cursor-executor.js

@@ -0,0 +1,88 @@
+import { mkdir } from "node:fs/promises";
+import path from "node:path";
+import { executeCursorTask } from "./cursor-executor.js";
+import { writeCursorExecutorArtifacts } from "./cursor-executor-artifacts.js";
+import { buildCursorExecutionLogRecord, persistCursorExecutionLog, } from "./cursor-execution-log.js";
+import { readGitStatusPorcelain, runPostRunWriteGuard, } from "./shell-write-guard.js";
+export async function executeDagCursorNode(input, meta) {
+    const started = Date.now();
+    let beforeStatus;
+    try {
+        beforeStatus = await readGitStatusPorcelain(input.cwd);
+    }
+    catch {
+        // Non-git cwd: skip write guard (documented limitation).
+        beforeStatus = undefined;
+    }
+    const artifactDir = path.join(meta.runDir, "artifacts", input.task.id);
+    await mkdir(artifactDir, { recursive: true });
+    const result = await executeCursorTask({
+        task: input.prompt,
+        cwd: input.cwd,
+        model: input.model,
+        useWorker: true,
+        artifactDir,
+    });
+    const executionContext = {
+        channel: "dag",
+        cwd: input.cwd,
+        dagRunId: meta.runId,
+        dagNodeId: input.task.id,
+    };
+    await persistCursorExecutionLog(meta.runDir, buildCursorExecutionLogRecord({
+        context: executionContext,
+        model: input.model,
+        prompt: input.prompt,
+        result,
+    }));
+    await writeCursorExecutorArtifacts(path.join(meta.runDir, input.task.id), {
+        prompt: input.prompt,
+        model: input.model,
+        context: executionContext,
+        result,
+    });
+    let writeGuardOk = true;
+    let writeGuardViolations = [];
+    if (beforeStatus !== undefined) {
+        try {
+            const guard = await runPostRunWriteGuard({
+                rootCwd: input.cwd,
+                beforeStatus,
+                writePolicy: input.task.writePolicy,
+                writeSet: input.task.writeSet,
+                allowedPaths: input.task.allowedPaths,
+                forbiddenPaths: input.task.forbiddenPaths,
+                concurrentSiblingWriteSets: meta.concurrentSiblingWriteSets,
+            });
+            writeGuardOk = guard.ok;
+            writeGuardViolations = guard.violations;
+        }
+        catch {
+            writeGuardOk = false;
+            writeGuardViolations = ["write guard failed: git status unavailable"];
+        }
+    }
+    const ok = result.ok && writeGuardOk;
+    const stderrParts = [result.stderr];
+    if (!writeGuardOk) {
+        stderrParts.push(`write guard failed: ${writeGuardViolations.join(", ")}`);
+        if (meta.writeGuardAttribution === "best-effort") {
+            stderrParts.push("write guard note: concurrent rank writers use best-effort per-node attribution; keep same-rank writeSet entries disjoint");
+        }
+    }
+    const executionResult = {
+        ok,
+        stdout: result.stdout,
+        stderr: stderrParts.filter(Boolean).join("\n\n"),
+        failureCategory: !result.ok
+            ? result.failureCategory
+            : !writeGuardOk
+                ? "write-guard"
+                : result.failureCategory,
+        durationMs: result.durationMs ?? Date.now() - started,
+    };
+    if (result.tokensUsed !== undefined) {
+        executionResult.tokensUsed = result.tokensUsed;
+    }
+    return executionResult;
+}