remcodex 0.1.0-beta.1

package/dist/server/src/services/session-timeline-service.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionTimelineService = void 0;
+const DEFAULT_TIMELINE_LIMIT = 200;
+const MAX_TIMELINE_LIMIT = 400;
+function clampLimit(limit) {
+    const numeric = Number(limit || DEFAULT_TIMELINE_LIMIT);
+    if (!Number.isFinite(numeric) || numeric <= 0) {
+        return DEFAULT_TIMELINE_LIMIT;
+    }
+    return Math.max(1, Math.min(Math.trunc(numeric), MAX_TIMELINE_LIMIT));
+}
+function normalizeCursor(value) {
+    const numeric = Number(value || 0);
+    if (!Number.isFinite(numeric) || numeric <= 0) {
+        return 0;
+    }
+    return Math.trunc(numeric);
+}
+function cloneEvent(event) {
+    return {
+        ...event,
+        payload: event.payload && typeof event.payload === "object"
+            ? { ...event.payload }
+            : event.payload,
+    };
+}
+function appendTextDelta(currentValue, nextValue) {
+    if (!nextValue) {
+        return currentValue || "";
+    }
+    return `${currentValue || ""}${nextValue}`;
+}
+function compareEvents(left, right) {
+    if (left.seq !== right.seq) {
+        return left.seq - right.seq;
+    }
+    return String(left.id || "").localeCompare(String(right.id || ""));
+}
+function upsertTimelineEvent(items, indexById, nextEvent) {
+    const existing = indexById.get(nextEvent.id);
+    if (existing) {
+        Object.assign(existing, nextEvent);
+        return existing;
+    }
+    const cloned = cloneEvent(nextEvent);
+    items.push(cloned);
+    indexById.set(cloned.id, cloned);
+    return cloned;
+}
+function timelineAssistantDeltaId(event) {
+    return `timeline:assistant:delta:${event.messageId || event.id}`;
+}
+function timelineReasoningDeltaId(event) {
+    return `timeline:reasoning:delta:${event.messageId || event.id}`;
+}
+function timelineCommandOutputId(event) {
+    return `timeline:command:output:${event.callId || event.id}:${event.stream || "stdout"}`;
+}
+function timelinePatchOutputId(event) {
+    return `timeline:patch:output:${event.callId || event.id}`;
+}
+function aggregateSemanticTimeline(rawEvents) {
+    const items = [];
+    const indexById = new Map();
+    rawEvents.forEach((event) => {
+        switch (event.type) {
+            case "message.assistant.delta": {
+                const syntheticId = timelineAssistantDeltaId(event);
+                const existing = indexById.get(syntheticId);
+                upsertTimelineEvent(items, indexById, {
+                    ...cloneEvent(event),
+                    id: syntheticId,
+                    payload: {
+                        ...(event.payload || {}),
+                        textDelta: appendTextDelta(existing?.payload?.textDelta || "", String(event.payload?.textDelta || "")),
+                    },
+                });
+                break;
+            }
+            case "reasoning.delta": {
+                const syntheticId = timelineReasoningDeltaId(event);
+                const existing = indexById.get(syntheticId);
+                const nextText = appendTextDelta(existing?.payload?.textDelta || "", String(event.payload?.textDelta || ""));
+                upsertTimelineEvent(items, indexById, {
+                    ...cloneEvent(event),
+                    id: syntheticId,
+                    payload: {
+                        ...(event.payload || {}),
+                        textDelta: nextText,
+                        summary: event.payload?.summary ||
+                            existing?.payload?.summary ||
+                            nextText ||
+                            null,
+                    },
+                });
+                break;
+            }
+            case "command.output.delta": {
+                const syntheticId = timelineCommandOutputId(event);
+                const existing = indexById.get(syntheticId);
+                upsertTimelineEvent(items, indexById, {
+                    ...cloneEvent(event),
+                    id: syntheticId,
+                    payload: {
+                        ...(event.payload || {}),
+                        textDelta: appendTextDelta(existing?.payload?.textDelta || "", String(event.payload?.textDelta || "")),
+                        stream: event.payload?.stream || event.stream || "stdout",
+                    },
+                });
+                break;
+            }
+            case "patch.output.delta": {
+                const syntheticId = timelinePatchOutputId(event);
+                const existing = indexById.get(syntheticId);
+                upsertTimelineEvent(items, indexById, {
+                    ...cloneEvent(event),
+                    id: syntheticId,
+                    payload: {
+                        ...(event.payload || {}),
+                        textDelta: appendTextDelta(existing?.payload?.textDelta || "", String(event.payload?.textDelta || "")),
+                    },
+                });
+                break;
+            }
+            default:
+                upsertTimelineEvent(items, indexById, event);
+                break;
+        }
+    });
+    return items.sort(compareEvents);
+}
+function paginateTimelineItems(items, options, lastSeq) {
+    const limit = clampLimit(options.limit);
+    const after = normalizeCursor(options.after);
+    const before = normalizeCursor(options.before);
+    if (before > 0) {
+        const matches = items.filter((item) => item.seq < before);
+        const hasMoreBefore = matches.length > limit;
+        const pageItems = matches.slice(Math.max(0, matches.length - limit));
+        return {
+            items: pageItems,
+            nextCursor: pageItems.at(-1)?.seq || after,
+            beforeCursor: pageItems[0]?.seq || before,
+            hasMoreBefore,
+            lastSeq,
+        };
+    }
+    if (after > 0) {
+        const pageItems = items.filter((item) => item.seq > after).slice(0, limit);
+        return {
+            items: pageItems,
+            nextCursor: pageItems.at(-1)?.seq || after,
+            beforeCursor: pageItems[0]?.seq || 0,
+            hasMoreBefore: pageItems.length > 0 ? pageItems[0].seq > 1 : items.length > 0,
+            lastSeq,
+        };
+    }
+    const hasMoreBefore = items.length > limit;
+    const pageItems = items.slice(Math.max(0, items.length - limit));
+    return {
+        items: pageItems,
+        nextCursor: pageItems.at(-1)?.seq || 0,
+        beforeCursor: pageItems[0]?.seq || 0,
+        hasMoreBefore,
+        lastSeq,
+    };
+}
+class SessionTimelineService {
+    eventStore;
+    constructor(eventStore) {
+        this.eventStore = eventStore;
+    }
+    list(sessionId, options = {}) {
+        const rawEvents = this.eventStore.listAll(sessionId);
+        const lastSeq = rawEvents.at(-1)?.seq || 0;
+        const aggregatedItems = aggregateSemanticTimeline(rawEvents);
+        return paginateTimelineItems(aggregatedItems, options, lastSeq);
+    }
+}
+exports.SessionTimelineService = SessionTimelineService;

package/dist/server/src/types/codex-launch.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/server/src/types/models.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IO_STREAMS = exports.ASSISTANT_PHASES = exports.EVENT_TYPES = exports.SESSION_SOURCE_KINDS = exports.SESSION_STATUSES = void 0;
+exports.SESSION_STATUSES = [
+    "idle",
+    "starting",
+    "running",
+    "waiting_input",
+    "stopping",
+    "completed",
+    "failed",
+];
+exports.SESSION_SOURCE_KINDS = ["native", "imported_rollout"];
+exports.EVENT_TYPES = [
+    "message.user",
+    "message.assistant.start",
+    "message.assistant.delta",
+    "message.assistant.end",
+    "reasoning.start",
+    "reasoning.delta",
+    "reasoning.end",
+    "command.start",
+    "command.output.delta",
+    "command.end",
+    "patch.start",
+    "patch.output.delta",
+    "patch.end",
+    "approval.requested",
+    "approval.resolved",
+    "turn.started",
+    "turn.completed",
+    "turn.aborted",
+    "error",
+    "token_count",
+];
+exports.ASSISTANT_PHASES = ["commentary", "final_answer"];
+exports.IO_STREAMS = ["stdout", "stderr"];

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

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripAnsi = stripAnsi;
+exports.normalizeTerminalOutput = normalizeTerminalOutput;
+function stripAnsi(value) {
+    return normalizeTerminalOutput(value).content;
+}
+function normalizeTerminalOutput(value) {
+    const { content, rest } = stripTerminalSequences(value);
+    return {
+        content: applyTerminalControls(content),
+        rest,
+    };
+}
+function stripTerminalSequences(value) {
+    let index = 0;
+    let output = "";
+    while (index < value.length) {
+        const current = value.charCodeAt(index);
+        if (current === 0x1b) {
+            const nextIndex = consumeEscapeSequence(value, index);
+            if (nextIndex === -1) {
+                break;
+            }
+            index = nextIndex;
+            continue;
+        }
+        if (current === 0x9b) {
+            const nextIndex = consumeCsi(value, index + 1);
+            if (nextIndex === -1) {
+                break;
+            }
+            index = nextIndex;
+            continue;
+        }
+        output += value[index];
+        index += 1;
+    }
+    return {
+        content: output,
+        rest: value.slice(index),
+    };
+}
+function consumeEscapeSequence(value, start) {
+    const next = value[start + 1];
+    if (!next) {
+        return -1;
+    }
+    switch (next) {
+        case "[":
+            return consumeCsi(value, start + 2);
+        case "]":
+            return consumeOsc(value, start + 2);
+        case "P":
+        case "^":
+        case "_":
+            return consumeStTerminated(value, start + 2);
+        case "(":
+        case ")":
+        case "*":
+        case "+":
+        case "-":
+        case ".":
+        case "/":
+            return start + 3 <= value.length ? start + 3 : -1;
+        default:
+            return start + 2;
+    }
+}
+function consumeCsi(value, start) {
+    for (let index = start; index < value.length; index += 1) {
+        const code = value.charCodeAt(index);
+        if (code >= 0x40 && code <= 0x7e) {
+            return index + 1;
+        }
+    }
+    return -1;
+}
+function consumeOsc(value, start) {
+    for (let index = start; index < value.length; index += 1) {
+        const code = value.charCodeAt(index);
+        if (code === 0x07) {
+            return index + 1;
+        }
+        if (code === 0x1b) {
+            if (index + 1 >= value.length) {
+                return -1;
+            }
+            if (value[index + 1] === "\\") {
+                return index + 2;
+            }
+        }
+    }
+    return -1;
+}
+function consumeStTerminated(value, start) {
+    for (let index = start; index < value.length; index += 1) {
+        const code = value.charCodeAt(index);
+        if (code === 0x9c) {
+            return index + 1;
+        }
+        if (code === 0x1b) {
+            if (index + 1 >= value.length) {
+                return -1;
+            }
+            if (value[index + 1] === "\\") {
+                return index + 2;
+            }
+        }
+    }
+    return -1;
+}
+function applyTerminalControls(value) {
+    const lines = [""];
+    for (const char of value.replace(/\r\n/g, "\n")) {
+        const lineIndex = lines.length - 1;
+        switch (char) {
+            case "\n":
+                lines.push("");
+                break;
+            case "\r":
+                lines[lineIndex] = "";
+                break;
+            case "\b":
+                lines[lineIndex] = lines[lineIndex].slice(0, -1);
+                break;
+            case "\t":
+                lines[lineIndex] += "\t";
+                break;
+            default: {
+                const code = char.charCodeAt(0);
+                if ((code >= 0x20 && code !== 0x7f) || code >= 0xa0) {
+                    lines[lineIndex] += char;
+                }
+            }
+        }
+    }
+    return lines
+        .join("\n")
+        .replace(/[ \t]+\n/g, "\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trimEnd();
+}

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

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeCodexExecLaunchInput = normalizeCodexExecLaunchInput;
+const SANDBOX = new Set([
+    "read-only",
+    "workspace-write",
+    "danger-full-access",
+]);
+const SPEEDS = new Set(["default", "fast", "deep"]);
+const REASONING_EFFORTS = new Set(["low", "medium", "high", "xhigh"]);
+function sanitizeToken(value, maxLen) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const t = value.trim();
+    if (!t || t.length > maxLen) {
+        return undefined;
+    }
+    if (!/^[\w.+-]+$/i.test(t)) {
+        return undefined;
+    }
+    return t;
+}
+function sanitizeProfile(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const t = value.trim();
+    if (!t || t.length > 64) {
+        return undefined;
+    }
+    if (!/^[\w-]+$/i.test(t)) {
+        return undefined;
+    }
+    return t;
+}
+function sanitizeFeatureName(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const t = value.trim();
+    if (!t || t.length > 64) {
+        return undefined;
+    }
+    if (!/^[a-z][a-z0-9_]*$/i.test(t)) {
+        return undefined;
+    }
+    return t;
+}
+function normalizeCodexExecLaunchInput(raw) {
+    if (!raw || typeof raw !== "object") {
+        return undefined;
+    }
+    const o = raw;
+    const model = sanitizeToken(o.model, 96);
+    const profile = sanitizeProfile(o.profile);
+    const sandbox = typeof o.sandbox === "string" && SANDBOX.has(o.sandbox)
+        ? o.sandbox
+        : undefined;
+    const speed = typeof o.speed === "string" && SPEEDS.has(o.speed) ? o.speed : undefined;
+    const reasoningEffort = typeof o.reasoningEffort === "string" && REASONING_EFFORTS.has(o.reasoningEffort)
+        ? o.reasoningEffort
+        : undefined;
+    const enableFeatures = Array.isArray(o.enableFeatures)
+        ? o.enableFeatures.map(sanitizeFeatureName).filter(Boolean)
+        : [];
+    const disableFeatures = Array.isArray(o.disableFeatures)
+        ? o.disableFeatures.map(sanitizeFeatureName).filter(Boolean)
+        : [];
+    const out = {};
+    if (model) {
+        out.model = model;
+    }
+    if (profile) {
+        out.profile = profile;
+    }
+    if (sandbox) {
+        out.sandbox = sandbox;
+    }
+    if (speed && speed !== "default") {
+        out.speed = speed;
+    }
+    if (reasoningEffort) {
+        out.reasoningEffort = reasoningEffort;
+    }
+    if (enableFeatures.length > 0) {
+        out.enableFeatures = enableFeatures;
+    }
+    if (disableFeatures.length > 0) {
+        out.disableFeatures = disableFeatures;
+    }
+    if (!out.model &&
+        !out.profile &&
+        !out.sandbox &&
+        !out.speed &&
+        !out.reasoningEffort &&
+        !out.enableFeatures?.length &&
+        !out.disableFeatures?.length) {
+        return undefined;
+    }
+    return out;
+}

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

@@ -0,0 +1,179 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCodexQuotaSnapshot = resolveCodexQuotaSnapshot;
+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 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 : undefined;
+    }
+    return undefined;
+}
+function normalizeTokenCountPayload(payload, source, timestamp) {
+    const rateLimits = payload.rate_limits && typeof payload.rate_limits === "object"
+        ? payload.rate_limits
+        : payload.rateLimits && typeof payload.rateLimits === "object"
+            ? payload.rateLimits
+            : null;
+    if (!rateLimits) {
+        return null;
+    }
+    const info = payload.info && typeof payload.info === "object"
+        ? payload.info
+        : undefined;
+    const totalTokenUsage = info?.total_token_usage && typeof info.total_token_usage === "object"
+        ? info.total_token_usage
+        : undefined;
+    const lastTokenUsage = info?.last_token_usage && typeof info.last_token_usage === "object"
+        ? info.last_token_usage
+        : undefined;
+    const modelContextWindow = readNumberField(info?.model_context_window);
+    return {
+        rateLimits,
+        totalTokenUsage,
+        lastTokenUsage,
+        modelContextWindow,
+        receivedAt: timestamp || new Date().toISOString(),
+        rawPayload: payload,
+        source,
+    };
+}
+function parseQuotaLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+        return null;
+    }
+    try {
+        const raw = JSON.parse(trimmed);
+        const timestamp = typeof raw.timestamp === "string" && raw.timestamp.trim() ? raw.timestamp.trim() : undefined;
+        if (raw.type === "event_msg" && raw.payload && typeof raw.payload === "object") {
+            const payload = raw.payload;
+            if (payload.type === "token_count") {
+                return normalizeTokenCountPayload(raw.payload, "rollout", timestamp);
+            }
+        }
+        if (raw.type === "token_count") {
+            return normalizeTokenCountPayload(raw, "rollout", timestamp);
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+function findRolloutPathInStateDb(input) {
+    const dbPath = resolveStateDbPath();
+    if (!(0, node_fs_1.existsSync)(dbPath)) {
+        return null;
+    }
+    const db = new better_sqlite3_1.default(dbPath);
+    try {
+        const byId = db.prepare("SELECT id, rollout_path, cwd, updated_at FROM threads WHERE id = ? LIMIT 1");
+        const byCwd = db.prepare("SELECT id, rollout_path, cwd, updated_at FROM threads WHERE cwd = ? ORDER BY updated_at DESC, id DESC LIMIT 1");
+        let row;
+        if (input.threadId?.trim()) {
+            row = byId.get(input.threadId.trim());
+        }
+        if (!row && input.cwd?.trim()) {
+            row = byCwd.get(input.cwd.trim());
+        }
+        if (!row?.rollout_path) {
+            return null;
+        }
+        const resolved = node_path_1.default.isAbsolute(row.rollout_path)
+            ? row.rollout_path
+            : node_path_1.default.resolve(resolveCodexHomeDir(), row.rollout_path);
+        return (0, node_fs_1.existsSync)(resolved) ? resolved : null;
+    }
+    finally {
+        db.close?.();
+    }
+}
+function scanDirForRollout(rootDir, threadId) {
+    const stack = [rootDir];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (!current) {
+            continue;
+        }
+        let entries;
+        try {
+            entries = (0, node_fs_1.readdirSync)(current);
+        }
+        catch {
+            continue;
+        }
+        for (const name of entries) {
+            const nextPath = node_path_1.default.join(current, name);
+            let stats;
+            try {
+                stats = (0, node_fs_1.statSync)(nextPath);
+            }
+            catch {
+                continue;
+            }
+            if (stats.isDirectory()) {
+                stack.push(nextPath);
+                continue;
+            }
+            if (stats.isFile() &&
+                name.includes(threadId) &&
+                name.endsWith(".jsonl")) {
+                return nextPath;
+            }
+        }
+    }
+    return null;
+}
+function findRolloutPathInSessions(threadId) {
+    const sessionsDir = node_path_1.default.join(resolveCodexHomeDir(), "sessions");
+    if (!(0, node_fs_1.existsSync)(sessionsDir)) {
+        return null;
+    }
+    return scanDirForRollout(sessionsDir, threadId);
+}
+function readLatestQuotaFromRollout(rolloutPath) {
+    if (!(0, node_fs_1.existsSync)(rolloutPath)) {
+        return null;
+    }
+    const body = (0, node_fs_1.readFileSync)(rolloutPath, "utf8");
+    const lines = body.split(/\r?\n/);
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+        const parsed = parseQuotaLine(lines[index] || "");
+        if (parsed) {
+            return parsed;
+        }
+    }
+    return null;
+}
+function resolveCodexQuotaSnapshot(input = {}) {
+    const rolloutPath = findRolloutPathInStateDb(input) ||
+        (input.threadId?.trim() ? findRolloutPathInSessions(input.threadId.trim()) : null);
+    if (!rolloutPath) {
+        return null;
+    }
+    return readLatestQuotaFromRollout(rolloutPath);
+}