appback-remoteagent 0.13.0

package/dist/adapters/codex-adapter.js

@@ -0,0 +1,241 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { spawnWithPlatformShell } from "./windows-shell.js";
+export class CodexAdapter {
+    codexBin;
+    timeoutMs;
+    sandboxMode;
+    constructor(codexBin, timeoutMs, sandboxMode) {
+        this.codexBin = codexBin;
+        this.timeoutMs = timeoutMs;
+        this.sandboxMode = sandboxMode;
+    }
+    async send(request) {
+        const outputPath = await this.createOutputPath();
+        const sandboxMode = request.sandboxMode ?? this.sandboxMode;
+        const args = request.sessionId
+            ? this.buildResumeArgs(request, outputPath, sandboxMode)
+            : this.buildExecArgs(request, outputPath, sandboxMode);
+        const { stdout, stderr, code, timedOut } = await this.runCodex(args, request.cwd, request.remoteSessionId, request.publicSessionId, request.message);
+        try {
+            const sessionId = this.extractThreadId(stdout) ?? request.sessionId;
+            const output = await this.readOutput(outputPath) || this.extractAgentMessage(stdout);
+            if (sessionId && output) {
+                return {
+                    provider: "codex",
+                    sessionId,
+                    cwd: request.cwd,
+                    output,
+                };
+            }
+            if (code !== 0) {
+                throw new Error(this.formatProcessError(stdout, stderr, timedOut));
+            }
+            if (timedOut) {
+                throw new Error(this.formatTimeoutError());
+            }
+            if (!sessionId) {
+                throw new Error("Codex response did not include a session id.");
+            }
+            if (!output) {
+                throw new Error("Codex returned an empty response.");
+            }
+            return {
+                provider: "codex",
+                sessionId,
+                cwd: request.cwd,
+                output,
+            };
+        }
+        finally {
+            await fs.rm(outputPath, { force: true }).catch(() => undefined);
+            await fs.rm(path.dirname(outputPath), { recursive: true, force: true }).catch(() => undefined);
+        }
+    }
+    async createOutputPath() {
+        const dir = await fs.mkdtemp(path.join(os.tmpdir(), "remoteagent-codex-"));
+        return path.join(dir, `${randomUUID()}.txt`);
+    }
+    buildExecArgs(request, outputPath, sandboxMode) {
+        const args = [
+            "exec",
+            "--json",
+            "--skip-git-repo-check",
+        ];
+        if (request.model) {
+            args.push("-m", request.model);
+        }
+        this.appendSandboxArgs(args, sandboxMode);
+        args.push("-o", outputPath, "-C", request.cwd);
+        this.appendPromptStdinArg(args);
+        return args;
+    }
+    buildResumeArgs(request, outputPath, sandboxMode) {
+        const args = [
+            "exec",
+            "resume",
+            "--json",
+            "--skip-git-repo-check",
+        ];
+        if (request.model) {
+            args.push("-m", request.model);
+        }
+        this.appendSandboxArgs(args, sandboxMode);
+        args.push("-o", outputPath, request.sessionId);
+        this.appendPromptStdinArg(args);
+        return args;
+    }
+    appendPromptStdinArg(args) {
+        args.push("--", "-");
+    }
+    appendSandboxArgs(args, sandboxMode) {
+        if (!sandboxMode || sandboxMode === "read-only") {
+            return;
+        }
+        if (sandboxMode === "workspace-write") {
+            args.push("--full-auto");
+            return;
+        }
+        if (sandboxMode === "danger-full-access") {
+            args.push("--dangerously-bypass-approvals-and-sandbox");
+        }
+    }
+    runCodex(args, cwd, remoteSessionId, publicSessionId, input) {
+        return spawnWithPlatformShell(this.codexBin, args, cwd, this.currentTimeoutMs(), input, remoteSessionId, {
+            REMOTEAGENT_SESSION_ID: remoteSessionId,
+            REMOTEAGENT_PUBLIC_SESSION_ID: publicSessionId ?? "",
+            REMOTEAGENT_WORKSPACE: cwd,
+        });
+    }
+    extractThreadId(stdout) {
+        for (const line of stdout.split(/\r?\n/)) {
+            if (!line.startsWith("{")) {
+                continue;
+            }
+            try {
+                const event = JSON.parse(line);
+                if (event.thread_id) {
+                    return event.thread_id;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        return undefined;
+    }
+    extractAgentMessage(stdout) {
+        let latest = "";
+        for (const line of stdout.split(/\r?\n/)) {
+            if (!line.startsWith("{")) {
+                continue;
+            }
+            try {
+                const event = JSON.parse(line);
+                if (event.type === "item.completed" && event.item?.type === "agent_message" && typeof event.item.text === "string") {
+                    latest = event.item.text.trim();
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        return latest;
+    }
+    async readOutput(outputPath) {
+        return (await fs.readFile(outputPath, "utf8").catch(() => "")).trim();
+    }
+    formatProcessError(stdout, stderr, timedOut = false) {
+        const structured = this.extractStructuredError(stdout, stderr);
+        if (structured) {
+            return structured;
+        }
+        const text = this.extractPlainTextError(stdout, stderr);
+        if (text) {
+            return text;
+        }
+        return timedOut
+            ? this.formatTimeoutError()
+            : "Codex execution failed without any output.";
+    }
+    extractStructuredError(stdout, stderr) {
+        const messages = [];
+        for (const line of stdout.split(/\r?\n/)) {
+            if (!line.startsWith("{")) {
+                continue;
+            }
+            try {
+                const event = JSON.parse(line);
+                if (event.type === "error" && typeof event.message === "string" && event.message.trim()) {
+                    messages.push(event.message.trim());
+                }
+                if (event.is_error) {
+                    if (Array.isArray(event.errors)) {
+                        for (const entry of event.errors) {
+                            if (typeof entry === "string" && entry.trim()) {
+                                messages.push(entry.trim());
+                            }
+                        }
+                    }
+                    if (typeof event.error === "string" && event.error.trim()) {
+                        messages.push(event.error.trim());
+                    }
+                    else if (event.error && typeof event.error === "object" && typeof event.error.message === "string" && event.error.message.trim()) {
+                        messages.push(event.error.message.trim());
+                    }
+                    if (typeof event.message === "string" && event.message.trim()) {
+                        messages.push(event.message.trim());
+                    }
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        for (const chunk of [stderr, stdout]) {
+            const trimmed = chunk.trim();
+            if (!trimmed) {
+                continue;
+            }
+            try {
+                const parsed = JSON.parse(trimmed);
+                if (typeof parsed.message === "string" && parsed.message.trim()) {
+                    messages.push(parsed.message.trim());
+                }
+                if (parsed.error && typeof parsed.error.message === "string" && parsed.error.message.trim()) {
+                    messages.push(parsed.error.message.trim());
+                }
+                if (Array.isArray(parsed.errors)) {
+                    for (const entry of parsed.errors) {
+                        if (typeof entry === "string" && entry.trim()) {
+                            messages.push(entry.trim());
+                        }
+                    }
+                }
+            }
+            catch {
+                // ignore non-JSON blocks
+            }
+        }
+        return messages.at(-1);
+    }
+    extractPlainTextError(stdout, stderr) {
+        const sanitize = (value) => value
+            .split(/\r?\n/)
+            .filter((line) => !line.trim().startsWith("{"))
+            .join("\n")
+            .trim();
+        return [sanitize(stderr), sanitize(stdout)]
+            .filter(Boolean)
+            .join("\n")
+            .trim();
+    }
+    formatTimeoutError() {
+        return `Codex timed out after ${Math.round(this.currentTimeoutMs() / 1000)}s without returning a final reply.`;
+    }
+    currentTimeoutMs() {
+        return typeof this.timeoutMs === "function" ? this.timeoutMs() : this.timeoutMs;
+    }
+}

package/dist/adapters/provider-adapter.js

@@ -0,0 +1 @@
+export {};

package/dist/adapters/shell-adapter.js

@@ -0,0 +1,44 @@
+import process from "node:process";
+import { promisify } from "node:util";
+import { exec as execCallback } from "node:child_process";
+const exec = promisify(execCallback);
+export class ShellAdapter {
+    provider;
+    command;
+    timeoutMs;
+    constructor(provider, command, timeoutMs) {
+        this.provider = provider;
+        this.command = command;
+        this.timeoutMs = timeoutMs;
+    }
+    async send(request) {
+        const env = {
+            ...process.env,
+            BRIDGE_PROVIDER: this.provider,
+            BRIDGE_BOT_ID: request.botId ?? "",
+            BRIDGE_CHAT_ID: request.chatId,
+            BRIDGE_SESSION_ID: request.sessionId ?? "",
+            BRIDGE_PUBLIC_SESSION_ID: request.publicSessionId ?? "",
+            BRIDGE_CWD: request.cwd,
+            BRIDGE_MESSAGE: request.message,
+        };
+        const { stdout, stderr } = await exec(this.command, {
+            env,
+            timeout: this.currentTimeoutMs(),
+            maxBuffer: 1024 * 1024,
+        });
+        const output = stdout.trim() || stderr.trim();
+        if (!output) {
+            throw new Error(`${this.provider} command completed without output`);
+        }
+        return {
+            provider: this.provider,
+            sessionId: request.sessionId ?? "",
+            cwd: request.cwd,
+            output,
+        };
+    }
+    currentTimeoutMs() {
+        return typeof this.timeoutMs === "function" ? this.timeoutMs() : this.timeoutMs;
+    }
+}

package/dist/adapters/windows-shell.js

@@ -0,0 +1,111 @@
+import process from "node:process";
+import path from "node:path";
+import os from "node:os";
+import { execFile, spawn } from "node:child_process";
+const activeCommands = new Map();
+const CHILD_ENV_BLOCKED_PREFIXES = ["TELEGRAM_"];
+function buildChildEnv(extraEnv) {
+    const env = { ...process.env };
+    for (const key of Object.keys(env)) {
+        if (CHILD_ENV_BLOCKED_PREFIXES.some((prefix) => key.startsWith(prefix))) {
+            delete env[key];
+        }
+    }
+    const dataDir = process.env.DATA_DIR?.trim() || path.join(os.homedir(), ".remoteagent");
+    env.REMOTEAGENT_DATA_DIR = dataDir;
+    env.REMOTEAGENT_SECRET_BIN = path.resolve(process.cwd(), "dist", "secret-helper.js");
+    if (extraEnv) {
+        Object.assign(env, extraEnv);
+    }
+    return env;
+}
+export function spawnWithPlatformShell(bin, args, cwd, timeoutMs, input, executionKey, extraEnv) {
+    return new Promise((resolve, reject) => {
+        const command = process.platform === "win32"
+            ? spawn("cmd.exe", ["/d", "/c", "call", bin, ...args], {
+                cwd,
+                env: buildChildEnv(extraEnv),
+            })
+            : spawn(bin, args, {
+                cwd,
+                env: buildChildEnv(extraEnv),
+                detached: true,
+            });
+        if (executionKey) {
+            activeCommands.set(executionKey, command);
+        }
+        let stdout = "";
+        let stderr = "";
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            terminateProcessTree(command);
+        }, timeoutMs);
+        command.stdout.on("data", (chunk) => {
+            stdout += chunk.toString();
+        });
+        command.stderr.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        command.on("error", (error) => {
+            clearTimeout(timer);
+            if (executionKey && activeCommands.get(executionKey) === command) {
+                activeCommands.delete(executionKey);
+            }
+            reject(error);
+        });
+        if (input !== undefined) {
+            command.stdin.write(input);
+        }
+        command.stdin.end();
+        command.on("close", (code) => {
+            clearTimeout(timer);
+            if (executionKey && activeCommands.get(executionKey) === command) {
+                activeCommands.delete(executionKey);
+            }
+            resolve({ stdout, stderr, code, timedOut });
+        });
+    });
+}
+export function stopSpawnedExecution(executionKey) {
+    const command = activeCommands.get(executionKey);
+    if (!command) {
+        return false;
+    }
+    return terminateProcessTree(command);
+}
+export function terminateAllSpawnedExecutions() {
+    let stopped = 0;
+    for (const [key, command] of activeCommands.entries()) {
+        if (terminateProcessTree(command)) {
+            stopped += 1;
+        }
+        activeCommands.delete(key);
+    }
+    return stopped;
+}
+function terminateProcessTree(command) {
+    if (!command.pid) {
+        return false;
+    }
+    try {
+        if (process.platform === "win32") {
+            execFile("taskkill", ["/pid", String(command.pid), "/t", "/f"], () => undefined);
+        }
+        else {
+            process.kill(-command.pid, "SIGTERM");
+            setTimeout(() => {
+                try {
+                    process.kill(-command.pid, "SIGKILL");
+                }
+                catch {
+                    // Process group already exited.
+                }
+            }, 3000).unref();
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}