dev-orchestrator-connector 0.0.0-stage → 0.1.1

package/README.md

@@ -1,3 +1,36 @@
-# Temporary Holding Version
+# Dev Orchestrator Connector
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The connector runs on your computer and uses your existing local Codex sign-in.
+It downloads only repositories authorized for the paired executor. The cloud
+service coordinates tasks but never hosts your source checkout.
+
+Requirements: Node.js 22.18 or newer and the official Codex CLI signed in.
+
+Install the connector in your home directory:
+
+```bash
+cd "$HOME" && npm i dev-orchestrator-connector
+```
+
+Pair this machine using the one-time code shown in **Executors**:
+
+```bash
+"$HOME/node_modules/.bin/dev-orchestrator-connector" pair \
+  --server https://YOUR-ORCHESTRATOR-HOST \
+  --code YOUR_ONE_USE_CODE \
+  --config "$HOME/.local/share/dev-orchestrator/connector.json"
+```
+
+An owner must bind the executor to a project in the web app. Then start it with:
+
+```bash
+"$HOME/node_modules/.bin/dev-orchestrator-connector" run \
+  --config "$HOME/.local/share/dev-orchestrator/connector.json"
+```
+
+Keep that terminal open while the executor should process tasks. Press `Ctrl+C`
+to stop it safely. The connector stores its credential and runtime data under
+`~/.local/share/dev-orchestrator` with owner-only permissions.
+
+This package contains only the local connector. It does not include the cloud
+control plane or provider credentials.

package/bin/dev-orchestrator-connector.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+const cli = fileURLToPath(new URL("../dist/cli.js", import.meta.url));
+const child = spawn(process.execPath, [cli, ...process.argv.slice(2)], {
+  stdio: "inherit",
+});
+
+child.on("error", (error) => {
+  console.error(`Could not start the connector: ${error.message}`);
+  process.exitCode = 1;
+});
+
+child.on("exit", (code, signal) => {
+  process.exitCode = code ?? (signal ? 1 : 0);
+});

package/dist/activity.js

@@ -0,0 +1,22 @@
+const validationCommand = /\b(test|tests|spec|lint|format|typecheck|type-check|check|build|compile)\b/i;
+export function activityForNotification(message) {
+    if (!message || typeof message !== "object" || !message.params)
+        return undefined;
+    if (message.method === "turn/started")
+        return "agent_started";
+    const item = message.params.item;
+    if (message.method === "item/started") {
+        if (item?.type === "fileChange")
+            return "editing";
+        if (item?.type === "commandExecution") {
+            return validationCommand.test(String(item.command ?? "")) ? "validating" : "working";
+        }
+    }
+    if (message.method === "item/completed" &&
+        item?.type === "commandExecution" &&
+        validationCommand.test(String(item.command ?? "")) &&
+        item.exitCode === 0) {
+        return "checks_passed";
+    }
+    return undefined;
+}

package/dist/api.js

@@ -0,0 +1,24 @@
+import { serverURL } from "./config.js";
+export class APIError extends Error {
+    status;
+    code;
+    constructor(status, code) { super(`Control plane request failed (${status}: ${code}).`); this.status = status; this.code = code; }
+}
+export class API {
+    origin;
+    token;
+    constructor(origin, token) { this.origin = serverURL(origin); this.token = token; }
+    async post(path, data) {
+        if (!/^\/[a-z/-]+$/.test(path))
+            throw new Error("Invalid control-plane route.");
+        const response = await fetch(this.origin + "/api/v1" + path, {
+            method: "POST", redirect: "error", signal: AbortSignal.timeout(15_000),
+            headers: { "content-type": "application/json", ...(this.token ? { authorization: `Bearer ${this.token}` } : {}) },
+            body: JSON.stringify(data)
+        });
+        const body = await response.json();
+        if (!response.ok)
+            throw new APIError(response.status, typeof body.error === "string" && /^[a-z_]+$/.test(body.error) ? body.error : "request_failed");
+        return path === "/enroll" ? body : body.data;
+    }
+}

package/dist/cli.js

@@ -0,0 +1,90 @@
+import { hostname } from "node:os";
+import { dirname, join } from "node:path";
+import { mkdir, open, unlink } from "node:fs/promises";
+import { pathToFileURL } from "node:url";
+import { API } from "./api.js";
+import { loadConfig, saveConfig, serverURL } from "./config.js";
+import { CodexSession } from "./codex.js";
+import { runLoop } from "./worker.js";
+export async function main(args) {
+    const [action, ...rest] = args;
+    if (!action || action === "help" || action === "--help") {
+        console.log("Dev Orchestrator connector\n\npair --server URL --code CODE --config /absolute/config.json\nstatus --config FILE\nrun --config FILE\n\nProjects and repository access are managed in the web app. This connector uses your official local Codex login and never modifies global provider/Git configuration.");
+        return;
+    }
+    const opts = {};
+    for (let i = 0; i < rest.length; i += 2) {
+        if (!/^--[a-z-]+$/.test(rest[i]) || !rest[i + 1])
+            throw new Error("Options require --name value pairs.");
+        opts[rest[i].slice(2)] = rest[i + 1];
+    }
+    if (!opts.config || !opts.config.startsWith("/"))
+        throw new Error("Provide an absolute --config path.");
+    const file = opts.config;
+    if (action === "pair") {
+        // Do not consume a one-use code if a pairing already exists.
+        const reservation = await open(file + ".pairing", "wx", 0o600).catch(() => { throw new Error("Configuration directory must exist and no pairing may already be in progress."); });
+        try {
+            try {
+                await loadConfig(file);
+                throw new Error("This configuration is already paired.");
+            }
+            catch (error) {
+                if (error.code !== "ENOENT")
+                    throw error;
+            }
+            const server = serverURL(opts.server);
+            const result = await new API(server).post("/enroll", { code: opts.code, name: opts.name ?? hostname() });
+            if (typeof result.token !== "string")
+                throw new Error("Invalid enrollment response.");
+            await saveConfig(file, { version: 2, server, token: result.token }, true);
+            console.log("Paired. Ask the owner to bind a project and install its repository in the web app.");
+        }
+        finally {
+            await reservation.close();
+            await unlink(file + ".pairing");
+        }
+        return;
+    }
+    const config = await loadConfig(file);
+    if (action === "allow") {
+        console.log("The local allow command is no longer needed. Bind this executor to the project and configure its GitHub App repository access in the web app.");
+        return;
+    }
+    if (action === "status") {
+        const session = CodexSession.start(config.codexBinary ?? "codex", dirname(file));
+        try {
+            await session.initialize();
+            console.log(JSON.stringify({ codex_authenticated: await session.authenticated(), server: config.server }));
+        }
+        finally {
+            session.stop();
+        }
+        return;
+    }
+    if (action !== "run")
+        throw new Error("Unknown command. Use help.");
+    const root = join(dirname(file), "runtime");
+    await mkdir(root, { recursive: true, mode: 0o700 });
+    const lock = join(root, "connector.lock");
+    const fd = await open(lock, "wx", 0o600).catch(() => { throw new Error("Connector lock exists. Confirm no connector is running before removing that exact lock file."); });
+    await fd.writeFile(String(process.pid));
+    const controller = new AbortController();
+    const stop = () => controller.abort();
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+    try {
+        console.log("Connector running. Press Ctrl+C to stop; interrupted work is preserved.");
+        await runLoop(config, root, controller.signal);
+    }
+    finally {
+        controller.abort();
+        process.off("SIGINT", stop);
+        process.off("SIGTERM", stop);
+        await fd.close();
+        await unlink(lock);
+    }
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+    main(process.argv.slice(2)).catch(error => { console.error(error instanceof Error ? error.message : "Connector operation failed."); process.exitCode = 1; });
+}

package/dist/codex.js

@@ -0,0 +1,202 @@
+import { spawn } from "node:child_process";
+import { EventEmitter } from "node:events";
+import { createHash } from "node:crypto";
+import { stopProcess } from "./process.js";
+import { activityForNotification } from "./activity.js";
+export class RepeatedFailureError extends Error {
+    fingerprint;
+    constructor(fingerprint) { super("Codex repeated the same failed command three times."); this.fingerprint = fingerprint; }
+}
+export class CodexBlockedError extends Error {
+}
+export class CodexSession {
+    child;
+    events = new EventEmitter();
+    pending = new Map();
+    id = 0;
+    buffer = "";
+    failed = null;
+    commandFailures = new Map();
+    constructor(child) {
+        this.child = child;
+        child.stderr.resume();
+        child.stdin.on("error", () => this.fail(new Error("Codex transport closed.")));
+        child.stdout.on("data", chunk => this.consume(chunk.toString()));
+        child.on("error", () => this.fail(new Error("Codex could not start. Check the locally installed CLI.")));
+        child.on("close", () => this.fail(new Error("Codex process stopped before completion.")));
+    }
+    static start(binary, workspace) {
+        // Keep provider-owned local login, but never forward API/Git tokens into the agent.
+        const allowed = ["PATH", "HOME", "USER", "LOGNAME", "SHELL", "TMPDIR", "LANG", "LC_ALL", "CODEX_HOME", "HTTP_PROXY", "HTTPS_PROXY", "ALL_PROXY", "NO_PROXY"];
+        const env = Object.fromEntries(allowed.filter(key => process.env[key] !== undefined).map(key => [key, process.env[key]]));
+        const args = ["app-server", "--listen", "stdio://",
+            "-c", 'permissions.dev-orchestrator.extends=":workspace"',
+            "-c", 'permissions.dev-orchestrator.filesystem={":workspace_roots"={"."="write",".git"="write",".agents"="write",".codex"="read",".aws"="read"}}',
+            "-c", "permissions.dev-orchestrator.network.enabled=false"];
+        return new CodexSession(spawn(binary, args, { cwd: workspace, env, detached: true, stdio: ["pipe", "pipe", "pipe"] }));
+    }
+    async initialize() {
+        await this.request("initialize", { clientInfo: { name: "dev_orchestrator", title: "Dev Orchestrator", version: "0.1.0" }, capabilities: { experimentalApi: true } });
+        this.send({ method: "initialized", params: {} });
+    }
+    async authenticated() {
+        const result = await this.request("account/read", { refreshToken: false });
+        return result.account?.type === "chatgpt";
+    }
+    async run(workspace, prompt, model, signal, onProgress) {
+        const thread = await this.request("thread/start", { cwd: workspace, approvalPolicy: "never", permissions: "dev-orchestrator", ...(model ? { model } : {}) });
+        const threadId = thread.thread?.id;
+        if (!threadId)
+            throw new Error("Codex returned no task thread.");
+        let onNotification;
+        let onFailure;
+        let abort;
+        let outcome;
+        let lastStage;
+        let progressQueue = Promise.resolve();
+        let progressFailure;
+        const completed = new Promise((resolve, reject) => {
+            onNotification = (message) => {
+                if (message.params?.threadId === threadId) {
+                    const stage = activityForNotification(message);
+                    if (stage && stage !== lastStage) {
+                        lastStage = stage;
+                        progressQueue = progressQueue.then(() => onProgress?.(stage));
+                        void progressQueue.catch(error => {
+                            progressFailure = error instanceof Error ? error : new Error("Progress delivery failed.");
+                            this.fail(progressFailure);
+                        });
+                    }
+                }
+                if (message.method === "item/completed" && message.params?.threadId === threadId && message.params.item?.type === "agentMessage") {
+                    try {
+                        const result = JSON.parse(message.params.item.text);
+                        if (["completed", "blocked"].includes(result?.outcome))
+                            outcome = result.outcome;
+                    }
+                    catch { /* Wait for a valid structured final answer. */ }
+                }
+                if (message.method === "turn/completed" && message.params?.threadId === threadId) {
+                    if (outcome === "blocked")
+                        reject(new CodexBlockedError("Essential context is missing; the task is blocked."));
+                    else if (message.params.turn?.status === "completed" && outcome === "completed")
+                        resolve();
+                    else
+                        reject(new Error("Codex turn did not complete."));
+                }
+            };
+            onFailure = reject;
+            abort = () => { this.stop(); reject(new Error("Task stopped before lease expiration.")); };
+            this.events.on("notification", onNotification);
+            this.events.once("failure", onFailure);
+            signal?.addEventListener("abort", abort, { once: true });
+            if (signal?.aborted)
+                abort();
+        });
+        // Attach a rejection handler before turn/start to cover an early process exit.
+        completed.catch(() => { });
+        try {
+            await this.request("turn/start", { threadId, cwd: workspace, approvalPolicy: "never", permissions: "dev-orchestrator", input: [{ type: "text", text: prompt }], outputSchema: { type: "object", properties: { outcome: { type: "string", enum: ["completed", "blocked"] } }, required: ["outcome"], additionalProperties: false } });
+            await completed;
+            await progressQueue;
+            if (progressFailure)
+                throw progressFailure;
+        }
+        finally {
+            this.events.off("notification", onNotification);
+            this.events.off("failure", onFailure);
+            signal?.removeEventListener("abort", abort);
+        }
+    }
+    stop() { stopProcess(this.child); this.fail(new Error("Codex stopped.")); }
+    request(method, params) {
+        if (this.failed)
+            return Promise.reject(this.failed);
+        return new Promise((resolve, reject) => {
+            const id = ++this.id;
+            const timer = setTimeout(() => { this.pending.delete(id); reject(new Error("Codex request timed out.")); this.stop(); }, 30_000);
+            this.pending.set(id, { resolve, reject, timer });
+            this.send({ id, method, params });
+        });
+    }
+    send(message) { if (!this.child.stdin.destroyed)
+        this.child.stdin.write(JSON.stringify(message) + "\n"); }
+    consume(chunk) {
+        this.buffer += chunk;
+        if (this.buffer.length > 1_048_576) {
+            this.fail(new Error("Codex message exceeded the size limit."));
+            this.stop();
+            return;
+        }
+        let newline;
+        while ((newline = this.buffer.indexOf("\n")) >= 0) {
+            const line = this.buffer.slice(0, newline);
+            this.buffer = this.buffer.slice(newline + 1);
+            if (!line.trim())
+                continue;
+            let message;
+            try {
+                message = JSON.parse(line);
+            }
+            catch {
+                this.fail(new Error("Invalid Codex protocol response."));
+                this.stop();
+                return;
+            }
+            if (!message || typeof message !== "object" || Array.isArray(message)) {
+                this.fail(new Error("Invalid Codex protocol response."));
+                this.stop();
+                return;
+            }
+            if (message.method === "item/completed") {
+                const item = message.params?.item;
+                if (item?.type === "commandExecution" && (typeof item.exitCode === "number" && item.exitCode !== 0 || item.status === "failed")) {
+                    const command = String(item.command ?? "");
+                    const wrapped = command.trim().match(/^(?:\/[^\s]+\/)?(?:bash|zsh|sh)\s+-lc\s+(['"])([\s\S]*)\1$/);
+                    const probe = (wrapped?.[2] ?? command).trim();
+                    const unquoted = probe.replace(/"[^"\n]*"|'[^'\n]*'/g, "");
+                    const expectedMiss = item.exitCode === 1 && /^(?:rg|grep|test|\[)(?:\s|$)/.test(probe) && !/[;&|]/.test(unquoted);
+                    if (!expectedMiss) {
+                        const detail = (command + ":" + String(item.exitCode) + ":" + String(item.aggregatedOutput ?? "")).replace(/\b[0-9a-f]{8}-[0-9a-f-]{27,}\b/gi, "<id>").replace(/\b\d+(?:\.\d+)?\s*(?:ms|s|seconds)\b/g, "<duration>");
+                        const fingerprint = createHash("sha256").update(detail).digest("hex");
+                        const count = (this.commandFailures.get(fingerprint) ?? 0) + 1;
+                        this.commandFailures.set(fingerprint, count);
+                        if (count >= 3) {
+                            this.fail(new RepeatedFailureError(fingerprint));
+                            this.stop();
+                            return;
+                        }
+                    }
+                }
+            }
+            if (message.method && message.id !== undefined) {
+                // The connector never auto-approves a broader permission or user-input request.
+                this.send({ id: message.id, error: { code: -32000, message: "Required context or permission is unavailable; task blocked." } });
+                this.fail(new Error("Codex needs context or unsupported permissions."));
+                this.stop();
+                return;
+            }
+            if (message.id !== undefined) {
+                const pending = this.pending.get(message.id);
+                if (pending) {
+                    clearTimeout(pending.timer);
+                    this.pending.delete(message.id);
+                    message.error ? pending.reject(new Error("Codex rejected the configured request or sandbox.")) : pending.resolve(message.result);
+                }
+            }
+            else if (message.method)
+                this.events.emit("notification", message);
+        }
+    }
+    fail(error) {
+        if (this.failed)
+            return;
+        this.failed = error;
+        for (const pending of this.pending.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(error);
+        }
+        this.pending.clear();
+        this.events.emit("failure", error);
+    }
+}

package/dist/config.js

@@ -0,0 +1,69 @@
+import { lstat, readFile, mkdir, open, rename, unlink } from "node:fs/promises";
+import { dirname, isAbsolute } from "node:path";
+import { randomUUID } from "node:crypto";
+export function serverURL(value) {
+    const url = new URL(value);
+    const local = ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+    if ((url.protocol !== "https:" && !(local && url.protocol === "http:")) || url.username || url.password || url.search || url.hash || url.pathname !== "/")
+        throw new Error("Use an HTTPS server origin (loopback HTTP is allowed for development).");
+    return url.origin;
+}
+export async function loadConfig(path) {
+    if (!isAbsolute(path))
+        throw new Error("Configuration path must be absolute.");
+    const info = await lstat(path);
+    if (!info.isFile() || info.isSymbolicLink() || (info.mode & 0o077) !== 0)
+        throw new Error("Configuration must be a regular owner-only file (chmod 600).");
+    const config = JSON.parse(await readFile(path, "utf8"));
+    if (![1, 2].includes(config.version) || typeof config.token !== "string" || !config.token)
+        throw new Error("Invalid connector configuration.");
+    const server = serverURL(config.server);
+    if (config.version === 1) {
+        if (!Array.isArray(config.mappings))
+            throw new Error("Invalid connector configuration.");
+        console.warn("Legacy connector configuration detected. Local project mappings are ignored; bind projects in the web app.");
+    }
+    else if ("mappings" in config) {
+        throw new Error("Invalid connector configuration.");
+    }
+    return { version: 2, server, token: config.token, ...(typeof config.codexBinary === "string" ? { codexBinary: config.codexBinary } : {}) };
+}
+export async function saveConfig(path, config, exclusive = false) {
+    if (!isAbsolute(path))
+        throw new Error("Configuration path must be absolute.");
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    if (!exclusive) {
+        try {
+            await loadConfig(path);
+        }
+        catch (e) {
+            if (e.code !== "ENOENT")
+                throw e;
+        }
+    }
+    if (exclusive) {
+        const file = await open(path, "wx", 0o600);
+        try {
+            await file.writeFile(JSON.stringify(config, null, 2));
+            await file.sync();
+        }
+        finally {
+            await file.close();
+        }
+    }
+    else {
+        const temporary = path + ".tmp-" + randomUUID();
+        const file = await open(temporary, "wx", 0o600);
+        try {
+            await file.writeFile(JSON.stringify(config, null, 2));
+            await file.sync();
+            await file.close();
+            await rename(temporary, path);
+        }
+        catch (error) {
+            await file.close().catch(() => { });
+            await unlink(temporary).catch(() => { });
+            throw error;
+        }
+    }
+}

package/dist/git-credential.js

@@ -0,0 +1,28 @@
+import { chmod, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { cleanGitEnv } from "./process.js";
+export function validateGitHubCredential(value) {
+    if (!value || typeof value !== "object")
+        throw new Error("GitHub authorization is unavailable.");
+    const credential = value;
+    if (typeof credential.token !== "string" || !/^[A-Za-z0-9_-]+$/.test(credential.token) ||
+        typeof credential.expires_at !== "string" || !Number.isFinite(Date.parse(credential.expires_at)) || Date.parse(credential.expires_at) <= Date.now() ||
+        typeof credential.author_name !== "string" || !credential.author_name || credential.author_name.length > 200 || /[\r\n]/.test(credential.author_name) ||
+        typeof credential.author_email !== "string" || !credential.author_email || credential.author_email.length > 254 || /[\r\n]/.test(credential.author_email)) {
+        throw new Error("GitHub authorization is invalid or expired.");
+    }
+}
+export async function withGitHubCredential(root, credential, operation) {
+    validateGitHubCredential(credential);
+    const directory = await mkdtemp(join(root, ".github-auth-"));
+    try {
+        await chmod(directory, 0o700);
+        const helper = join(directory, "askpass");
+        const script = `#!/bin/sh\ncase "$1" in\n  *sername*) printf '%s\\n' 'x-access-token' ;;\n  *assword*) printf '%s\\n' '${credential.token}' ;;\n  *) exit 1 ;;\nesac\n`;
+        await writeFile(helper, script, { encoding: "utf8", mode: 0o700, flag: "wx" });
+        return await operation({ ...cleanGitEnv(), GIT_ASKPASS: helper, SSH_ASKPASS: helper, GIT_TERMINAL_PROMPT: "0" });
+    }
+    finally {
+        await rm(directory, { recursive: true, force: true });
+    }
+}

package/dist/journal.js

@@ -0,0 +1,51 @@
+import { mkdir, open, readFile, rename, unlink, lstat } from "node:fs/promises";
+import { join, isAbsolute } from "node:path";
+import { randomUUID } from "node:crypto";
+export class Journal {
+    root;
+    constructor(root) {
+        if (!isAbsolute(root))
+            throw new Error("Journal directory must be absolute.");
+        this.root = root;
+    }
+    async load() {
+        try {
+            const path = join(this.root, "active.json");
+            const stat = await lstat(path);
+            if (!stat.isFile() || stat.isSymbolicLink() || (stat.mode & 0o077))
+                throw new Error("Unsafe journal file.");
+            const state = JSON.parse(await readFile(path, "utf8"));
+            if (!state.lease?.id || !Number.isInteger(state.sequence))
+                throw new Error("Corrupt journal; manual recovery is required.");
+            return state;
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return null;
+            throw error;
+        }
+    }
+    async save(state) {
+        await mkdir(this.root, { recursive: true, mode: 0o700 });
+        const info = await lstat(this.root);
+        if (!info.isDirectory() || info.isSymbolicLink())
+            throw new Error("Unsafe journal directory.");
+        const temp = join(this.root, ".journal-" + randomUUID());
+        const file = await open(temp, "wx", 0o600);
+        try {
+            await file.writeFile(JSON.stringify(state));
+            await file.sync();
+            await file.close();
+            await rename(temp, join(this.root, "active.json"));
+        }
+        catch (error) {
+            await file.close().catch(() => { });
+            await unlink(temp).catch(() => { });
+            throw error;
+        }
+    }
+    async clear() {
+        await unlink(join(this.root, "active.json")).catch((e) => { if (e.code !== "ENOENT")
+            throw e; });
+    }
+}

package/dist/process.js

@@ -0,0 +1,54 @@
+import { spawn } from "node:child_process";
+export const cleanGitEnv = () => ({
+    PATH: process.env.PATH, HOME: process.env.HOME,
+    LANG: "C", GIT_CONFIG_NOSYSTEM: "1", GIT_CONFIG_GLOBAL: "/dev/null",
+    GIT_TERMINAL_PROMPT: "0", GIT_NO_REPLACE_OBJECTS: "1"
+});
+export async function readAuthor(source, env = { PATH: process.env.PATH, HOME: process.env.HOME, XDG_CONFIG_HOME: process.env.XDG_CONFIG_HOME, GIT_CONFIG_NOSYSTEM: "1" }) {
+    // Reading these two values does not execute hooks or credential helpers.
+    const name = (await command("git", ["-C", source, "config", "--get", "user.name"], { env })).output;
+    const email = (await command("git", ["-C", source, "config", "--get", "user.email"], { env })).output;
+    if (!name || name.length > 200 || !email || email.length > 254 || /[\r\n]/.test(name + email))
+        throw new Error("Configure a Git author on the customer host before running tasks.");
+    return { name, email };
+}
+export function stopProcess(child) {
+    if (!child.pid || child.exitCode !== null)
+        return;
+    try {
+        process.kill(-child.pid, "SIGKILL");
+    }
+    catch {
+        child.kill("SIGKILL");
+    }
+}
+export async function command(binary, args, opts = {}) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(binary, args, { cwd: opts.cwd, env: opts.env ?? cleanGitEnv(), detached: true, stdio: ["ignore", "pipe", "ignore"] });
+        let output = "", settled = false;
+        const fail = () => { if (!settled) {
+            settled = true;
+            stopProcess(child);
+            reject(new Error("Local command failed."));
+        } };
+        const timer = setTimeout(fail, opts.timeout ?? 30_000);
+        const abort = () => fail();
+        opts.signal?.addEventListener("abort", abort, { once: true });
+        if (opts.signal?.aborted)
+            fail();
+        child.stdout.on("data", chunk => { output += chunk.toString(); if (output.length > 1_048_576)
+            fail(); });
+        child.on("error", fail);
+        child.on("close", code => {
+            clearTimeout(timer);
+            opts.signal?.removeEventListener("abort", abort);
+            if (settled)
+                return;
+            settled = true;
+            if (code === 0 || (code === 1 && opts.allowExitOne))
+                resolve({ output: output.trim(), code: code });
+            else
+                reject(new Error("Local command failed."));
+        });
+    });
+}