@nordbyte/nordrelay 0.2.1

package/dist/codex-state.js

@@ -0,0 +1,573 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import path from "node:path";
+import { isCodexApprovalPolicy, isCodexSandboxMode, } from "./codex-launch.js";
+export const FALLBACK_MODELS = [
+    { slug: "gpt-5.5", displayName: "GPT-5.5" },
+    { slug: "gpt-5.4", displayName: "GPT-5.4" },
+    { slug: "gpt-5.4-mini", displayName: "GPT-5.4-Mini" },
+    { slug: "gpt-5", displayName: "GPT-5" },
+    { slug: "o4-mini", displayName: "o4-mini" },
+    { slug: "o3", displayName: "o3" },
+    { slug: "o3-mini", displayName: "o3-mini" },
+    { slug: "gpt-4o", displayName: "GPT-4o" },
+];
+const betterSqlite3Module = await import("better-sqlite3").catch(() => null);
+const BetterSqlite3 = (betterSqlite3Module?.default ??
+    betterSqlite3Module);
+export function findLatestDatabase() {
+    const codexDir = getCodexDir();
+    if (!codexDir || !existsSync(codexDir)) {
+        return null;
+    }
+    try {
+        const candidates = readdirSync(codexDir)
+            .filter((file) => /^state_.*\.sqlite$/i.test(file))
+            .map((file) => {
+            const fullPath = path.join(codexDir, file);
+            return {
+                path: fullPath,
+                modifiedAtMs: statSync(fullPath).mtimeMs,
+            };
+        })
+            .sort((left, right) => right.modifiedAtMs - left.modifiedAtMs);
+        return candidates[0]?.path ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+export function listThreads(limit = 20) {
+    return withDatabase((db) => {
+        const query = db.prepare(`
+      SELECT id, title, cwd, model, reasoning_effort, sandbox_policy, approval_mode, created_at, updated_at, first_user_message
+      FROM threads
+      WHERE (archived = 0 OR archived IS NULL)
+      ORDER BY updated_at DESC
+      LIMIT ?
+    `);
+        const rows = query.all(limit);
+        return rows.map(mapThreadRow);
+    }) ?? [];
+}
+export function getThread(id) {
+    return (withDatabase((db) => {
+        const query = db.prepare(`
+        SELECT id, title, cwd, model, reasoning_effort, sandbox_policy, approval_mode, created_at, updated_at, first_user_message
+        FROM threads
+        WHERE archived = 0 AND id = ?
+        LIMIT 1
+      `);
+        const row = query.get(id);
+        return row ? mapThreadRow(row) : null;
+    }) ?? null);
+}
+export function getThreadUsage(id) {
+    const rolloutPath = getThreadRolloutPath(id);
+    if (!rolloutPath || !existsSync(rolloutPath)) {
+        return null;
+    }
+    try {
+        return parseUsageFromRollout(readFileSync(rolloutPath, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function getThreadActivity(id, options = {}) {
+    const rolloutPath = getThreadRolloutPath(id);
+    if (!rolloutPath || !existsSync(rolloutPath)) {
+        return null;
+    }
+    try {
+        const parsed = parseActivityFromRollout(id, rolloutPath, readFileSync(rolloutPath, "utf8"));
+        const fileModifiedAtMs = statSync(rolloutPath).mtimeMs;
+        const updatedAtMs = Math.max(parsed.updatedAt?.getTime() ?? 0, fileModifiedAtMs);
+        const updatedAt = updatedAtMs > 0 ? new Date(updatedAtMs) : parsed.updatedAt;
+        const staleAfterMs = options.staleAfterMs ?? 5 * 60 * 1000;
+        const nowMs = options.nowMs ?? Date.now();
+        const stale = Boolean(parsed.active &&
+            updatedAt &&
+            staleAfterMs > 0 &&
+            nowMs - updatedAt.getTime() > staleAfterMs);
+        return {
+            ...parsed,
+            updatedAt,
+            stale,
+            active: parsed.active && !stale,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function getThreadRolloutSnapshot(id, options = {}) {
+    const rolloutPath = getThreadRolloutPath(id);
+    if (!rolloutPath || !existsSync(rolloutPath)) {
+        return null;
+    }
+    try {
+        const parsed = parseRolloutSnapshot(id, rolloutPath, readFileSync(rolloutPath, "utf8"));
+        return finalizeRolloutSnapshot(parsed, statSync(rolloutPath).mtimeMs, options);
+    }
+    catch {
+        return null;
+    }
+}
+export function getThreadActivityLog(id, limit = 20) {
+    const snapshot = getThreadRolloutSnapshot(id, { maxEvents: limit });
+    return snapshot?.events ?? [];
+}
+export function listWorkspaces() {
+    return (withDatabase((db) => {
+        const query = db.prepare(`
+        SELECT DISTINCT cwd
+        FROM threads
+        WHERE (archived = 0 OR archived IS NULL) AND cwd IS NOT NULL AND cwd != ''
+        ORDER BY cwd ASC
+      `);
+        const rows = query.all();
+        return rows
+            .map((row) => (typeof row.cwd === "string" ? row.cwd : ""))
+            .filter(Boolean);
+    }) ?? []);
+}
+export function listModels() {
+    const modelsPath = getModelsCachePath();
+    if (!modelsPath || !existsSync(modelsPath)) {
+        return FALLBACK_MODELS;
+    }
+    try {
+        const payload = JSON.parse(readFileSync(modelsPath, "utf8"));
+        const models = (payload.models ?? [])
+            .filter((model) => model && typeof model === "object")
+            .filter((model) => model.visibility !== "hidden")
+            .map((model) => ({
+            slug: typeof model.slug === "string" ? model.slug : "",
+            displayName: typeof model.display_name === "string" ? model.display_name : "",
+        }))
+            .filter((model) => model.slug && model.displayName);
+        return models.length > 0 ? models : FALLBACK_MODELS;
+    }
+    catch {
+        return FALLBACK_MODELS;
+    }
+}
+export function getThreadRolloutPath(id) {
+    return (withDatabase((db) => {
+        const query = db.prepare(`
+        SELECT rollout_path
+        FROM threads
+        WHERE archived = 0 AND id = ?
+        LIMIT 1
+      `);
+        const row = query.get(id);
+        return typeof row?.rollout_path === "string" && row.rollout_path.trim()
+            ? row.rollout_path
+            : null;
+    }) ?? null);
+}
+function parseUsageFromRollout(contents) {
+    let contextWindow = null;
+    let contextUsedPercent = null;
+    let lastTokenUsage = null;
+    let totalTokenUsage = null;
+    let rateLimits = null;
+    let updatedAt = null;
+    for (const line of contents.split(/\r?\n/)) {
+        if (!line.includes('"token_count"')) {
+            continue;
+        }
+        let event;
+        try {
+            event = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const payload = readObject(readObject(event)?.payload);
+        if (payload?.type !== "token_count") {
+            continue;
+        }
+        const timestamp = readString(readObject(event)?.timestamp);
+        if (timestamp) {
+            const parsedTimestamp = new Date(timestamp);
+            if (!Number.isNaN(parsedTimestamp.getTime())) {
+                updatedAt = parsedTimestamp;
+            }
+        }
+        const info = readObject(payload.info);
+        const parsedTotal = parseTokenUsage(readObject(info?.total_token_usage));
+        const parsedLast = parseTokenUsage(readObject(info?.last_token_usage));
+        const parsedContextWindow = readNumber(info?.model_context_window);
+        if (parsedTotal) {
+            totalTokenUsage = parsedTotal;
+        }
+        if (parsedLast) {
+            lastTokenUsage = parsedLast;
+        }
+        if (parsedContextWindow !== null && parsedContextWindow > 0) {
+            contextWindow = parsedContextWindow;
+        }
+        if (lastTokenUsage && contextWindow) {
+            contextUsedPercent = Math.min(100, (lastTokenUsage.totalTokens / contextWindow) * 100);
+        }
+        const parsedRateLimits = parseRateLimits(readObject(payload.rate_limits));
+        if (parsedRateLimits) {
+            rateLimits = parsedRateLimits;
+        }
+    }
+    if (!lastTokenUsage && !totalTokenUsage && !rateLimits) {
+        return null;
+    }
+    return {
+        contextWindow,
+        contextUsedPercent,
+        lastTokenUsage,
+        totalTokenUsage,
+        rateLimits,
+        updatedAt,
+    };
+}
+function parseActivityFromRollout(threadId, rolloutPath, contents) {
+    return parseRolloutSnapshot(threadId, rolloutPath, contents).activity;
+}
+function parseRolloutSnapshot(threadId, rolloutPath, contents) {
+    let activeTurnId = null;
+    let startedAt = null;
+    let updatedAt = null;
+    let latestAgentMessage = null;
+    let latestUserMessage = null;
+    let latestToolName = null;
+    const events = [];
+    const lines = contents.split(/\r?\n/);
+    for (const [index, line] of lines.entries()) {
+        if (!line.trim()) {
+            continue;
+        }
+        if (!line.includes('"task_') &&
+            !line.includes('"turn_') &&
+            !line.includes('"user_message"') &&
+            !line.includes('"agent_message"') &&
+            !line.includes('"function_call"') &&
+            !activeTurnId) {
+            continue;
+        }
+        let event;
+        try {
+            event = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const eventObject = readObject(event);
+        const payload = readObject(eventObject?.payload);
+        const eventTimestamp = parseTimestamp(readString(eventObject?.timestamp));
+        const lineNumber = index + 1;
+        if (activeTurnId && eventTimestamp) {
+            updatedAt = eventTimestamp;
+        }
+        const type = readString(payload?.type);
+        if (!type) {
+            continue;
+        }
+        if (type === "task_started") {
+            activeTurnId = readString(payload?.turn_id);
+            startedAt = parseUnixSeconds(readNumber(payload?.started_at)) ?? eventTimestamp;
+            updatedAt = eventTimestamp ?? startedAt;
+            events.push({
+                lineNumber,
+                kind: "task",
+                timestamp: eventTimestamp,
+                type,
+                turnId: activeTurnId,
+                status: "started",
+                text: null,
+                toolName: null,
+                phase: null,
+            });
+            continue;
+        }
+        if (isTaskTerminalEvent(type)) {
+            const turnId = readString(payload?.turn_id);
+            events.push({
+                lineNumber,
+                kind: "task",
+                timestamp: eventTimestamp,
+                type,
+                turnId,
+                status: terminalStatusForEvent(type),
+                text: readString(payload?.last_agent_message),
+                toolName: null,
+                phase: null,
+            });
+            if (!activeTurnId || !turnId || turnId === activeTurnId) {
+                activeTurnId = null;
+                startedAt = null;
+                updatedAt = eventTimestamp ?? updatedAt;
+            }
+            continue;
+        }
+        if (type === "user_message") {
+            latestUserMessage = readString(payload?.message);
+            events.push({
+                lineNumber,
+                kind: "user",
+                timestamp: eventTimestamp,
+                type,
+                turnId: activeTurnId,
+                status: null,
+                text: latestUserMessage,
+                toolName: null,
+                phase: null,
+            });
+            continue;
+        }
+        if (type === "agent_message") {
+            latestAgentMessage = readString(payload?.message);
+            events.push({
+                lineNumber,
+                kind: "agent",
+                timestamp: eventTimestamp,
+                type,
+                turnId: activeTurnId,
+                status: null,
+                text: latestAgentMessage,
+                toolName: null,
+                phase: readString(payload?.phase),
+            });
+            continue;
+        }
+        if (type === "function_call") {
+            latestToolName = readString(payload?.name);
+            events.push({
+                lineNumber,
+                kind: "tool",
+                timestamp: eventTimestamp,
+                type,
+                turnId: activeTurnId,
+                status: "started",
+                text: null,
+                toolName: latestToolName,
+                phase: null,
+            });
+            continue;
+        }
+        if (type === "function_call_output") {
+            events.push({
+                lineNumber,
+                kind: "tool",
+                timestamp: eventTimestamp,
+                type,
+                turnId: activeTurnId,
+                status: "finished",
+                text: null,
+                toolName: null,
+                phase: null,
+            });
+        }
+    }
+    return {
+        threadId,
+        rolloutPath,
+        lineCount: lines.filter((line) => line.trim()).length,
+        activity: {
+            threadId,
+            rolloutPath,
+            active: Boolean(activeTurnId),
+            stale: false,
+            turnId: activeTurnId,
+            startedAt,
+            updatedAt,
+        },
+        events,
+        latestAgentMessage,
+        latestUserMessage,
+        latestToolName,
+    };
+}
+function finalizeRolloutSnapshot(snapshot, fileModifiedAtMs, options) {
+    const updatedAtMs = Math.max(snapshot.activity.updatedAt?.getTime() ?? 0, fileModifiedAtMs);
+    const updatedAt = updatedAtMs > 0 ? new Date(updatedAtMs) : snapshot.activity.updatedAt;
+    const staleAfterMs = options.staleAfterMs ?? 5 * 60 * 1000;
+    const nowMs = options.nowMs ?? Date.now();
+    const stale = Boolean(snapshot.activity.active &&
+        updatedAt &&
+        staleAfterMs > 0 &&
+        nowMs - updatedAt.getTime() > staleAfterMs);
+    const afterLine = options.afterLine ?? 0;
+    const maxEvents = options.maxEvents ?? Number.POSITIVE_INFINITY;
+    const filteredEvents = snapshot.events.filter((event) => event.lineNumber > afterLine);
+    const events = maxEvents <= 0 ? [] : filteredEvents.slice(-maxEvents);
+    return {
+        ...snapshot,
+        activity: {
+            ...snapshot.activity,
+            updatedAt,
+            stale,
+            active: snapshot.activity.active && !stale,
+        },
+        events,
+    };
+}
+function isTaskTerminalEvent(type) {
+    return [
+        "task_complete",
+        "task_failed",
+        "task_error",
+        "turn_aborted",
+        "turn_complete",
+        "turn_failed",
+        "turn_error",
+    ].includes(type);
+}
+function terminalStatusForEvent(type) {
+    if (type.includes("abort")) {
+        return "aborted";
+    }
+    if (type.includes("fail") || type.includes("error")) {
+        return "failed";
+    }
+    return "completed";
+}
+function parseTokenUsage(value) {
+    if (!value) {
+        return null;
+    }
+    const inputTokens = readNumber(value.input_tokens);
+    const cachedInputTokens = readNumber(value.cached_input_tokens);
+    const outputTokens = readNumber(value.output_tokens);
+    const reasoningOutputTokens = readNumber(value.reasoning_output_tokens);
+    const totalTokens = readNumber(value.total_tokens);
+    if (inputTokens === null ||
+        cachedInputTokens === null ||
+        outputTokens === null ||
+        reasoningOutputTokens === null ||
+        totalTokens === null) {
+        return null;
+    }
+    return {
+        inputTokens,
+        cachedInputTokens,
+        outputTokens,
+        reasoningOutputTokens,
+        totalTokens,
+    };
+}
+function parseRateLimits(value) {
+    if (!value) {
+        return null;
+    }
+    return {
+        limitId: readString(value.limit_id),
+        limitName: readString(value.limit_name),
+        planType: readString(value.plan_type),
+        primary: parseRateLimitWindow(readObject(value.primary)),
+        secondary: parseRateLimitWindow(readObject(value.secondary)),
+    };
+}
+function parseRateLimitWindow(value) {
+    if (!value) {
+        return null;
+    }
+    const usedPercent = readNumber(value.used_percent);
+    const windowMinutes = readNumber(value.window_minutes);
+    if (usedPercent === null || windowMinutes === null) {
+        return null;
+    }
+    const resetSeconds = readNumber(value.resets_at);
+    return {
+        usedPercent,
+        remainingPercent: Math.max(0, 100 - usedPercent),
+        windowMinutes,
+        resetsAt: resetSeconds === null ? null : new Date(resetSeconds * 1000),
+    };
+}
+function mapThreadRow(row) {
+    return {
+        id: typeof row.id === "string" ? row.id : String(row.id ?? ""),
+        title: typeof row.title === "string" ? row.title : "",
+        cwd: typeof row.cwd === "string" ? row.cwd : "",
+        model: typeof row.model === "string" ? row.model : null,
+        reasoningEffort: typeof row.reasoning_effort === "string" ? row.reasoning_effort : null,
+        sandboxMode: parseSandboxPolicy(row.sandbox_policy),
+        approvalPolicy: parseApprovalMode(row.approval_mode),
+        createdAt: fromUnixSeconds(row.created_at),
+        updatedAt: fromUnixSeconds(row.updated_at),
+        firstUserMessage: typeof row.first_user_message === "string" ? row.first_user_message : "",
+    };
+}
+function parseApprovalMode(value) {
+    return typeof value === "string" && isCodexApprovalPolicy(value) ? value : null;
+}
+function parseSandboxPolicy(value) {
+    if (typeof value !== "string" || !value.trim()) {
+        return null;
+    }
+    if (isCodexSandboxMode(value)) {
+        return value;
+    }
+    try {
+        const parsed = JSON.parse(value);
+        return typeof parsed.type === "string" && isCodexSandboxMode(parsed.type) ? parsed.type : null;
+    }
+    catch {
+        return null;
+    }
+}
+function fromUnixSeconds(value) {
+    return typeof value === "number" ? new Date(value * 1000) : new Date(0);
+}
+function parseUnixSeconds(value) {
+    return value === null ? null : new Date(value * 1000);
+}
+function parseTimestamp(value) {
+    if (!value) {
+        return null;
+    }
+    const parsed = new Date(value);
+    return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+function readObject(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function readNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function readString(value) {
+    return typeof value === "string" ? value : null;
+}
+function withDatabase(fn) {
+    if (!BetterSqlite3) {
+        return null;
+    }
+    const databasePath = findLatestDatabase();
+    if (!databasePath) {
+        return null;
+    }
+    let db = null;
+    try {
+        db = new BetterSqlite3(databasePath, { readonly: true, fileMustExist: true });
+        return fn(db);
+    }
+    catch {
+        return null;
+    }
+    finally {
+        try {
+            db?.close();
+        }
+        catch {
+            // Ignore close failures.
+        }
+    }
+}
+function getCodexDir() {
+    const home = process.env.HOME?.trim();
+    return home ? path.join(home, ".codex") : null;
+}
+function getModelsCachePath() {
+    const codexDir = getCodexDir();
+    return codexDir ? path.join(codexDir, "models_cache.json") : null;
+}