@roamcode.ai/server 1.0.0

package/dist/providers/codex-latest-service.js

@@ -0,0 +1,174 @@
+export const CODEX_VERSION_UNAVAILABLE = "CODEX_VERSION_UNAVAILABLE";
+export const CODEX_VERSION_TIMEOUT_MS = 5_000;
+export const CODEX_VERSION_MAX_OUTPUT_BYTES = 1_024;
+export const CODEX_LATEST_MAX_RESPONSE_BYTES = 16_384;
+export const DEFAULT_CODEX_VERSION_CACHE_TTL_MS = 5 * 60_000;
+export class CodexVersionUnavailableError extends Error {
+    code = CODEX_VERSION_UNAVAILABLE;
+    constructor() {
+        super("Codex version is unavailable");
+        this.name = "CodexVersionUnavailableError";
+    }
+}
+const SEMVER_SOURCE = "(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-([0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*))?(?:\\+[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)?";
+const SEMVER_RE = new RegExp(`^${SEMVER_SOURCE}$`);
+const CODEX_VERSION_RE = new RegExp(`^codex-cli (${SEMVER_SOURCE})\\r?\\n?$`);
+function unavailable() {
+    return new CodexVersionUnavailableError();
+}
+function positiveInteger(value, fallback) {
+    return value !== undefined && Number.isSafeInteger(value) && value > 0 ? value : fallback;
+}
+function parseSemver(value) {
+    const match = SEMVER_RE.exec(value);
+    if (!match)
+        return undefined;
+    const major = Number(match[1]);
+    const minor = Number(match[2]);
+    const patch = Number(match[3]);
+    if (![major, minor, patch].every(Number.isSafeInteger))
+        return undefined;
+    const prerelease = match[4]?.split(".");
+    if (prerelease?.some((identifier) => /^\d+$/.test(identifier) && identifier.length > 1 && identifier.startsWith("0"))) {
+        return undefined;
+    }
+    return { major, minor, patch, ...(prerelease ? { prerelease } : {}) };
+}
+function compareIdentifiers(left, right) {
+    const leftNumeric = /^\d+$/.test(left);
+    const rightNumeric = /^\d+$/.test(right);
+    if (leftNumeric && rightNumeric) {
+        if (left.length !== right.length)
+            return left.length - right.length;
+        return left === right ? 0 : left < right ? -1 : 1;
+    }
+    if (leftNumeric !== rightNumeric)
+        return leftNumeric ? -1 : 1;
+    return left === right ? 0 : left < right ? -1 : 1;
+}
+function compareSemver(left, right) {
+    for (const key of ["major", "minor", "patch"]) {
+        if (left[key] !== right[key])
+            return left[key] - right[key];
+    }
+    if (!left.prerelease && !right.prerelease)
+        return 0;
+    if (!left.prerelease)
+        return 1;
+    if (!right.prerelease)
+        return -1;
+    const length = Math.max(left.prerelease.length, right.prerelease.length);
+    for (let index = 0; index < length; index += 1) {
+        const leftIdentifier = left.prerelease[index];
+        const rightIdentifier = right.prerelease[index];
+        if (leftIdentifier === undefined)
+            return -1;
+        if (rightIdentifier === undefined)
+            return 1;
+        const compared = compareIdentifiers(leftIdentifier, rightIdentifier);
+        if (compared !== 0)
+            return compared;
+    }
+    return 0;
+}
+export function parseCodexVersion(stdout) {
+    if (typeof stdout !== "string" || Buffer.byteLength(stdout) > CODEX_VERSION_MAX_OUTPUT_BYTES)
+        throw unavailable();
+    const match = CODEX_VERSION_RE.exec(stdout);
+    if (!match || !parseSemver(match[1]))
+        throw unavailable();
+    return match[1];
+}
+function hintFor(provenance) {
+    if (provenance === "chatgpt")
+        return "Update Codex through the ChatGPT app.";
+    if (provenance === "homebrew")
+        return "Update Codex through Homebrew.";
+    return "Update Codex through the installation source that provided it.";
+}
+export class CodexLatestService {
+    options;
+    now;
+    cacheTtlMs;
+    cache;
+    inFlight;
+    constructor(options) {
+        this.options = options;
+        this.now = options.now ?? (() => Date.now());
+        this.cacheTtlMs = positiveInteger(options.cacheTtlMs, DEFAULT_CODEX_VERSION_CACHE_TTL_MS);
+    }
+    async getVersion(force = false) {
+        const now = this.now();
+        if (!force && this.cache && now - this.cache.at < this.cacheTtlMs)
+            return { ...this.cache.info };
+        if (this.inFlight)
+            return { ...(await this.inFlight) };
+        const request = this.loadVersion();
+        this.inFlight = request;
+        try {
+            const info = await request;
+            this.cache = { at: this.now(), info: { ...info } };
+            return { ...info };
+        }
+        finally {
+            if (this.inFlight === request)
+                this.inFlight = undefined;
+        }
+    }
+    async loadVersion() {
+        let run;
+        try {
+            run = await this.options.runVersion(["--version"], {
+                timeoutMs: CODEX_VERSION_TIMEOUT_MS,
+                maxOutputBytes: CODEX_VERSION_MAX_OUTPUT_BYTES,
+            });
+        }
+        catch {
+            throw unavailable();
+        }
+        if (run.code !== 0 ||
+            typeof run.stdout !== "string" ||
+            typeof run.stderr !== "string" ||
+            Buffer.byteLength(run.stdout) + Buffer.byteLength(run.stderr) > CODEX_VERSION_MAX_OUTPUT_BYTES) {
+            throw unavailable();
+        }
+        const installed = parseCodexVersion(run.stdout);
+        let provenance;
+        try {
+            provenance = await this.options.detectProvenance();
+        }
+        catch {
+            provenance = "unknown";
+        }
+        if (!["npm", "chatgpt", "homebrew", "unknown"].includes(provenance))
+            provenance = "unknown";
+        if (provenance !== "npm")
+            return { installed, provenance, updateHint: hintFor(provenance) };
+        try {
+            const latestRaw = await this.options.fetchNpmLatest("@openai/codex", {
+                timeoutMs: CODEX_VERSION_TIMEOUT_MS,
+                maxResponseBytes: CODEX_LATEST_MAX_RESPONSE_BYTES,
+            });
+            if (typeof latestRaw !== "string" || Buffer.byteLength(latestRaw) > 256)
+                throw unavailable();
+            const latest = latestRaw.trim();
+            const installedSemver = parseSemver(installed);
+            const latestSemver = parseSemver(latest);
+            if (!installedSemver || !latestSemver)
+                throw unavailable();
+            return {
+                installed,
+                latest,
+                updateAvailable: compareSemver(installedSemver, latestSemver) < 0,
+                provenance,
+            };
+        }
+        catch {
+            return {
+                installed,
+                provenance,
+                updateHint: "Latest npm version is temporarily unavailable.",
+            };
+        }
+    }
+}

package/dist/providers/codex-metadata-service.d.ts

@@ -0,0 +1,161 @@
+import { type ZodType } from "zod";
+import { type CodexProfileLaunchProof } from "./types.js";
+import { type CodexProfileClientLifecycle } from "./codex-profile-client.js";
+import type { ReadCodexThreadInventory } from "./codex-thread-resolver.js";
+export declare const CODEX_METADATA_ERROR_CODE: "CODEX_METADATA_UNAVAILABLE";
+export declare const CODEX_MODEL_CATALOG_ERROR_CODE: "CODEX_MODEL_CATALOG_UNAVAILABLE";
+export declare const OSS_PROVIDER_DEFERRED: "OSS_PROVIDER_DEFERRED";
+export interface CodexMetadataRpc {
+    request<T>(method: string, params: unknown, schema: ZodType<T>): Promise<T>;
+    onNotification(listener: (notification: {
+        method: string;
+        params?: unknown;
+    }) => void): () => void;
+    start?(): Promise<void>;
+    stop?(): Promise<void>;
+}
+export interface CodexAccount {
+    readonly authenticated: boolean;
+    readonly authMethod: "none" | "apiKey" | "chatgpt";
+    readonly plan?: string;
+}
+export interface CodexModel {
+    readonly value: string;
+    readonly id: string;
+    readonly displayName: string;
+    readonly description: string;
+    readonly isDefault: boolean;
+    readonly reasoningOptions: ReadonlyArray<{
+        value: string;
+        description: string;
+        isDefault: boolean;
+    }>;
+    readonly supportedReasoningEfforts: string[];
+    readonly defaultReasoningEffort: string;
+}
+export interface CodexUsageBar {
+    readonly id: string;
+    readonly label: string;
+    readonly percent: number;
+    readonly resetsAt?: number;
+    readonly windowDurationMs?: number;
+}
+export interface CodexUsage {
+    readonly bars: CodexUsageBar[];
+    readonly credits?: {
+        readonly hasCredits: boolean;
+        readonly unlimited: boolean;
+        readonly balance?: string;
+        readonly resetCreditsAvailable?: number;
+    };
+    readonly fetchedAt: number;
+}
+export type CodexLoginCompletion = {
+    readonly status: "completed";
+} | {
+    readonly status: "failed";
+} | {
+    readonly status: "canceled";
+} | {
+    readonly status: "expired";
+};
+export type CodexLoginStatus = CodexLoginCompletion | {
+    readonly status: "pending";
+} | {
+    readonly status: "notFound";
+};
+export interface CodexDeviceLogin {
+    readonly loginId: string;
+    readonly userCode: string;
+    readonly verificationUrl: string;
+    readonly expiresAt: number;
+    readonly completion: Promise<CodexLoginCompletion>;
+}
+export interface CodexMetadataServiceOptions {
+    readonly now?: () => number;
+    readonly loginTtlMs?: number;
+    readonly modelCacheTtlMs?: number;
+    readonly capabilityCacheTtlMs?: number;
+    readonly capabilityTimeoutMs?: number;
+    readonly maxModelPages?: number;
+    readonly maxModelItems?: number;
+    readonly codexHome?: string;
+    readonly profileClient?: CodexProfileClientLifecycle;
+}
+export declare class CodexMetadataServiceError extends Error {
+    readonly code: "CODEX_METADATA_UNAVAILABLE";
+    constructor(message?: string);
+}
+export declare class CodexModelCatalogError extends Error {
+    readonly code: "CODEX_MODEL_CATALOG_UNAVAILABLE";
+    constructor();
+}
+export declare class CodexProfileCapabilityError extends Error {
+    readonly code: "OSS_PROVIDER_DEFERRED";
+    constructor();
+}
+export declare class CodexMetadataService {
+    private readonly rpc;
+    private readonly now;
+    private readonly loginTtlMs;
+    private readonly modelCacheTtlMs;
+    private readonly capabilityCacheTtlMs;
+    private readonly capabilityTimeoutMs;
+    private readonly maxModelPages;
+    private readonly maxModelItems;
+    private readonly codexHome?;
+    private readonly profileClient?;
+    private readonly activeLogins;
+    private readonly earlyLoginCompletions;
+    private readonly retiredLoginIds;
+    private readonly loginOutcomes;
+    private activeStartGeneration?;
+    private nextStartGeneration;
+    private startingLogin?;
+    private modelCache?;
+    private modelRequest?;
+    private lastUsageDiagnostic?;
+    private lastCapabilityDiagnostic?;
+    private capabilityCache?;
+    private capabilityRequest?;
+    private readonly unsubscribeNotification;
+    private disposed;
+    constructor(rpc: CodexMetadataRpc, options?: CodexMetadataServiceOptions);
+    get diagnostics(): {
+        readonly usage?: {
+            readonly code: typeof CODEX_METADATA_ERROR_CODE;
+            readonly message: string;
+        };
+        readonly capabilities?: {
+            readonly code: typeof CODEX_METADATA_ERROR_CODE;
+            readonly message: string;
+        };
+    };
+    probeCapabilities(cwd: string, readThreadInventory: ReadCodexThreadInventory): Promise<boolean>;
+    private loadCapabilities;
+    getAccount(): Promise<CodexAccount>;
+    startDeviceLogin(): Promise<CodexDeviceLogin>;
+    cancelLogin(loginId: string): Promise<{
+        status: "canceled" | "notFound";
+    }>;
+    getLoginStatus(loginId: string): CodexLoginStatus;
+    dispose(): void;
+    getModels(force?: boolean): Promise<CodexModel[]>;
+    validateModelSelection(model: string, reasoningEffort?: string): Promise<void>;
+    getUsage(): Promise<CodexUsage | null>;
+    listProfiles(): Promise<string[]>;
+    readonly validateProfile: (profile: string, cwd: string) => Promise<CodexProfileLaunchProof>;
+    private readProfileConfig;
+    private installLogin;
+    private onNotification;
+    private settleLogin;
+    private finishStartGeneration;
+    private retireLoginId;
+    private pruneEarlyLoginCompletions;
+    private pruneRetiredLoginIds;
+    private recordLoginOutcome;
+    private pruneLoginOutcomes;
+    private expireLogin;
+    private loadModels;
+    private appendSnapshotBars;
+}