@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
195 lines (184 loc) • 8.1 kB
text/typescript
import { spawn } from "node:child_process";
import { shellInvocation } from "../../lib/win-exec";
import { create } from "@bufbuild/protobuf";
import {
ComputerUseErrorSchema,
ComputerUseResultSchema,
ComputerUseSuccessSchema,
RecordScreenDiscardSuccessSchema,
RecordScreenFailureSchema,
RecordScreenResultSchema,
RecordScreenSaveSuccessSchema,
RecordScreenStartSuccessSchema,
type ComputerUseArgs,
type ComputerUseResult,
type RecordScreenArgs,
type RecordScreenResult,
} from "./gen/agent_pb";
import { errorText } from "./native-exec-common";
import type { CursorNativeToolDeps } from "./native-exec-tools";
import type { DesktopExecutorConfig } from "./desktop-executor-contract";
const DEFAULT_DESKTOP_TIMEOUT_MS = 30_000;
export type { DesktopExecutorConfig } from "./desktop-executor-contract";
/**
* Build `computerUse` / `recordScreen` deps from external executor commands. Returns `{}` when no
* command is configured (the dispatcher then falls back to the honest "not supported" default).
* Every method maps results to protobuf and NEVER throws — a throw would propagate into the
* stream loop and fail the conversation.
*/
export function desktopDepsFromConfig(config?: DesktopExecutorConfig): CursorNativeToolDeps {
if (!config?.computerUseCommand && !config?.recordScreenCommand) return {};
const deps: CursorNativeToolDeps = {};
if (config.computerUseCommand) {
deps.computerUse = (args: ComputerUseArgs) => runComputerUse(config, args);
}
if (config.recordScreenCommand) {
deps.recordScreen = (args: RecordScreenArgs) => runRecordScreen(config, args);
}
return deps;
}
async function runComputerUse(config: DesktopExecutorConfig, args: ComputerUseArgs): Promise<ComputerUseResult> {
const actionCount = args.actions.length;
try {
const out = await runExternalJson(config.computerUseCommand!, {
toolCallId: args.toolCallId,
actions: args.actions,
}, config);
if (out && typeof out === "object" && "error" in out) {
return computerUseError(String((out as { error: unknown }).error), actionCount);
}
const result = out as { screenshot?: string; screenshotPath?: string; durationMs?: number; log?: string };
return create(ComputerUseResultSchema, {
result: { case: "success", value: create(ComputerUseSuccessSchema, {
actionCount,
durationMs: typeof result?.durationMs === "number" ? result.durationMs : 0,
screenshot: result?.screenshot,
screenshotPath: result?.screenshotPath,
log: result?.log,
}) },
});
} catch (err) {
return computerUseError(errorText(err), actionCount);
}
}
async function runRecordScreen(config: DesktopExecutorConfig, args: RecordScreenArgs): Promise<RecordScreenResult> {
try {
const out = await runExternalJson(config.recordScreenCommand!, {
mode: args.mode,
toolCallId: args.toolCallId,
saveAsFilename: args.saveAsFilename,
}, config) as Record<string, unknown>;
if (out?.startSuccess) {
const s = out.startSuccess as { wasPriorRecordingCancelled?: boolean; wasSaveAsFilenameIgnored?: boolean };
return create(RecordScreenResultSchema, { result: { case: "startSuccess", value: create(RecordScreenStartSuccessSchema, {
wasPriorRecordingCancelled: Boolean(s.wasPriorRecordingCancelled),
wasSaveAsFilenameIgnored: Boolean(s.wasSaveAsFilenameIgnored),
}) } });
}
if (out?.saveSuccess) {
const s = out.saveSuccess as { path?: string; recordingDurationMs?: number };
return create(RecordScreenResultSchema, { result: { case: "saveSuccess", value: create(RecordScreenSaveSuccessSchema, {
path: String(s.path ?? ""),
recordingDurationMs: BigInt(Math.trunc(s.recordingDurationMs ?? 0)),
}) } });
}
if (out?.discardSuccess) {
return create(RecordScreenResultSchema, { result: { case: "discardSuccess", value: create(RecordScreenDiscardSuccessSchema, {}) } });
}
const failure = out?.failure as { error?: unknown } | undefined;
return recordScreenFailure(failure?.error ? String(failure.error) : "record-screen executor returned no recognized result");
} catch (err) {
return recordScreenFailure(errorText(err));
}
}
function computerUseError(error: string, actionCount: number): ComputerUseResult {
return create(ComputerUseResultSchema, {
result: { case: "error", value: create(ComputerUseErrorSchema, { error, actionCount, durationMs: 0 }) },
});
}
function recordScreenFailure(error: string): RecordScreenResult {
return create(RecordScreenResultSchema, {
result: { case: "failure", value: create(RecordScreenFailureSchema, { error }) },
});
}
/**
* Spawn `command` via the platform shell (sh -c on POSIX, cmd.exe /d /s /c on win32 —
* the configured command is platform-native shell syntax; devlog
* 260715_cross_platform_audit/020), write `payload` as JSON to stdin, return parsed stdout JSON.
*/
function runExternalJson(command: string, payload: unknown, config: DesktopExecutorConfig): Promise<unknown> {
const timeoutMs = config.timeoutMs ?? DEFAULT_DESKTOP_TIMEOUT_MS;
return new Promise((resolve, reject) => {
const inv = shellInvocation(command);
const child = spawn(inv.file, inv.args, {
cwd: config.cwd,
env: config.env ? { ...process.env, ...config.env } : process.env,
stdio: ["pipe", "pipe", "pipe"],
...inv.options,
});
let stdout = "";
let stderr = "";
let settled = false;
const timer = setTimeout(() => {
if (settled) return;
settled = true;
child.kill("SIGKILL");
reject(new Error(`desktop executor timed out after ${timeoutMs}ms`));
}, timeoutMs);
child.stdout.on("data", chunk => { stdout += chunk.toString(); });
child.stderr.on("data", chunk => { stderr += chunk.toString(); });
child.on("error", err => {
if (settled) return;
settled = true;
clearTimeout(timer);
reject(err);
});
child.on("close", code => {
if (settled) return;
settled = true;
clearTimeout(timer);
if (code !== 0) {
reject(new Error(`desktop executor exited with code ${code}${stderr ? `: ${stderr.trim()}` : ""}`));
return;
}
try {
resolve(JSON.parse(stdout.trim()));
} catch {
reject(new Error(`desktop executor produced invalid JSON: ${stdout.slice(0, 200)}`));
}
});
// A command that never reads stdin - `echo`, a script that exits on a bad flag,
// anything that fails before its first read - closes the pipe while we are still
// writing to it. The write then fails with EPIPE, and on Linux that surfaces as an
// ASYNCHRONOUS 'error' event on the stream rather than a throw, so the try/catch
// below never saw it and the rejection escaped as an unhandled stream error. On
// macOS the same command usually drains the small payload first, which is why this
// only ever went red on the Linux shard.
//
// EPIPE here is not a failure of the executor CONTRACT: the child's exit code and
// stdout are what decide the result, and both are handled in 'close' above. So the
// pipe error is swallowed deliberately and the outcome is left to the child, which
// is what makes "bad output maps to failure" reachable instead of exploding.
child.stdin.on("error", (err: NodeJS.ErrnoException) => {
if (err.code === "EPIPE" || err.code === "ERR_STREAM_DESTROYED") return;
if (settled) return;
settled = true;
clearTimeout(timer);
reject(err);
});
try {
child.stdin.write(JSON.stringify(payload));
child.stdin.end();
} catch (err) {
// Kept for the synchronous half: a stream already destroyed when we reach this
// line throws immediately instead of emitting.
const code = (err as NodeJS.ErrnoException).code;
if (code === "EPIPE" || code === "ERR_STREAM_DESTROYED") return;
if (!settled) {
settled = true;
clearTimeout(timer);
reject(err);
}
}
});
}