remcodex 0.1.0-beta.1

package/dist/server/src/controllers/session.controller.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSessionRouter = createSessionRouter;
+const express_1 = require("express");
+function createSessionRouter(sessionManager, eventStore, projectManager, codexRolloutSync, sessionTimeline) {
+    const router = (0, express_1.Router)();
+    router.get("/", (_request, response) => {
+        const items = sessionManager.listSessions().map((session) => ({
+            sessionId: session.id,
+            title: session.title,
+            projectId: session.project_id,
+            status: session.status,
+            liveBusy: sessionManager.isLiveBusy(session.id),
+            codexThreadId: session.codex_thread_id,
+            sourceKind: session.source_kind,
+            sourceRolloutPath: session.source_rollout_path,
+            sourceThreadId: session.source_thread_id,
+            sourceRolloutHasOpenTurn: session.source_rollout_has_open_turn === 1,
+            pendingApproval: sessionManager.getPendingApproval(session.id),
+            lastEventAt: session.last_event_at,
+            lastAssistantContent: session.last_assistant_content,
+            lastCommand: session.last_command,
+            eventCount: session.event_count,
+            createdAt: session.created_at,
+            updatedAt: session.updated_at,
+        }));
+        response.json({ items });
+    });
+    router.post("/import-codex", (request, response, next) => {
+        try {
+            const body = request.body;
+            const result = codexRolloutSync.importRollout(body.rolloutPath ?? "");
+            response.status(result.imported ? 201 : 200).json(result);
+        }
+        catch (error) {
+            next(error);
+        }
+    });
+    router.post("/", (request, response, next) => {
+        try {
+            const body = request.body;
+            const session = sessionManager.createSession({
+                title: body.title,
+                projectId: body.projectId ?? "",
+            });
+            response.status(201).json({
+                sessionId: session.id,
+                status: session.status,
+            });
+        }
+        catch (error) {
+            next(error);
+        }
+    });
+    router.get("/:sessionId", (request, response, next) => {
+        try {
+            const session = sessionManager.getSession(request.params.sessionId);
+            if (!session) {
+                response.status(404).json({ error: "Session not found." });
+                return;
+            }
+            const project = projectManager.getProject(session.project_id);
+            response.json({
+                sessionId: session.id,
+                title: session.title,
+                projectId: session.project_id,
+                projectName: project?.name ?? null,
+                projectPath: project?.path ?? null,
+                status: session.status,
+                liveBusy: sessionManager.isLiveBusy(session.id),
+                pid: session.pid,
+                codexThreadId: session.codex_thread_id,
+                sourceKind: session.source_kind,
+                sourceRolloutPath: session.source_rollout_path,
+                sourceThreadId: session.source_thread_id,
+                sourceRolloutHasOpenTurn: session.source_rollout_has_open_turn === 1,
+                pendingApproval: sessionManager.getPendingApproval(session.id),
+                createdAt: session.created_at,
+                updatedAt: session.updated_at,
+            });
+        }
+        catch (error) {
+            next(error);
+        }
+    });
+    router.get("/:sessionId/events", (request, response, next) => {
+        try {
+            const after = Number.parseInt(String(request.query.after ?? request.query.cursor ?? "0"), 10);
+            const before = Number.parseInt(String(request.query.before ?? "0"), 10);
+            const limit = Number.parseInt(String(request.query.limit ?? "200"), 10);
+            const safeAfter = Number.isNaN(after) ? 0 : after;
+            const safeBefore = Number.isNaN(before) ? 0 : before;
+            const safeLimit = Number.isNaN(limit) ? 200 : limit;
+            if (!sessionManager.hasSession(request.params.sessionId)) {
+                response.status(404).json({ error: "Session not found." });
+                return;
+            }
+            const data = eventStore.list(request.params.sessionId, {
+                after: safeAfter,
+                before: safeBefore,
+                limit: safeLimit,
+            });
+            response.json(data);
+        }
+        catch (error) {
+            next(error);
+        }
+    });
+    router.get("/:sessionId/timeline", (request, response, next) => {
+        try {
+            const after = Number.parseInt(String(request.query.after ?? request.query.cursor ?? "0"), 10);
+            const before = Number.parseInt(String(request.query.before ?? "0"), 10);
+            const limit = Number.parseInt(String(request.query.limit ?? "200"), 10);
+            const safeAfter = Number.isNaN(after) ? 0 : after;
+            const safeBefore = Number.isNaN(before) ? 0 : before;
+            const safeLimit = Number.isNaN(limit) ? 200 : limit;
+            if (!sessionManager.hasSession(request.params.sessionId)) {
+                response.status(404).json({ error: "Session not found." });
+                return;
+            }
+            const data = sessionTimeline.list(request.params.sessionId, {
+                after: safeAfter,
+                before: safeBefore,
+                limit: safeLimit,
+            });
+            response.json(data);
+        }
+        catch (error) {
+            next(error);
+        }
+    });
+    router.post("/:sessionId/sync", (request, response, next) => {
+        try {
+            const result = codexRolloutSync.syncImportedSession(request.params.sessionId);
+            response.json(result);
+        }
+        catch (error) {
+            next(error);
+        }
+    });
+    router.post("/:sessionId/stop", (request, response, next) => {
+        try {
+            const result = sessionManager.stopSession(request.params.sessionId);
+            response.json(result);
+        }
+        catch (error) {
+            next(error);
+        }
+    });
+    router.post("/:sessionId/approvals/:requestId", (request, response, next) => {
+        try {
+            const body = request.body;
+            const decision = body.decision === "accept" ||
+                body.decision === "acceptForSession" ||
+                body.decision === "decline"
+                ? body.decision
+                : null;
+            if (!decision) {
+                response.status(400).json({ error: "decision is required." });
+                return;
+            }
+            const requestId = String(request.params.requestId || "").trim();
+            if (!requestId) {
+                response.status(400).json({ error: "requestId is invalid." });
+                return;
+            }
+            const result = sessionManager.resolveApproval(request.params.sessionId, requestId, decision);
+            response.json(result);
+        }
+        catch (error) {
+            next(error);
+        }
+    });
+    return router;
+}

package/dist/server/src/db/client.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDatabase = createDatabase;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+function createDatabase(file) {
+    return new better_sqlite3_1.default(file);
+}

package/dist/server/src/db/migrations.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runMigrations = runMigrations;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+function ensureColumn(db, table, column, definition) {
+    const rows = db.prepare(`PRAGMA table_info(${table})`).all();
+    if (rows.some((row) => row.name === column)) {
+        return;
+    }
+    db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
+}
+function runMigrations(db) {
+    const schemaFile = node_path_1.default.join(process.cwd(), "server", "src", "db", "schema.sql");
+    const schema = (0, node_fs_1.readFileSync)(schemaFile, "utf8");
+    db.exec(schema);
+    ensureColumn(db, "sessions", "source_kind", "TEXT NOT NULL DEFAULT 'native'");
+    ensureColumn(db, "sessions", "source_rollout_path", "TEXT");
+    ensureColumn(db, "sessions", "source_thread_id", "TEXT");
+    ensureColumn(db, "sessions", "source_sync_cursor", "INTEGER");
+    ensureColumn(db, "sessions", "source_last_synced_at", "TEXT");
+    ensureColumn(db, "sessions", "source_rollout_has_open_turn", "INTEGER NOT NULL DEFAULT 0");
+    // Older imports mapped external open turns to status=running; that is not local runner state.
+    db.exec(`UPDATE sessions
+     SET status = 'waiting_input'
+     WHERE source_kind = 'imported_rollout'
+       AND pid IS NULL
+       AND status = 'running'`);
+}

package/dist/server/src/gateways/ws.gateway.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSessionGateway = registerSessionGateway;
+const ws_1 = require("ws");
+function registerSessionGateway(server, options) {
+    const wss = new ws_1.WebSocketServer({ noServer: true });
+    server.on("upgrade", (request, socket, head) => {
+        const url = new URL(request.url ?? "/", `http://${request.headers.host}`);
+        const matched = url.pathname.match(/^\/ws\/sessions\/([^/]+)$/);
+        if (!matched) {
+            socket.destroy();
+            return;
+        }
+        const sessionId = matched[1];
+        if (!options.sessionManager.hasSession(sessionId)) {
+            socket.destroy();
+            return;
+        }
+        wss.handleUpgrade(request, socket, head, (ws) => {
+            const sessionSocket = ws;
+            sessionSocket.sessionId = sessionId;
+            sessionSocket.isAlive = true;
+            wss.emit("connection", sessionSocket, request);
+        });
+    });
+    wss.on("connection", (ws) => {
+        const sessionSocket = ws;
+        const sessionId = sessionSocket.sessionId;
+        if (!sessionId) {
+            ws.close();
+            return;
+        }
+        const unsubscribe = options.eventStore.subscribe(sessionId, (event) => {
+            if (ws.readyState === ws_1.WebSocket.OPEN) {
+                ws.send(JSON.stringify(event));
+            }
+        });
+        const heartbeat = setInterval(() => {
+            if (!sessionSocket.isAlive) {
+                ws.terminate();
+                return;
+            }
+            sessionSocket.isAlive = false;
+            ws.ping();
+        }, 30000);
+        heartbeat.unref();
+        ws.on("pong", () => {
+            sessionSocket.isAlive = true;
+        });
+        ws.on("close", () => {
+            clearInterval(heartbeat);
+            unsubscribe();
+        });
+        ws.on("error", () => {
+            clearInterval(heartbeat);
+            unsubscribe();
+            ws.close();
+        });
+    });
+}

package/dist/server/src/services/codex-app-server-runner.js

@@ -0,0 +1,363 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodexAppServerRunner = void 0;
+const node_child_process_1 = require("node:child_process");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+class CodexAppServerRunner {
+    command;
+    cwd;
+    process = null;
+    jsonListeners = new Set();
+    textListeners = new Set();
+    exitListeners = new Set();
+    pendingRequests = new Map();
+    stdoutBuffer = "";
+    requestId = 1;
+    finalized = false;
+    stopTimer = null;
+    constructor(command, cwd) {
+        this.command = command;
+        this.cwd = cwd;
+    }
+    start(prompt, threadId, launch) {
+        this.process = (0, node_child_process_1.spawn)(this.command, ["app-server", "--listen", "stdio://"], {
+            cwd: this.cwd,
+            env: process.env,
+            stdio: "pipe",
+        });
+        if (!this.process.pid) {
+            throw new Error("Failed to start codex app-server process.");
+        }
+        this.process.stdout.on("data", (chunk) => {
+            this.handleStdout(chunk.toString("utf8"));
+        });
+        this.process.stderr.on("data", (chunk) => {
+            this.emitText("stderr", chunk.toString("utf8"));
+        });
+        this.process.on("close", (exitCode) => {
+            this.clearStopTimer();
+            this.flushStdoutRemainder();
+            this.rejectPendingRequests(new Error("Codex app-server closed before replying to all requests."));
+            this.process = null;
+            if (!this.finalized) {
+                this.finalized = true;
+                this.exitListeners.forEach((listener) => listener(exitCode));
+            }
+        });
+        this.process.on("error", (error) => {
+            this.emitText("stderr", `Failed to spawn Codex app-server: ${error.message}`);
+        });
+        void this.bootstrap(prompt, threadId, launch).catch((error) => {
+            this.emitText("stderr", `Failed to initialize Codex app-server: ${this.messageOf(error)}`);
+            this.finish(1);
+        });
+        return this.process.pid;
+    }
+    stop() {
+        if (!this.process) {
+            return;
+        }
+        this.process.stdin.end();
+        this.process.kill("SIGINT");
+        this.stopTimer = setTimeout(() => {
+            this.process?.kill("SIGTERM");
+        }, 1500);
+        this.stopTimer.unref();
+    }
+    respond(requestId, result) {
+        if (!this.process || !Number.isFinite(requestId)) {
+            return false;
+        }
+        this.respondJsonRpc(requestId, result);
+        return true;
+    }
+    onJsonEvent(listener) {
+        this.jsonListeners.add(listener);
+        return () => {
+            this.jsonListeners.delete(listener);
+        };
+    }
+    onText(listener) {
+        this.textListeners.add(listener);
+        return () => {
+            this.textListeners.delete(listener);
+        };
+    }
+    onExit(listener) {
+        this.exitListeners.add(listener);
+        return () => {
+            this.exitListeners.delete(listener);
+        };
+    }
+    isAlive() {
+        return this.process !== null;
+    }
+    async bootstrap(prompt, threadId, launch) {
+        await this.request("initialize", {
+            clientInfo: {
+                name: "remote-agent-console",
+                version: "0.1.0",
+            },
+            capabilities: {
+                experimentalApi: true,
+            },
+        });
+        this.notify("initialized");
+        const approvalPolicy = "on-request";
+        const sandboxMode = launch?.sandbox ?? "workspace-write";
+        const config = this.buildConfig(launch);
+        const threadResult = (threadId
+            ? await this.request("thread/resume", {
+                threadId,
+                cwd: this.cwd,
+                approvalPolicy,
+                sandbox: sandboxMode,
+                config,
+                persistExtendedHistory: true,
+            })
+            : await this.request("thread/start", {
+                cwd: this.cwd,
+                approvalPolicy,
+                sandbox: sandboxMode,
+                config,
+                experimentalRawEvents: false,
+                persistExtendedHistory: true,
+            }));
+        const resolvedThreadId = threadResult.thread?.id ?? threadId;
+        if (!resolvedThreadId) {
+            throw new Error("Codex app-server did not return a thread id.");
+        }
+        await this.request("turn/start", {
+            threadId: resolvedThreadId,
+            input: [
+                {
+                    type: "text",
+                    text: prompt,
+                    text_elements: [],
+                },
+            ],
+            approvalPolicy,
+            sandboxPolicy: this.buildSandboxPolicy(sandboxMode, launch),
+            model: launch?.model ?? null,
+            effort: launch?.reasoningEffort ?? null,
+        });
+    }
+    buildConfig(launch) {
+        const config = {};
+        if (launch?.profile) {
+            config.profile = launch.profile;
+        }
+        if (launch?.enableFeatures?.length) {
+            for (const name of launch.enableFeatures) {
+                config[`features.${name}`] = true;
+            }
+        }
+        if (launch?.disableFeatures?.length) {
+            for (const name of launch.disableFeatures) {
+                config[`features.${name}`] = false;
+            }
+        }
+        return Object.keys(config).length > 0 ? config : null;
+    }
+    buildSandboxPolicy(sandboxMode, launch) {
+        if (sandboxMode === "read-only") {
+            return {
+                type: "readOnly",
+                access: {
+                    type: "fullAccess",
+                },
+                networkAccess: false,
+            };
+        }
+        if (sandboxMode === "danger-full-access") {
+            return {
+                type: "dangerFullAccess",
+            };
+        }
+        return {
+            type: "workspaceWrite",
+            writableRoots: this.workspaceWritableRoots(launch?.additionalWritableRoots),
+            readOnlyAccess: {
+                type: "fullAccess",
+            },
+            networkAccess: false,
+            excludeTmpdirEnvVar: false,
+            excludeSlashTmp: false,
+        };
+    }
+    workspaceWritableRoots(additionalRoots) {
+        const roots = new Set();
+        roots.add(this.cwd);
+        for (const root of additionalRoots ?? []) {
+            if (typeof root === "string" && root.trim()) {
+                roots.add(root.trim());
+            }
+        }
+        roots.add(node_path_1.default.join(node_os_1.default.homedir(), ".codex", "memories"));
+        return [...roots];
+    }
+    request(method, params) {
+        const id = this.requestId++;
+        const request = {
+            jsonrpc: "2.0",
+            id,
+            method,
+            params,
+        };
+        return new Promise((resolve, reject) => {
+            this.pendingRequests.set(id, { resolve, reject });
+            this.writeJson(request);
+        });
+    }
+    notify(method, params) {
+        this.writeJson({
+            jsonrpc: "2.0",
+            method,
+            params,
+        });
+    }
+    writeJson(message) {
+        if (!this.process) {
+            throw new Error("Codex app-server process is not running.");
+        }
+        this.process.stdin.write(`${JSON.stringify(message)}\n`);
+    }
+    handleStdout(chunk) {
+        this.stdoutBuffer += chunk;
+        const lines = this.stdoutBuffer.split(/\r?\n/);
+        this.stdoutBuffer = lines.pop() ?? "";
+        for (const line of lines) {
+            this.handleJsonLine(line);
+        }
+    }
+    flushStdoutRemainder() {
+        if (!this.stdoutBuffer.trim()) {
+            this.stdoutBuffer = "";
+            return;
+        }
+        this.handleJsonLine(this.stdoutBuffer);
+        this.stdoutBuffer = "";
+    }
+    handleJsonLine(line) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            return;
+        }
+        try {
+            const message = JSON.parse(trimmed);
+            this.handleJsonMessage(message);
+        }
+        catch {
+            this.emitText("stdout", trimmed);
+        }
+    }
+    handleJsonMessage(message) {
+        if (!message || typeof message !== "object") {
+            return;
+        }
+        if ("id" in message && typeof message.id === "number" && !("method" in message)) {
+            const response = message;
+            const pending = this.pendingRequests.get(message.id);
+            if (!pending) {
+                return;
+            }
+            this.pendingRequests.delete(message.id);
+            if (response.error) {
+                pending.reject(new Error(response.error.message || `JSON-RPC request failed (${message.id}).`));
+                return;
+            }
+            pending.resolve(response.result);
+            return;
+        }
+        if (!("method" in message) || typeof message.method !== "string") {
+            return;
+        }
+        if ("id" in message && typeof message.id === "number") {
+            this.handleServerRequest(message);
+            return;
+        }
+        this.handleNotification(message);
+    }
+    handleServerRequest(message) {
+        this.jsonListeners.forEach((listener) => listener(message));
+        switch (message.method) {
+            case "item/commandExecution/requestApproval":
+            case "item/fileChange/requestApproval":
+            case "item/permissions/requestApproval":
+            case "execCommandApproval":
+            case "applyPatchApproval":
+                return;
+            default:
+                this.respondJsonRpcError(message.id, -32601, `Unsupported server request: ${message.method}`);
+        }
+    }
+    handleNotification(message) {
+        const method = message.method;
+        this.jsonListeners.forEach((listener) => listener(message));
+        if (method === "turn/completed") {
+            const params = message.params;
+            const turn = params?.turn;
+            this.finish(turn?.status === "failed" ? 1 : 0);
+        }
+    }
+    respondJsonRpc(id, result) {
+        this.writeJson({
+            jsonrpc: "2.0",
+            id,
+            result,
+        });
+    }
+    respondJsonRpcError(id, code, message) {
+        this.writeJson({
+            jsonrpc: "2.0",
+            id,
+            error: {
+                code,
+                message,
+            },
+        });
+    }
+    finish(exitCode) {
+        if (this.finalized) {
+            return;
+        }
+        this.finalized = true;
+        this.exitListeners.forEach((listener) => listener(exitCode));
+        if (!this.process) {
+            return;
+        }
+        this.process.stdin.end();
+        this.process.kill("SIGTERM");
+    }
+    rejectPendingRequests(error) {
+        for (const pending of this.pendingRequests.values()) {
+            pending.reject(error);
+        }
+        this.pendingRequests.clear();
+    }
+    clearStopTimer() {
+        if (!this.stopTimer) {
+            return;
+        }
+        clearTimeout(this.stopTimer);
+        this.stopTimer = null;
+    }
+    emitText(stream, text) {
+        if (!text) {
+            return;
+        }
+        const normalized = text.trimEnd();
+        if (!normalized) {
+            return;
+        }
+        this.textListeners.forEach((listener) => listener(stream, normalized));
+    }
+    messageOf(error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+}
+exports.CodexAppServerRunner = CodexAppServerRunner;