@roamcode.ai/server 1.0.0 → 1.0.1

package/dist/providers/codex-profile-client.d.ts

@@ -1,16 +0,0 @@
-import type { ZodType } from "zod";
-import { type SpawnCodexAppServerTransport } from "./codex-app-server-client.js";
-export interface CodexProfileClientLifecycle {
-    readConfig<T>(profile: string, codexHome: string, cwd: string, schema: ZodType<T>): Promise<T>;
-}
-export interface CreateCodexProfileClientLifecycleOptions {
-    readonly codexBin: string;
-    readonly env?: NodeJS.ProcessEnv;
-    readonly spawnTransport?: SpawnCodexAppServerTransport;
-    readonly timeoutMs?: number;
-}
-/** Required selected-profile lifecycle. It owns Task 6 client construction, canonical env, start, and stop. */
-export declare function createCodexProfileClientLifecycle(options: CreateCodexProfileClientLifecycleOptions): CodexProfileClientLifecycle;
-/** Isolated protocol seam for service tests; unavailable outside the test process. */
-export declare function createCodexProfileClientLifecycleForTests(readConfig: CodexProfileClientLifecycle["readConfig"]): CodexProfileClientLifecycle;
-export declare function isCodexProfileClientLifecycle(value: unknown): value is CodexProfileClientLifecycle;

package/dist/providers/codex-profile-client.js

@@ -1,52 +0,0 @@
-import { CodexAppServerClient, } from "./codex-app-server-client.js";
-import { ProviderError } from "./types.js";
-const lifecycles = new WeakSet();
-function unavailable() {
-    return new ProviderError("OSS_PROVIDER_DEFERRED", "Codex profile capability proof is unavailable");
-}
-function brand(lifecycle) {
-    lifecycles.add(lifecycle);
-    return lifecycle;
-}
-/** Required selected-profile lifecycle. It owns Task 6 client construction, canonical env, start, and stop. */
-export function createCodexProfileClientLifecycle(options) {
-    return brand({
-        async readConfig(profile, codexHome, cwd, schema) {
-            const clientOptions = {
-                codexBin: options.codexBin,
-                profile,
-                env: { ...(options.env ?? process.env), CODEX_HOME: codexHome },
-                ...(options.spawnTransport ? { spawnTransport: options.spawnTransport } : {}),
-                ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
-            };
-            const client = new CodexAppServerClient(clientOptions);
-            let result;
-            let failed = false;
-            try {
-                await client.start();
-                result = await client.request("config/read", { cwd, includeLayers: false }, schema);
-            }
-            catch {
-                failed = true;
-            }
-            try {
-                await client.stop();
-            }
-            catch {
-                failed = true;
-            }
-            if (failed || result === undefined)
-                throw unavailable();
-            return result;
-        },
-    });
-}
-/** Isolated protocol seam for service tests; unavailable outside the test process. */
-export function createCodexProfileClientLifecycleForTests(readConfig) {
-    if (process.env.NODE_ENV !== "test")
-        throw unavailable();
-    return brand({ readConfig });
-}
-export function isCodexProfileClientLifecycle(value) {
-    return typeof value === "object" && value !== null && lifecycles.has(value);
-}

package/dist/providers/codex-profile-security.d.ts

@@ -1,23 +0,0 @@
-export interface CodexProfileFingerprint {
-    readonly path: string;
-    readonly realPath: string;
-    readonly dev: bigint;
-    readonly ino: bigint;
-    readonly size: bigint;
-    readonly mtimeNs: bigint;
-    readonly digest: string;
-}
-export interface CodexLaunchConfigFingerprint {
-    readonly homeDev: bigint;
-    readonly homeIno: bigint;
-    readonly homeSize: bigint;
-    readonly homeMtimeNs: bigint;
-    readonly base: CodexProfileFingerprint | null;
-    readonly profile: CodexProfileFingerprint;
-}
-export declare function resolveSecureCodexHome(configured: string | undefined): Promise<string | undefined>;
-export declare function listSecureProfileNames(codexHome: string, validName: (name: string) => boolean): Promise<string[]>;
-export declare function captureProfileFingerprint(codexHome: string, profile: string): Promise<CodexProfileFingerprint | undefined>;
-export declare function sameProfileFingerprint(left: CodexProfileFingerprint, right: CodexProfileFingerprint | undefined): boolean;
-export declare function captureLaunchConfigFingerprint(codexHome: string, profile: string): Promise<CodexLaunchConfigFingerprint | undefined>;
-export declare function sameLaunchConfigFingerprint(left: CodexLaunchConfigFingerprint, right: CodexLaunchConfigFingerprint | undefined): boolean;

package/dist/providers/codex-profile-security.js

@@ -1,161 +0,0 @@
-import { createHash } from "node:crypto";
-import { lstat, readFile, readdir, realpath } from "node:fs/promises";
-import { isAbsolute, join, parse, relative, resolve, sep } from "node:path";
-const PROFILE_SUFFIX = ".config.toml";
-const MAX_DIRECTORY_ENTRIES = 1_024;
-const MAX_CONFIG_BYTES = 1024 * 1024;
-async function hasSymlinkComponent(path) {
-    const absolute = resolve(path);
-    const root = parse(absolute).root;
-    const segments = absolute.slice(root.length).split(sep).filter(Boolean);
-    let current = root;
-    for (const segment of segments) {
-        current = join(current, segment);
-        if ((await lstat(current)).isSymbolicLink())
-            return true;
-    }
-    return false;
-}
-export async function resolveSecureCodexHome(configured) {
-    if (!configured || !isAbsolute(configured))
-        return undefined;
-    try {
-        if (await hasSymlinkComponent(configured))
-            return undefined;
-        const stat = await lstat(configured, { bigint: true });
-        if (!stat.isDirectory() || stat.isSymbolicLink())
-            return undefined;
-        const canonical = await realpath(configured);
-        const after = await lstat(configured, { bigint: true });
-        return canonical === resolve(configured) &&
-            after.isDirectory() &&
-            !after.isSymbolicLink() &&
-            stat.dev === after.dev &&
-            stat.ino === after.ino
-            ? canonical
-            : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-export async function listSecureProfileNames(codexHome, validName) {
-    if ((await resolveSecureCodexHome(codexHome)) !== codexHome)
-        return [];
-    const before = await lstat(codexHome, { bigint: true });
-    const entries = await readdir(codexHome, { withFileTypes: true });
-    const profiles = [];
-    for (const entry of entries.slice(0, MAX_DIRECTORY_ENTRIES)) {
-        if (!entry.isFile() || entry.isSymbolicLink() || !entry.name.endsWith(PROFILE_SUFFIX))
-            continue;
-        const profile = entry.name.slice(0, -PROFILE_SUFFIX.length);
-        if (!validName(profile))
-            continue;
-        const fingerprint = await captureProfileFingerprint(codexHome, profile);
-        if (fingerprint)
-            profiles.push(profile);
-    }
-    const after = await lstat(codexHome, { bigint: true });
-    if ((await resolveSecureCodexHome(codexHome)) !== codexHome ||
-        before.dev !== after.dev ||
-        before.ino !== after.ino ||
-        before.size !== after.size ||
-        before.mtimeNs !== after.mtimeNs) {
-        return [];
-    }
-    return [...new Set(profiles)].sort((left, right) => left.localeCompare(right));
-}
-export async function captureProfileFingerprint(codexHome, profile) {
-    return captureConfigFileFingerprint(codexHome, join(codexHome, `${profile}${PROFILE_SUFFIX}`));
-}
-async function captureConfigFileFingerprint(codexHome, path) {
-    try {
-        if (relative(codexHome, path).startsWith(".."))
-            return undefined;
-        const stat = await lstat(path, { bigint: true });
-        if (!stat.isFile() || stat.isSymbolicLink())
-            return undefined;
-        if (stat.size > BigInt(MAX_CONFIG_BYTES))
-            return undefined;
-        const realPath = await realpath(path);
-        if (realPath !== path)
-            return undefined;
-        const contents = await readFile(path);
-        const after = await lstat(path, { bigint: true });
-        if (!after.isFile() ||
-            after.isSymbolicLink() ||
-            stat.dev !== after.dev ||
-            stat.ino !== after.ino ||
-            stat.size !== after.size ||
-            stat.mtimeNs !== after.mtimeNs) {
-            return undefined;
-        }
-        return {
-            path,
-            realPath,
-            dev: stat.dev,
-            ino: stat.ino,
-            size: stat.size,
-            mtimeNs: stat.mtimeNs,
-            digest: createHash("sha256").update(contents).digest("hex"),
-        };
-    }
-    catch {
-        return undefined;
-    }
-}
-export function sameProfileFingerprint(left, right) {
-    return Boolean(right &&
-        left.path === right.path &&
-        left.realPath === right.realPath &&
-        left.dev === right.dev &&
-        left.ino === right.ino &&
-        left.size === right.size &&
-        left.mtimeNs === right.mtimeNs &&
-        left.digest === right.digest);
-}
-export async function captureLaunchConfigFingerprint(codexHome, profile) {
-    try {
-        if ((await resolveSecureCodexHome(codexHome)) !== codexHome)
-            return undefined;
-        const home = await lstat(codexHome, { bigint: true });
-        const selected = await captureProfileFingerprint(codexHome, profile);
-        if (!selected)
-            return undefined;
-        const basePath = join(codexHome, "config.toml");
-        let base = null;
-        try {
-            const baseStat = await lstat(basePath);
-            if (!baseStat.isFile() || baseStat.isSymbolicLink())
-                return undefined;
-            const capturedBase = await captureConfigFileFingerprint(codexHome, basePath);
-            if (!capturedBase)
-                return undefined;
-            base = capturedBase;
-        }
-        catch (error) {
-            if (error.code !== "ENOENT")
-                return undefined;
-        }
-        return {
-            homeDev: home.dev,
-            homeIno: home.ino,
-            homeSize: home.size,
-            homeMtimeNs: home.mtimeNs,
-            base,
-            profile: selected,
-        };
-    }
-    catch {
-        return undefined;
-    }
-}
-export function sameLaunchConfigFingerprint(left, right) {
-    return Boolean(right &&
-        left.homeDev === right.homeDev &&
-        left.homeIno === right.homeIno &&
-        left.homeSize === right.homeSize &&
-        left.homeMtimeNs === right.homeMtimeNs &&
-        (left.base === null ? right.base === null : right.base !== null && sameProfileFingerprint(left.base, right.base)) &&
-        sameProfileFingerprint(left.profile, right.profile));
-}

package/dist/providers/codex-provider.d.ts

@@ -1,15 +0,0 @@
-import { type AttachSpawnOptions } from "../config.js";
-import { type AgentProvider, type CodexProfileLaunchProof, type ProviderProcessContext, type ProviderAvailability } from "./types.js";
-export interface CreateCodexProviderOptions {
-    codexBin: string;
-    env?: NodeJS.ProcessEnv;
-    attach?: AttachSpawnOptions;
-    getAttach?: () => AttachSpawnOptions | undefined;
-    probe?: () => Promise<ProviderAvailability>;
-    /** Task 7 supplies the effective-provider capability check; this adapter never reads profile files. */
-    validateProfile?(profile: string, cwd: string): CodexProfileLaunchProof | Promise<CodexProfileLaunchProof>;
-}
-type CodexAttachContext = Pick<AttachSpawnOptions, "baseUrl" | "token" | "mcpScriptPath">;
-export declare function buildCodexArgs(context: ProviderProcessContext, attach?: CodexAttachContext): string[];
-export declare function createCodexProvider(options: CreateCodexProviderOptions): AgentProvider;
-export {};

package/dist/providers/codex-provider.js

@@ -1,174 +0,0 @@
-import { codexMcpTokenPathFor } from "../config.js";
-import { isAbsolute } from "node:path";
-import { classifyCodexPane, createCodexOscParser, parseCodexOscNotifications, parseCodexRuntimeMetadata, } from "./codex-activity.js";
-import { assertExactCodexResumeArgs } from "./codex-thread-resolver.js";
-import { cleanupProviderArtifacts, writeProviderArtifact0600 } from "./provider-artifacts.js";
-import { ProviderError, } from "./types.js";
-function configArg(key, value) {
-    return ["-c", `${key}=${JSON.stringify(value)}`];
-}
-function validResumeId(id) {
-    return (id !== undefined &&
-        id.trim().length > 0 &&
-        id.length <= 2048 &&
-        !/[\p{Cc}\p{Zl}\p{Zp}]/u.test(id) &&
-        !id.trimStart().startsWith("-"));
-}
-function usableAttach(attach) {
-    return Boolean(attach?.baseUrl &&
-        attach.token &&
-        Buffer.byteLength(attach.token, "utf8") <= 4096 &&
-        !/[\p{Cc}\p{Zl}\p{Zp}]/u.test(attach.token) &&
-        attach.mcpScriptPath &&
-        attach.dataDir);
-}
-function profileUnavailable() {
-    return new ProviderError("OSS_PROVIDER_DEFERRED", "Codex profile capability proof is unavailable");
-}
-export function buildCodexArgs(context, attach) {
-    if (context.options.provider !== "codex") {
-        throw new ProviderError("INVALID_PROVIDER_OPTIONS", "Codex provider received non-Codex options");
-    }
-    if (context.intent === "fresh" && context.providerSessionId !== undefined) {
-        throw new ProviderError("INVALID_PROVIDER_OPTIONS", "Fresh Codex launch cannot include a resume identity");
-    }
-    const options = context.options;
-    const args = [];
-    let resumeId;
-    if (context.intent === "resume") {
-        resumeId = context.providerSessionId;
-        if (!validResumeId(resumeId)) {
-            throw new ProviderError("RESUME_IDENTITY_UNAVAILABLE", "Codex resume requires an exact safe session id");
-        }
-        args.push("resume");
-    }
-    if (options.model)
-        args.push("--model", options.model);
-    if (options.profile)
-        args.push("--profile", options.profile);
-    if (options.dangerouslyBypassApprovalsAndSandbox) {
-        args.push("--dangerously-bypass-approvals-and-sandbox");
-    }
-    else {
-        if (options.sandbox)
-            args.push("--sandbox", options.sandbox);
-        if (options.approvalPolicy)
-            args.push("--ask-for-approval", options.approvalPolicy);
-    }
-    if (options.webSearch)
-        args.push("--search");
-    for (const dir of options.addDirs ?? [])
-        args.push("--add-dir", dir);
-    if (options.reasoningEffort)
-        args.push(...configArg("model_reasoning_effort", options.reasoningEffort));
-    if (attach) {
-        args.push(...configArg("mcp_servers.roamcode.command", process.execPath));
-        args.push(...configArg("mcp_servers.roamcode.args", [attach.mcpScriptPath]));
-        args.push(...configArg("mcp_servers.roamcode.env_vars", ["RC_BASE_URL", "RC_SESSION_ID", "RC_TOKEN_FILE"]));
-    }
-    args.push(...configArg("tui.notifications", ["agent-turn-complete", "approval-requested", "plan-mode-prompt"]));
-    args.push(...configArg("tui.notification_method", "osc9"));
-    args.push(...configArg("tui.notification_condition", "always"));
-    // Keep the conversation in tmux's ordinary pane history. With tmux mouse mode enabled, wheel/trackpad
-    // and mobile scroll can read that history in place instead of opening Codex's separate transcript UI.
-    args.push("--no-alt-screen");
-    if (resumeId)
-        args.push("--", resumeId);
-    if (context.intent === "resume")
-        assertExactCodexResumeArgs(args);
-    return args;
-}
-export function createCodexProvider(options) {
-    return {
-        id: "codex",
-        displayName: "Codex",
-        resumeIdentity: "required",
-        probe: options.probe ?? (() => Promise.resolve({ terminalAvailable: true, metadataAvailable: false })),
-        buildProcess: async (context) => {
-            if (context.options.provider !== "codex") {
-                throw new ProviderError("INVALID_PROVIDER_OPTIONS", "Codex provider received non-Codex options");
-            }
-            let profileProof;
-            if (context.options.profile) {
-                let validateProfile;
-                try {
-                    validateProfile = options.validateProfile;
-                }
-                catch {
-                    throw profileUnavailable();
-                }
-                if (!validateProfile)
-                    throw profileUnavailable();
-                try {
-                    profileProof = await validateProfile(context.options.profile, context.cwd);
-                }
-                catch {
-                    throw profileUnavailable();
-                }
-                if (profileProof.profile !== context.options.profile ||
-                    !isAbsolute(profileProof.codexHome) ||
-                    /[\p{Cc}\p{Zl}\p{Zp}]/u.test(profileProof.codexHome) ||
-                    typeof profileProof.assertUnchanged !== "function") {
-                    throw profileUnavailable();
-                }
-            }
-            const env = { ...(options.env ?? process.env) };
-            delete env.RC_TOKEN;
-            delete env.RC_TOKEN_FILE;
-            if (profileProof)
-                env.CODEX_HOME = profileProof.codexHome;
-            const preSpawnCheck = profileProof
-                ? async () => {
-                    try {
-                        await profileProof.assertUnchanged();
-                    }
-                    catch {
-                        throw profileUnavailable();
-                    }
-                }
-                : undefined;
-            const ownedPaths = [];
-            const candidateAttach = context.attach ?? options.getAttach?.() ?? options.attach;
-            let attach;
-            try {
-                if (usableAttach(candidateAttach)) {
-                    const tokenPath = codexMcpTokenPathFor(candidateAttach.dataDir, context.roamSessionId);
-                    if (writeProviderArtifact0600(tokenPath, candidateAttach.token, context, ownedPaths)) {
-                        attach = candidateAttach;
-                        env.RC_BASE_URL = candidateAttach.baseUrl;
-                        env.RC_SESSION_ID = context.roamSessionId;
-                        env.RC_TOKEN_FILE = tokenPath;
-                    }
-                }
-                const args = buildCodexArgs(context, attach);
-                return {
-                    executable: options.codexBin,
-                    args,
-                    env,
-                    cleanupPaths: ownedPaths,
-                    ...(preSpawnCheck ? { preSpawnCheck } : {}),
-                    integration: attach
-                        ? {
-                            attachments: "ready",
-                            activity: "degraded",
-                            detail: "Codex activity uses display-text signals with pane fallback",
-                        }
-                        : {
-                            attachments: "degraded",
-                            activity: "degraded",
-                            detail: "RoamCode attachment MCP is not configured; Codex activity uses display-text signals with pane fallback",
-                        },
-                };
-            }
-            catch (error) {
-                cleanupProviderArtifacts(ownedPaths);
-                throw error;
-            }
-        },
-        createRuntimeSignalParser: createCodexOscParser,
-        runtimeSignals: parseCodexOscNotifications,
-        classifyPane: classifyCodexPane,
-        runtimeMetadata: parseCodexRuntimeMetadata,
-        cleanup: cleanupProviderArtifacts,
-    };
-}

package/dist/providers/codex-thread-coordinator.d.ts

@@ -1,18 +0,0 @@
-export interface CodexSpawnLease {
-    readonly started: Promise<void>;
-    cancel(): Promise<void>;
-}
-declare class CodexThreadResolutionCoordinator {
-    private locked;
-    private poisoned;
-    private readonly queue;
-    acquire(signal?: AbortSignal): Promise<() => void>;
-    acknowledgeCancellation(lease: CodexSpawnLease, timeoutMs: number): Promise<void>;
-    /** A launch callback ran but did not return a cancellable lease, so later discovery is permanently unsafe. */
-    poisonUnknownSpawnOutcome(): void;
-    resetForTests(): void;
-    private poison;
-    private grant;
-}
-export declare const codexThreadResolutionCoordinator: CodexThreadResolutionCoordinator;
-export {};

package/dist/providers/codex-thread-coordinator.js

@@ -1,93 +0,0 @@
-import { ProviderError } from "./types.js";
-function unavailable() {
-    return new ProviderError("RESUME_IDENTITY_UNAVAILABLE", "Codex resume identity is unavailable");
-}
-class CodexThreadResolutionCoordinator {
-    locked = false;
-    poisoned = false;
-    queue = [];
-    acquire(signal) {
-        if (this.poisoned || signal?.aborted)
-            return Promise.reject(unavailable());
-        return new Promise((resolve, reject) => {
-            const waiter = { resolve, reject, signal };
-            if (signal) {
-                waiter.abort = () => {
-                    const index = this.queue.indexOf(waiter);
-                    if (index >= 0)
-                        this.queue.splice(index, 1);
-                    reject(unavailable());
-                };
-                signal.addEventListener("abort", waiter.abort, { once: true });
-            }
-            if (!this.locked) {
-                this.locked = true;
-                this.grant(waiter);
-            }
-            else {
-                this.queue.push(waiter);
-            }
-        });
-    }
-    async acknowledgeCancellation(lease, timeoutMs) {
-        let timer;
-        try {
-            const acknowledgement = lease.cancel();
-            if (!(acknowledgement instanceof Promise))
-                throw unavailable();
-            await Promise.race([
-                acknowledgement,
-                new Promise((_, reject) => {
-                    timer = setTimeout(() => reject(unavailable()), timeoutMs);
-                    timer.unref?.();
-                }),
-            ]);
-        }
-        catch {
-            this.poison();
-            throw unavailable();
-        }
-        finally {
-            if (timer)
-                clearTimeout(timer);
-        }
-    }
-    /** A launch callback ran but did not return a cancellable lease, so later discovery is permanently unsafe. */
-    poisonUnknownSpawnOutcome() {
-        this.poison();
-    }
-    resetForTests() {
-        if (process.env.NODE_ENV !== "test" || this.locked || this.queue.length > 0)
-            throw unavailable();
-        this.poisoned = false;
-    }
-    poison() {
-        this.poisoned = true;
-        for (const waiter of this.queue.splice(0)) {
-            if (waiter.abort)
-                waiter.signal?.removeEventListener("abort", waiter.abort);
-            waiter.reject(unavailable());
-        }
-    }
-    grant(waiter) {
-        if (waiter.abort)
-            waiter.signal?.removeEventListener("abort", waiter.abort);
-        if (this.poisoned) {
-            waiter.reject(unavailable());
-            this.locked = false;
-            return;
-        }
-        let released = false;
-        waiter.resolve(() => {
-            if (released)
-                return;
-            released = true;
-            const next = this.queue.shift();
-            if (next)
-                this.grant(next);
-            else
-                this.locked = false;
-        });
-    }
-}
-export const codexThreadResolutionCoordinator = new CodexThreadResolutionCoordinator();

package/dist/providers/codex-thread-persistence.d.ts

@@ -1,9 +0,0 @@
-import { type SessionStore } from "../session-store.js";
-export interface CodexThreadPersistence {
-    markProvisional(id: string): void;
-    clear(id: string): void;
-    commit(id: string): void;
-}
-/** Creates the only persistence object accepted by the exact-thread resolver. */
-export declare function createCodexThreadPersistence(store: SessionStore, roamSessionId: string): CodexThreadPersistence;
-export declare function isCodexThreadPersistence(value: unknown): value is CodexThreadPersistence;

package/dist/providers/codex-thread-persistence.js

@@ -1,45 +0,0 @@
-import { isConcreteSessionStore } from "../session-store.js";
-const capabilities = new WeakSet();
-class StoreBoundCodexThreadPersistence {
-    store;
-    roamSessionId;
-    constructor(store, roamSessionId) {
-        this.store = store;
-        this.roamSessionId = roamSessionId;
-    }
-    markProvisional(id) {
-        this.requireCodexSession();
-        this.store.markProvisionalProviderSessionId(this.roamSessionId, id);
-        if (this.store.get(this.roamSessionId)?.providerSessionId !== undefined)
-            throw new Error("Persistence failed");
-    }
-    clear(id) {
-        this.requireCodexSession();
-        this.store.clearProvisionalProviderSessionId(this.roamSessionId, id);
-        if (this.store.get(this.roamSessionId)?.providerSessionId !== undefined)
-            throw new Error("Rollback failed");
-    }
-    commit(id) {
-        this.requireCodexSession();
-        this.store.commitProvisionalProviderSessionId(this.roamSessionId, id);
-        if (this.store.get(this.roamSessionId)?.providerSessionId !== id)
-            throw new Error("Persistence identity changed");
-    }
-    requireCodexSession() {
-        const session = this.store.get(this.roamSessionId);
-        if (!session || session.provider !== "codex")
-            throw new Error("Codex session is unavailable");
-        return session;
-    }
-}
-/** Creates the only persistence object accepted by the exact-thread resolver. */
-export function createCodexThreadPersistence(store, roamSessionId) {
-    if (!isConcreteSessionStore(store) || roamSessionId.length === 0)
-        throw new Error("Invalid Codex persistence");
-    const capability = new StoreBoundCodexThreadPersistence(store, roamSessionId);
-    capabilities.add(capability);
-    return capability;
-}
-export function isCodexThreadPersistence(value) {
-    return typeof value === "object" && value !== null && capabilities.has(value);
-}

package/dist/providers/codex-thread-resolver.d.ts

@@ -1,59 +0,0 @@
-import { type ZodType } from "zod";
-import { type CodexSpawnLease } from "./codex-thread-coordinator.js";
-import { type CodexThreadPersistence } from "./codex-thread-persistence.js";
-export interface CodexThreadInventoryEntry {
-    readonly id: string;
-    readonly cwd: string;
-    readonly source: "cli" | "vscode" | "exec" | "appServer" | "unknown" | Record<string, unknown>;
-    /** Current protocol uses Unix seconds; milliseconds are normalized defensively for compatible revisions. */
-    readonly createdAt: number;
-}
-export type ReadCodexThreadInventory = () => Promise<readonly CodexThreadInventoryEntry[]>;
-export interface CodexThreadRpc {
-    request<T>(method: string, params: unknown, schema: ZodType<T>): Promise<T>;
-}
-export interface CreateCodexThreadInventoryOptions {
-    readonly cwd: string;
-    readonly maxPages?: number;
-    readonly maxItems?: number;
-}
-export interface CodexThreadResolverOptions {
-    readonly inventory: ReadCodexThreadInventory;
-    readonly now?: () => number;
-    readonly sleep?: (milliseconds: number, signal?: AbortSignal) => Promise<void>;
-    readonly deadlineMs?: number;
-    readonly pollIntervalMs?: number;
-    readonly maxInventoryItems?: number;
-    readonly creationSkewMs?: number;
-    readonly cancellationAckMs?: number;
-}
-export interface ResolveCodexThreadOptions {
-    readonly cwd: string;
-    /** The launch callback is intentionally inside the process-wide identity mutex. */
-    readonly spawn: (signal: AbortSignal) => CodexSpawnLease;
-    readonly persistence: CodexThreadPersistence;
-    readonly signal?: AbortSignal;
-}
-export declare function resetCodexThreadResolutionCoordinatorForTests(): void;
-/** Shared assertion used by the provider's generated resume argv regression. */
-export declare function assertExactCodexResumeArgs(args: readonly string[]): void;
-/** Creates the bounded current-protocol `thread/list` reader used by resolver snapshots and polls. */
-export declare function createCodexThreadInventory(rpc: CodexThreadRpc, options: CreateCodexThreadInventoryOptions): ReadCodexThreadInventory;
-export declare class CodexThreadResolver {
-    private readonly inventory;
-    private readonly now;
-    private readonly sleep;
-    private readonly deadlineMs;
-    private readonly pollIntervalMs;
-    private readonly maxInventoryItems;
-    private readonly creationSkewMs;
-    private readonly cancellationAckMs;
-    private readonly maxPolls;
-    constructor(options: CodexThreadResolverOptions);
-    resolveAfterSpawn(options: ResolveCodexThreadOptions): Promise<string>;
-    private resolveLocked;
-    private readInventory;
-    private candidates;
-    private sameIdentity;
-    private throwIfCancelled;
-}