remcodex 0.1.0-beta.1

package/dist/server/src/utils/codex-status.js

@@ -0,0 +1,163 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCodexStatus = resolveCodexStatus;
+const node_fs_1 = require("node:fs");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+function resolveCodexHomeDir() {
+    const override = process.env.CODEX_HOME?.trim();
+    if (override) {
+        return node_path_1.default.resolve(override);
+    }
+    return node_path_1.default.join(node_os_1.default.homedir(), ".codex");
+}
+function resolveStateDbPath() {
+    const override = process.env.CODEX_STATE_DB_PATH?.trim();
+    if (override) {
+        return node_path_1.default.resolve(override);
+    }
+    return node_path_1.default.join(resolveCodexHomeDir(), "state_5.sqlite");
+}
+function toIso(unixSeconds) {
+    return new Date(unixSeconds * 1000).toISOString();
+}
+function normalizeNonEmpty(value) {
+    const trimmed = typeof value === "string" ? value.trim() : "";
+    return trimmed ? trimmed : null;
+}
+function parseSandboxPolicy(raw) {
+    const text = normalizeNonEmpty(raw);
+    if (!text) {
+        return {
+            sandboxMode: null,
+            writableRoots: [],
+        };
+    }
+    if (!text.startsWith("{")) {
+        return {
+            sandboxMode: text,
+            writableRoots: [],
+        };
+    }
+    try {
+        const parsed = JSON.parse(text);
+        const writableRoots = Array.isArray(parsed.writable_roots)
+            ? parsed.writable_roots
+                .filter((item) => typeof item === "string" && item.trim().length > 0)
+            : [];
+        return {
+            sandboxMode: normalizeNonEmpty(typeof parsed.type === "string" ? parsed.type : null),
+            writableRoots,
+        };
+    }
+    catch {
+        return {
+            sandboxMode: text,
+            writableRoots: [],
+        };
+    }
+}
+function deriveWritableRoots(sandboxMode, cwd, parsedRoots) {
+    if (parsedRoots.length > 0) {
+        return parsedRoots;
+    }
+    if (sandboxMode === "danger-full-access") {
+        return ["<full-access>"];
+    }
+    if (sandboxMode === "workspace-write") {
+        const roots = [];
+        if (cwd) {
+            roots.push(cwd);
+        }
+        roots.push("/tmp");
+        return roots;
+    }
+    return [];
+}
+function buildRuntime(row, input) {
+    const cwd = normalizeNonEmpty(row?.cwd ?? input.cwd ?? null);
+    const parsedPolicy = parseSandboxPolicy(row?.sandbox_policy ?? null);
+    const sandboxMode = parsedPolicy.sandboxMode;
+    const approvalMode = normalizeNonEmpty(row?.approval_mode ?? null);
+    return {
+        executionMode: input.executionMode ?? "codex app-server",
+        interactiveApprovalUi: input.interactiveApprovalUi ?? false,
+        cwd,
+        workspaceRoot: cwd,
+        sandboxMode,
+        approvalMode,
+        writableRoots: deriveWritableRoots(sandboxMode, cwd, parsedPolicy.writableRoots),
+    };
+}
+function mapThread(row) {
+    return {
+        threadId: row.id,
+        rolloutPath: row.rollout_path,
+        source: row.source,
+        modelProvider: row.model_provider,
+        cwd: row.cwd,
+        title: row.title,
+        sandboxPolicy: row.sandbox_policy,
+        approvalMode: row.approval_mode,
+        tokensUsed: row.tokens_used,
+        hasUserEvent: row.has_user_event !== 0,
+        archived: row.archived !== 0,
+        archivedAt: row.archived_at == null ? null : toIso(row.archived_at),
+        gitSha: row.git_sha,
+        gitBranch: row.git_branch,
+        gitOriginUrl: row.git_origin_url,
+        cliVersion: row.cli_version,
+        firstUserMessage: row.first_user_message,
+        agentNickname: row.agent_nickname,
+        agentRole: row.agent_role,
+        memoryMode: row.memory_mode,
+        model: row.model,
+        reasoningEffort: row.reasoning_effort,
+        createdAt: toIso(row.created_at),
+        updatedAt: toIso(row.updated_at),
+    };
+}
+function resolveCodexStatus(input = {}) {
+    const dbPath = resolveStateDbPath();
+    if (!(0, node_fs_1.existsSync)(dbPath)) {
+        return {
+            thread: null,
+            source: "none",
+            runtime: buildRuntime(undefined, input),
+            fetchedAt: new Date().toISOString(),
+        };
+    }
+    const db = new better_sqlite3_1.default(dbPath);
+    try {
+        const byId = db.prepare("SELECT * FROM threads WHERE id = ? LIMIT 1");
+        const byCwd = db.prepare("SELECT * FROM threads WHERE cwd = ? ORDER BY updated_at DESC, id DESC LIMIT 1");
+        const latest = db.prepare("SELECT * FROM threads ORDER BY updated_at DESC, id DESC LIMIT 1");
+        let row;
+        let source = "none";
+        if (input.threadId?.trim()) {
+            row = byId.get(input.threadId.trim());
+            source = row ? "threadId" : "none";
+        }
+        if (!row && input.cwd?.trim()) {
+            row = byCwd.get(input.cwd.trim());
+            source = row ? "cwd" : source;
+        }
+        if (!row) {
+            row = latest.get();
+            source = row ? "latest" : "none";
+        }
+        return {
+            thread: row ? mapThread(row) : null,
+            source,
+            runtime: buildRuntime(row, input),
+            fetchedAt: new Date().toISOString(),
+        };
+    }
+    finally {
+        db.close?.();
+    }
+}

package/dist/server/src/utils/codex-ui-options.js

@@ -0,0 +1,114 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCodexUiOptions = resolveCodexUiOptions;
+const node_fs_1 = require("node:fs");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const DEFAULT_OPTIONS = {
+    models: [
+        { id: "gpt-5.4", label: "gpt-5.4" },
+        { id: "gpt-5.4-mini", label: "GPT-5.4-Mini" },
+        { id: "gpt-5.3-codex", label: "gpt-5.3-codex" },
+        { id: "gpt-5.2-codex", label: "gpt-5.2-codex" },
+        { id: "gpt-5.2", label: "gpt-5.2" },
+        { id: "gpt-5.1-codex-max", label: "gpt-5.1-codex-max" },
+        { id: "gpt-5.1-codex-mini", label: "gpt-5.1-codex-mini" },
+    ],
+    reasoningLevels: [
+        { id: "low", label: "Low", launch: { reasoningEffort: "low" } },
+        { id: "medium", label: "Medium", launch: { reasoningEffort: "medium" } },
+        { id: "high", label: "High", launch: { reasoningEffort: "high" } },
+        { id: "xhigh", label: "Very high", launch: { reasoningEffort: "xhigh" } },
+    ],
+};
+function resolveCodexHomeDir() {
+    const override = process.env.CODEX_HOME?.trim();
+    if (override) {
+        return node_path_1.default.resolve(override);
+    }
+    return node_path_1.default.join(node_os_1.default.homedir(), ".codex");
+}
+function resolveModelsCachePath() {
+    const override = process.env.CODEX_MODELS_CACHE_PATH?.trim();
+    if (override) {
+        return node_path_1.default.resolve(override);
+    }
+    return node_path_1.default.join(resolveCodexHomeDir(), "models_cache.json");
+}
+function sanitizeModel(raw) {
+    if (!raw || typeof raw !== "object") {
+        return null;
+    }
+    const o = raw;
+    const id = typeof o.slug === "string" ? o.slug.trim() : "";
+    const label = typeof o.display_name === "string" ? o.display_name.trim() : "";
+    const visibility = typeof o.visibility === "string" ? o.visibility.trim() : "";
+    if (!id || !label || id.length > 96 || label.length > 120) {
+        return null;
+    }
+    if (!/^[\w.+-]+$/i.test(id)) {
+        return null;
+    }
+    if (visibility && visibility !== "list" && visibility !== "hide") {
+        return null;
+    }
+    if (visibility !== "list") {
+        return null;
+    }
+    return { id, label };
+}
+function parseModelsCache(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        const modelsIn = Array.isArray(parsed.models) ? parsed.models : [];
+        const models = modelsIn.map(sanitizeModel).filter(Boolean);
+        if (models.length === 0) {
+            return null;
+        }
+        const seen = new Set();
+        const deduped = models.filter((model) => {
+            if (seen.has(model.id)) {
+                return false;
+            }
+            seen.add(model.id);
+            return true;
+        });
+        return {
+            models: deduped,
+            reasoningLevels: DEFAULT_OPTIONS.reasoningLevels,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * CODEX_UI_OPTIONS_JSON: full JSON { models, reasoningLevels }.
+ * CODEX_MODELS_CACHE_PATH: optional override for ~/.codex/models_cache.json.
+ * Falls back to DEFAULT_OPTIONS when unset or invalid.
+ */
+function resolveCodexUiOptions() {
+    const fromEnv = process.env.CODEX_UI_OPTIONS_JSON?.trim();
+    if (fromEnv) {
+        try {
+            const parsed = JSON.parse(fromEnv);
+            if (Array.isArray(parsed.models) && parsed.models.length > 0 && Array.isArray(parsed.reasoningLevels)) {
+                return parsed;
+            }
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    const modelsCachePath = resolveModelsCachePath();
+    if ((0, node_fs_1.existsSync)(modelsCachePath)) {
+        const parsed = parseModelsCache((0, node_fs_1.readFileSync)(modelsCachePath, "utf8"));
+        if (parsed) {
+            return parsed;
+        }
+    }
+    return DEFAULT_OPTIONS;
+}

package/dist/server/src/utils/command.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveExecutable = resolveExecutable;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+function isExecutable(filePath) {
+    try {
+        (0, node_fs_1.accessSync)(filePath, node_fs_1.constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function shellQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function resolveExecutable(command) {
+    const trimmed = command.trim();
+    if (!trimmed) {
+        return trimmed;
+    }
+    if (trimmed.includes(node_path_1.default.sep)) {
+        const candidate = node_path_1.default.resolve(trimmed);
+        return isExecutable(candidate) ? candidate : trimmed;
+    }
+    const envPath = process.env.PATH ?? "";
+    for (const root of envPath.split(node_path_1.default.delimiter).filter(Boolean)) {
+        const candidate = node_path_1.default.join(root, trimmed);
+        if (isExecutable(candidate)) {
+            return candidate;
+        }
+    }
+    try {
+        const shell = process.env.SHELL ?? "/bin/zsh";
+        const resolved = (0, node_child_process_1.execFileSync)(shell, ["-lc", `command -v ${shellQuote(trimmed)}`], { encoding: "utf8" }).trim();
+        return resolved || trimmed;
+    }
+    catch {
+        return trimmed;
+    }
+}

package/dist/server/src/utils/errors.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppError = void 0;
+exports.isAppError = isAppError;
+class AppError extends Error {
+    statusCode;
+    constructor(statusCode, message) {
+        super(message);
+        this.statusCode = statusCode;
+        this.name = "AppError";
+    }
+}
+exports.AppError = AppError;
+function isAppError(error) {
+    return error instanceof AppError;
+}

package/dist/server/src/utils/ids.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createId = createId;
+const node_crypto_1 = require("node:crypto");
+function createId(prefix) {
+    return `${prefix}_${(0, node_crypto_1.randomUUID)().replace(/-/g, "").slice(0, 12)}`;
+}

package/dist/server/src/utils/node-pty.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureNodePtyHelperExecutable = ensureNodePtyHelperExecutable;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+function ensureNodePtyHelperExecutable() {
+    if (process.platform !== "darwin") {
+        return;
+    }
+    let packageJsonPath;
+    try {
+        packageJsonPath = require.resolve("node-pty/package.json");
+    }
+    catch {
+        return;
+    }
+    const helperPath = node_path_1.default.join(node_path_1.default.dirname(packageJsonPath), "prebuilds", `darwin-${process.arch}`, "spawn-helper");
+    if (!(0, node_fs_1.existsSync)(helperPath)) {
+        return;
+    }
+    const currentMode = (0, node_fs_1.statSync)(helperPath).mode & 0o777;
+    const nextMode = currentMode | 0o111;
+    if (currentMode !== nextMode) {
+        (0, node_fs_1.chmodSync)(helperPath, nextMode);
+    }
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "remcodex",
+  "version": "0.1.0-beta.1",
+  "description": "Control Codex from anywhere. Even on your phone.",
+  "license": "MIT",
+  "bin": {
+    "remcodex": "dist/server/src/cli.js"
+  },
+  "files": [
+    "dist",
+    "web",
+    "scripts/fix-node-pty-helper.js",
+    "README.md"
+  ],
+  "scripts": {
+    "postinstall": "node scripts/fix-node-pty-helper.js",
+    "dev": "tsx watch server/src/app.ts",
+    "start": "tsx server/src/cli.ts --no-open",
+    "build": "tsc -p tsconfig.json",
+    "cli": "tsx server/src/cli.ts --no-open"
+  },
+  "dependencies": {
+    "better-sqlite3": "^11.8.1",
+    "express": "^4.21.2",
+    "markdown-it": "^14.1.1",
+    "node-pty": "^1.0.0",
+    "ws": "^8.18.1"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.1",
+    "@types/node": "^22.13.10",
+    "@types/ws": "^8.5.14",
+    "tsx": "^4.19.3",
+    "typescript": "^5.8.2"
+  }
+}

package/scripts/fix-node-pty-helper.js

@@ -0,0 +1,36 @@
+const fs = require("node:fs");
+const path = require("node:path");
+
+function fixNodePtyHelper() {
+  if (process.platform !== "darwin") {
+    return;
+  }
+
+  let packageJsonPath;
+  try {
+    packageJsonPath = require.resolve("node-pty/package.json");
+  } catch {
+    return;
+  }
+
+  const helperPath = path.join(
+    path.dirname(packageJsonPath),
+    "prebuilds",
+    `darwin-${process.arch}`,
+    "spawn-helper",
+  );
+
+  if (!fs.existsSync(helperPath)) {
+    return;
+  }
+
+  const currentMode = fs.statSync(helperPath).mode & 0o777;
+  const nextMode = currentMode | 0o111;
+
+  if (currentMode !== nextMode) {
+    fs.chmodSync(helperPath, nextMode);
+    console.log(`[postinstall] fixed executable bit: ${helperPath}`);
+  }
+}
+
+fixNodePtyHelper();

package/web/api.js

@@ -0,0 +1,175 @@
+const headers = {
+  "Content-Type": "application/json",
+};
+
+async function request(path, options = {}) {
+  const response = await fetch(path, {
+    ...options,
+    headers: {
+      ...headers,
+      ...(options.headers ?? {}),
+    },
+  });
+
+  if (!response.ok) {
+    const data = await safeJson(response);
+    throw new Error(data?.error ?? `Request failed: ${response.status}`);
+  }
+
+  return safeJson(response);
+}
+
+async function safeJson(response) {
+  const text = await response.text();
+  return text ? JSON.parse(text) : null;
+}
+
+export function getProjects() {
+  return request("/api/projects");
+}
+
+export function createProject(payload) {
+  return request("/api/projects", {
+    method: "POST",
+    body: JSON.stringify(payload),
+  });
+}
+
+export function browseProjectDirectories(pathValue = "") {
+  const query = pathValue ? `?path=${encodeURIComponent(pathValue)}` : "";
+  return request(`/api/projects/browse${query}`);
+}
+
+export function getSessions() {
+  return request("/api/sessions");
+}
+
+export function createSession(payload) {
+  return request("/api/sessions", {
+    method: "POST",
+    body: JSON.stringify(payload),
+  });
+}
+
+export function importCodexSession(payload) {
+  return request("/api/sessions/import-codex", {
+    method: "POST",
+    body: JSON.stringify(payload),
+  });
+}
+
+export function getSession(sessionId) {
+  return request(`/api/sessions/${sessionId}`);
+}
+
+export function syncImportedSession(sessionId) {
+  return request(`/api/sessions/${sessionId}/sync`, {
+    method: "POST",
+  });
+}
+
+export function getSessionEvents(sessionId, options = 0) {
+  const search = new URLSearchParams();
+
+  if (typeof options === "number") {
+    if (options > 0) {
+      search.set("after", String(options));
+    }
+  } else if (options && typeof options === "object") {
+    if (options.after) {
+      search.set("after", String(options.after));
+    }
+    if (options.before) {
+      search.set("before", String(options.before));
+    }
+    if (options.limit) {
+      search.set("limit", String(options.limit));
+    }
+  }
+
+  const query = search.toString();
+  return request(`/api/sessions/${sessionId}/events${query ? `?${query}` : ""}`);
+}
+
+export function getSessionTimeline(sessionId, options = 0) {
+  const search = new URLSearchParams();
+
+  if (typeof options === "number") {
+    if (options > 0) {
+      search.set("after", String(options));
+    }
+  } else if (options && typeof options === "object") {
+    if (options.after) {
+      search.set("after", String(options.after));
+    }
+    if (options.before) {
+      search.set("before", String(options.before));
+    }
+    if (options.limit) {
+      search.set("limit", String(options.limit));
+    }
+  }
+
+  const query = search.toString();
+  return request(`/api/sessions/${sessionId}/timeline${query ? `?${query}` : ""}`);
+}
+
+export function getSessionTimelineEvents(sessionId, options = 0) {
+  return getSessionTimeline(sessionId, options);
+}
+
+export function sendMessage(sessionId, payload) {
+  return request(`/api/sessions/${sessionId}/messages`, {
+    method: "POST",
+    body: JSON.stringify(payload),
+  });
+}
+
+export function stopSession(sessionId) {
+  return request(`/api/sessions/${sessionId}/stop`, {
+    method: "POST",
+  });
+}
+
+export function resolveSessionApproval(sessionId, requestId, decision) {
+  return request(`/api/sessions/${sessionId}/approvals/${encodeURIComponent(requestId)}`, {
+    method: "POST",
+    body: JSON.stringify({ decision }),
+  });
+}
+
+export function getHealth() {
+  return request("/health");
+}
+
+export function getCodexUiOptions() {
+  return request("/api/codex/mode");
+}
+
+export function getCodexStatus(params = {}) {
+  const search = new URLSearchParams();
+  if (params.sessionId) {
+    search.set("sessionId", params.sessionId);
+  }
+  if (params.threadId) {
+    search.set("threadId", params.threadId);
+  }
+  if (params.cwd) {
+    search.set("cwd", params.cwd);
+  }
+
+  const query = search.toString();
+  return request(`/api/codex/status${query ? `?${query}` : ""}`);
+}
+
+export function getCodexQuota(sessionId) {
+  return request(`/api/codex/quota?sessionId=${encodeURIComponent(sessionId)}`);
+}
+
+export function getCodexHosts() {
+  return request("/api/codex/hosts");
+}
+
+export function getImportableCodexSessions() {
+  return request("/api/codex/importable-sessions");
+}