remcodex 0.1.0-beta.1

package/dist/server/src/cli.js

@@ -0,0 +1,270 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = require("node:fs");
+const node_child_process_1 = require("node:child_process");
+const node_os_1 = require("node:os");
+const node_path_1 = __importDefault(require("node:path"));
+const app_1 = require("./app");
+const command_1 = require("./utils/command");
+function print(message = "") {
+    process.stdout.write(`${message}\n`);
+}
+function printError(message = "") {
+    process.stderr.write(`${message}\n`);
+}
+function readPackageVersion() {
+    try {
+        const packageRoot = (0, app_1.resolvePackageRoot)();
+        const packageJson = JSON.parse((0, node_fs_1.readFileSync)(node_path_1.default.join(packageRoot, "package.json"), "utf8"));
+        return typeof packageJson.version === "string" ? packageJson.version : "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+function isExecutableFile(filePath) {
+    try {
+        (0, node_fs_1.accessSync)(filePath, node_fs_1.constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function commandExists(command) {
+    const resolved = (0, command_1.resolveExecutable)(command);
+    const ok = Boolean(resolved) &&
+        (resolved.includes(node_path_1.default.sep) || node_path_1.default.isAbsolute(resolved)) &&
+        isExecutableFile(resolved);
+    return { ok, resolved };
+}
+function parseFlags(argv) {
+    const flags = {
+        noOpen: false,
+    };
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === "--no-open") {
+            flags.noOpen = true;
+            continue;
+        }
+        if (token === "--port") {
+            const value = argv[index + 1];
+            const parsed = Number.parseInt(value ?? "", 10);
+            if (Number.isFinite(parsed) && parsed > 0) {
+                flags.port = parsed;
+            }
+            index += 1;
+            continue;
+        }
+        if (token === "--db" || token === "--database") {
+            const value = argv[index + 1];
+            if (value) {
+                flags.databasePath = node_path_1.default.resolve(value);
+            }
+            index += 1;
+        }
+    }
+    return flags;
+}
+function getLanAddresses() {
+    const interfaces = (0, node_os_1.networkInterfaces)();
+    const addresses = [];
+    Object.values(interfaces).forEach((entries) => {
+        entries?.forEach((entry) => {
+            if (entry.family === "IPv4" && !entry.internal) {
+                addresses.push(entry.address);
+            }
+        });
+    });
+    return Array.from(new Set(addresses));
+}
+function openBrowser(url) {
+    let command = "";
+    let args = [];
+    if (process.platform === "darwin") {
+        command = "open";
+        args = [url];
+    }
+    else if (process.platform === "win32") {
+        command = "cmd";
+        args = ["/c", "start", "", url];
+    }
+    else {
+        command = "xdg-open";
+        args = [url];
+    }
+    try {
+        const child = (0, node_child_process_1.spawn)(command, args, {
+            stdio: "ignore",
+            detached: true,
+        });
+        child.unref();
+    }
+    catch {
+        /* ignore */
+    }
+}
+function usage() {
+    print("RemCodex");
+    print("");
+    print("Usage:");
+    print("  remcodex                Start the local web app");
+    print("  remcodex start          Start the local web app");
+    print("  remcodex doctor         Check local environment");
+    print("  remcodex version        Show version");
+    print("");
+    print("Options:");
+    print("  --port <number>         Preferred port");
+    print("  --db <path>             Use a specific SQLite database path");
+    print("  --no-open               Do not open a browser automatically");
+}
+async function runDoctor(flags) {
+    const version = readPackageVersion();
+    const rawCodexCommand = process.env.CODEX_COMMAND ?? "codex";
+    const codex = commandExists(rawCodexCommand);
+    const packageRoot = (0, app_1.resolvePackageRoot)();
+    const databasePath = flags.databasePath ?? process.env.DATABASE_PATH ?? (0, app_1.resolveDefaultDatabasePath)();
+    const databaseDir = node_path_1.default.dirname(databasePath);
+    const databaseDirExists = (0, node_fs_1.existsSync)(databaseDir);
+    const databaseDirWritable = databaseDirExists && (() => {
+        try {
+            (0, node_fs_1.accessSync)(databaseDir, node_fs_1.constants.W_OK);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    })();
+    print(`RemCodex v${version}`);
+    print("");
+    print(`Node: ${process.version}`);
+    print(`Package root: ${packageRoot}`);
+    print(`Database path: ${databasePath}`);
+    print(`Database dir: ${databaseDirExists ? (databaseDirWritable ? "writable" : "not writable") : "missing (will be created on first start)"}`);
+    print(`Default project root: ${process.env.PROJECT_ROOTS?.trim() || (0, node_os_1.homedir)()}`);
+    print(`Codex command: ${rawCodexCommand}`);
+    print(`Codex resolved: ${codex.resolved}`);
+    print(`Codex available: ${codex.ok ? "yes" : "no"}`);
+    if (!codex.ok) {
+        printError("");
+        printError("Codex CLI was not found in PATH.");
+        printError("Install Codex first, or set CODEX_COMMAND to the correct executable.");
+        return 1;
+    }
+    print("");
+    print("Environment looks good.");
+    return 0;
+}
+async function runStart(flags) {
+    const version = readPackageVersion();
+    const rawCodexCommand = process.env.CODEX_COMMAND ?? "codex";
+    const codex = commandExists(rawCodexCommand);
+    if (!codex.ok) {
+        printError("Codex CLI was not found in PATH.");
+        printError("Install Codex first, or set CODEX_COMMAND to the correct executable.");
+        return 1;
+    }
+    const preferredPort = flags.port ?? Number.parseInt(process.env.PORT ?? "3000", 10);
+    const codexMode = process.env.CODEX_MODE === "exec-json" ? "exec-json" : "app-server";
+    let started = null;
+    let activePort = preferredPort;
+    for (let offset = 0; offset < 20; offset += 1) {
+        const candidate = preferredPort + offset;
+        try {
+            started = await (0, app_1.startRemCodexServer)({
+                port: candidate,
+                databasePath: flags.databasePath,
+                codexCommand: rawCodexCommand,
+                codexMode,
+                logStartup: false,
+            });
+            activePort = candidate;
+            break;
+        }
+        catch (error) {
+            const code = typeof error === "object" && error && "code" in error ? String(error.code) : "";
+            if (code === "EADDRINUSE") {
+                continue;
+            }
+            throw error;
+        }
+    }
+    if (!started) {
+        printError(`Could not find an available port starting from ${preferredPort}.`);
+        return 1;
+    }
+    const localUrl = `http://127.0.0.1:${activePort}`;
+    const lanUrls = getLanAddresses().map((address) => `http://${address}:${activePort}`);
+    print(`RemCodex v${version}`);
+    print("");
+    print("Starting local workspace...");
+    print(`Codex: ${codex.resolved}`);
+    print(`Mode: ${started.codexMode}`);
+    print(`Database: ${started.databasePath}`);
+    print("");
+    print(`Local: ${localUrl}`);
+    lanUrls.forEach((url) => {
+        print(`LAN:   ${url}`);
+    });
+    if (!flags.noOpen) {
+        openBrowser(localUrl);
+        print("");
+        print("Opening browser...");
+    }
+    const shutdown = async () => {
+        process.off("SIGINT", shutdown);
+        process.off("SIGTERM", shutdown);
+        try {
+            await started?.stop();
+        }
+        finally {
+            process.exit(0);
+        }
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    return await new Promise((resolve) => {
+        started?.server.on("close", () => resolve(0));
+    });
+}
+async function main() {
+    const argv = process.argv.slice(2);
+    if (argv.includes("--version") || argv.includes("-v")) {
+        print(readPackageVersion());
+        return;
+    }
+    if (argv.includes("--help") || argv.includes("-h")) {
+        usage();
+        return;
+    }
+    const command = argv[0] && !argv[0].startsWith("-") ? argv[0] : "start";
+    const flagArgs = command === "start" ? argv.slice(1) : argv;
+    const flags = parseFlags(flagArgs);
+    switch (command) {
+        case "start":
+            process.exitCode = await runStart(flags);
+            return;
+        case "doctor":
+            process.exitCode = await runDoctor(flags);
+            return;
+        case "version":
+            print(readPackageVersion());
+            return;
+        case "help":
+            usage();
+            return;
+        default:
+            usage();
+            process.exitCode = 1;
+    }
+}
+void main().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    printError(message);
+    process.exitCode = 1;
+});

package/dist/server/src/controllers/codex-options.controller.js

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCodexOptionsRouter = createCodexOptionsRouter;
+const express_1 = require("express");
+const codex_ui_options_1 = require("../utils/codex-ui-options");
+const codex_quota_1 = require("../utils/codex-quota");
+const codex_status_1 = require("../utils/codex-status");
+function resolveRequestHost(request) {
+    const requestHostname = typeof request.hostname === "string" ? request.hostname.trim() : "";
+    if (requestHostname) {
+        return requestHostname;
+    }
+    const forwardedHost = request.headers["x-forwarded-host"];
+    const hostHeader = Array.isArray(forwardedHost)
+        ? forwardedHost[0]
+        : (typeof forwardedHost === "string" && forwardedHost.trim()
+            ? forwardedHost
+            : request.headers.host);
+    const normalized = typeof hostHeader === "string" ? hostHeader.trim().replace(/:\d+$/, "") : "";
+    return normalized || null;
+}
+function resolveCodexHosts(request) {
+    const fallbackHost = resolveRequestHost(request);
+    const rawHosts = (process.env.REMOTE_HOSTS ?? fallbackHost ?? "")
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean);
+    const hosts = Array.from(new Set(rawHosts));
+    const requestedActive = process.env.ACTIVE_REMOTE_HOST?.trim() || "";
+    const activeHost = requestedActive && hosts.includes(requestedActive)
+        ? requestedActive
+        : (hosts[0] ?? null);
+    return {
+        hosts,
+        activeHost,
+    };
+}
+function readNumberField(input) {
+    if (typeof input === "number" && Number.isFinite(input)) {
+        return input;
+    }
+    if (typeof input === "string" && input.trim()) {
+        const parsed = Number.parseFloat(input);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    return null;
+}
+function toRemainingPercent(input) {
+    const usedPercent = readNumberField(input);
+    if (usedPercent == null) {
+        return null;
+    }
+    return Math.max(0, Math.min(100, Math.round(100 - usedPercent)));
+}
+function formatRemainTime(input) {
+    const resetAt = readNumberField(input);
+    if (resetAt == null) {
+        return null;
+    }
+    const diffSec = Math.max(0, Math.floor(resetAt - Date.now() / 1000));
+    const hours = Math.floor(diffSec / 3600);
+    const minutes = Math.floor((diffSec % 3600) / 60);
+    return `${String(hours).padStart(2, "0")}:${String(minutes).padStart(2, "0")}`;
+}
+function formatResetDate(input) {
+    const resetAt = readNumberField(input);
+    if (resetAt == null) {
+        return null;
+    }
+    const date = new Date(resetAt * 1000);
+    return new Intl.DateTimeFormat("en-US", {
+        month: "numeric",
+        day: "numeric",
+    }).format(date);
+}
+function normalizeQuota(payload) {
+    const rateLimits = payload?.rateLimits && typeof payload.rateLimits === "object" ? payload.rateLimits : {};
+    const primary = rateLimits.primary && typeof rateLimits.primary === "object"
+        ? rateLimits.primary
+        : {};
+    const secondary = rateLimits.secondary && typeof rateLimits.secondary === "object"
+        ? rateLimits.secondary
+        : {};
+    return {
+        quota: {
+            hour: {
+                percent: toRemainingPercent(primary.used_percent),
+                remainTime: formatRemainTime(primary.resets_at),
+            },
+            week: {
+                percent: toRemainingPercent(secondary.used_percent),
+                resetDate: formatResetDate(secondary.resets_at),
+            },
+        },
+    };
+}
+function readRuntimeFailureHint(runtime) {
+    const hints = [];
+    if (runtime.sandboxMode === "read-only") {
+        hints.push("The current runtime is using a read-only sandbox. File writes and environment-changing commands are blocked.");
+    }
+    else if (runtime.sandboxMode === "workspace-write") {
+        hints.push("The current runtime is using a workspace-write sandbox. It can only write inside the current writable roots.");
+    }
+    if (!runtime.interactiveApprovalUi) {
+        hints.push(`The current ${runtime.executionMode} runtime path does not support interactive approval prompts.`);
+    }
+    if (runtime.workspaceRoot) {
+        hints.push(`The current workspace root is ${runtime.workspaceRoot}.`);
+    }
+    return hints;
+}
+function createCodexOptionsRouter(deps) {
+    const router = (0, express_1.Router)();
+    router.get("/mode", (_request, response) => {
+        response.json((0, codex_ui_options_1.resolveCodexUiOptions)());
+    });
+    router.get("/ui-options", (_request, response) => {
+        response.json((0, codex_ui_options_1.resolveCodexUiOptions)());
+    });
+    router.get("/status", (request, response) => {
+        const params = request.query;
+        let threadId = params.threadId?.trim() || "";
+        let cwd = params.cwd?.trim() || "";
+        if (params.sessionId?.trim()) {
+            const session = deps.sessionManager.getSession(params.sessionId.trim());
+            if (session) {
+                threadId = threadId || session.codex_thread_id || "";
+                if (threadId) {
+                    if (!cwd) {
+                        const project = deps.projectManager.getProject(session.project_id);
+                        cwd = project?.path || "";
+                    }
+                }
+                else {
+                    response.json({
+                        thread: null,
+                        source: "none",
+                        fetchedAt: new Date().toISOString(),
+                    });
+                    return;
+                }
+            }
+        }
+        const status = (0, codex_status_1.resolveCodexStatus)({
+            threadId: threadId || null,
+            cwd: cwd || null,
+            executionMode: deps.codexMode === "app-server" ? "codex app-server" : "codex exec --json",
+            interactiveApprovalUi: deps.codexMode === "app-server",
+        });
+        response.json({
+            ...status,
+            runtimeHints: readRuntimeFailureHint(status.runtime),
+        });
+    });
+    router.get("/quota", (request, response) => {
+        const params = request.query;
+        if (!params.sessionId?.trim()) {
+            response.status(400).json({ error: "sessionId is required." });
+            return;
+        }
+        const session = deps.sessionManager.getSession(params.sessionId.trim());
+        if (!session) {
+            response.status(404).json({ error: "Session not found." });
+            return;
+        }
+        let payload = deps.eventStore.latestQuota(session.id);
+        if (!payload) {
+            const project = deps.projectManager.getProject(session.project_id);
+            const restored = (0, codex_quota_1.resolveCodexQuotaSnapshot)({
+                threadId: session.codex_thread_id,
+                cwd: project?.path || null,
+            });
+            if (restored) {
+                deps.eventStore.append(session.id, {
+                    type: "token_count",
+                    turnId: null,
+                    messageId: null,
+                    callId: null,
+                    requestId: null,
+                    phase: null,
+                    stream: null,
+                    payload: restored,
+                });
+                payload = restored;
+            }
+        }
+        response.json(normalizeQuota(payload));
+    });
+    router.get("/hosts", (request, response) => {
+        response.json(resolveCodexHosts(request));
+    });
+    router.get("/importable-sessions", (_request, response) => {
+        response.json({
+            items: deps.codexRolloutSync.listImportableSessions(),
+        });
+    });
+    return router;
+}

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMessageRouter = createMessageRouter;
+const express_1 = require("express");
+const codex_launch_1 = require("../utils/codex-launch");
+function createMessageRouter(sessionManager) {
+    const router = (0, express_1.Router)({ mergeParams: true });
+    router.post("/", (request, response, next) => {
+        try {
+            const body = request.body;
+            const params = request.params;
+            const launch = (0, codex_launch_1.normalizeCodexExecLaunchInput)(body.codex);
+            const result = sessionManager.sendMessage(params.sessionId, body.content ?? "", launch);
+            response.json(result);
+        }
+        catch (error) {
+            next(error);
+        }
+    });
+    return router;
+}

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProjectRouter = createProjectRouter;
+const express_1 = require("express");
+function createProjectRouter(projectManager) {
+    const router = (0, express_1.Router)();
+    router.get("/", (_request, response) => {
+        const items = projectManager.listProjects().map((project) => ({
+            projectId: project.id,
+            name: project.name,
+            path: project.path,
+            createdAt: project.created_at,
+        }));
+        response.json({ items });
+    });
+    router.post("/", (request, response, next) => {
+        try {
+            const body = request.body;
+            const project = projectManager.createProject({
+                name: body.name ?? "",
+                path: body.path ?? "",
+                createMissing: body.createMissing === true,
+            });
+            response.status(201).json({
+                projectId: project.id,
+            });
+        }
+        catch (error) {
+            next(error);
+        }
+    });
+    router.get("/browse", (request, response, next) => {
+        try {
+            const targetPath = typeof request.query.path === "string" && request.query.path.trim()
+                ? request.query.path
+                : null;
+            response.json(projectManager.browseDirectories(targetPath));
+        }
+        catch (error) {
+            next(error);
+        }
+    });
+    return router;
+}