@love-moon/ai-sdk 0.2.42 → 0.3.2

package/CHANGELOG.md

@@ -0,0 +1,26 @@
+# @love-moon/ai-sdk
+
+## 0.3.2
+
+### Patch Changes
+
+- 8e1d4a8: Prefer the bundled Copilot platform executable before the JS entrypoint so Node
+  20 installs do not fail with `ERR_UNKNOWN_BUILTIN_MODULE: node:sqlite`.
+
+## 0.3.1
+
+### Patch Changes
+
+- 4e8d4e5: Include `CHANGELOG.md` in published npm tarballs.
+
+  The `files` array in each package's `package.json` previously only
+  listed the build output (`bin`/`src` for the CLI, `dist` for the
+  modules). npm's `files` whitelist replaces the default include set,
+  and CHANGELOG is not one of the auto-included files (only
+  `package.json`, `README*`, `LICENSE*`, and `main` are unconditional).
+
+  As a result, every release through 0.3.0 published tarballs with no
+  CHANGELOG, so a consumer running `npm install` or unpacking the brew
+  artifact had no way to see what changed in the version they just
+  installed. The repo `cli/CHANGELOG.md` and the GitHub Release body
+  remain the canonical source until 0.3.1 ships with this fix.

package/dist/built-in-backends.d.ts

@@ -0,0 +1,51 @@
+export function listBuiltInBackends(): string[];
+export function normalizeBuiltInBackend(backend: any): any;
+export function isBuiltInBackend(backend: any): boolean;
+export function getBuiltInBackendEntry(backend: any): BuiltInBackendEntry | null;
+/**
+ * Canonical registry of built-in AI SDK backends.
+ *
+ * This is the single source of truth for:
+ *   - backend canonical name (e.g. "codex", "claude")
+ *   - accepted aliases (e.g. "code" → "codex", "kimi-cli" → "kimi")
+ *   - session variants (default + structured-output variant, if any)
+ *
+ * Provider surfaces that need to know about built-in backends (session
+ * factory, resume dispatcher, etc.) import from here so that adding a new
+ * built-in backend is a one-line change in this file, plus the provider's own
+ * implementation module.
+ */
+export const CODEX_APP_SERVER_VARIANT: "codex-app-server";
+export const CODEX_EXEC_VARIANT: "codex-exec";
+export const CLAUDE_AGENT_SDK_VARIANT: "claude-agent-sdk";
+export const COPILOT_SDK_VARIANT: "copilot-sdk";
+export const KIMI_CLI_WIRE_VARIANT: "kimi-cli-wire";
+export const KIMI_CLI_PRINT_VARIANT: "kimi-cli-print";
+export const OPENCODE_SDK_VARIANT: "opencode-sdk";
+/**
+ * @typedef {Object} BuiltInBackendEntry
+ * @property {string}   backend        Canonical backend name.
+ * @property {string[]} aliases        All accepted aliases (INCLUDING the canonical name).
+ * @property {string}   defaultVariant Variant used when no structured-output preference is set.
+ * @property {string=}  structuredVariant Optional variant used when structured output is requested.
+ */
+/** @type {BuiltInBackendEntry[]} */
+export const BUILT_IN_BACKENDS: BuiltInBackendEntry[];
+export type BuiltInBackendEntry = {
+    /**
+     * Canonical backend name.
+     */
+    backend: string;
+    /**
+     * All accepted aliases (INCLUDING the canonical name).
+     */
+    aliases: string[];
+    /**
+     * Variant used when no structured-output preference is set.
+     */
+    defaultVariant: string;
+    /**
+     * Optional variant used when structured output is requested.
+     */
+    structuredVariant?: string | undefined;
+};

package/dist/built-in-backends.js

@@ -0,0 +1,78 @@
+/**
+ * Canonical registry of built-in AI SDK backends.
+ *
+ * This is the single source of truth for:
+ *   - backend canonical name (e.g. "codex", "claude")
+ *   - accepted aliases (e.g. "code" → "codex", "kimi-cli" → "kimi")
+ *   - session variants (default + structured-output variant, if any)
+ *
+ * Provider surfaces that need to know about built-in backends (session
+ * factory, resume dispatcher, etc.) import from here so that adding a new
+ * built-in backend is a one-line change in this file, plus the provider's own
+ * implementation module.
+ */
+export const CODEX_APP_SERVER_VARIANT = "codex-app-server";
+export const CODEX_EXEC_VARIANT = "codex-exec";
+export const CLAUDE_AGENT_SDK_VARIANT = "claude-agent-sdk";
+export const COPILOT_SDK_VARIANT = "copilot-sdk";
+export const KIMI_CLI_WIRE_VARIANT = "kimi-cli-wire";
+export const KIMI_CLI_PRINT_VARIANT = "kimi-cli-print";
+export const OPENCODE_SDK_VARIANT = "opencode-sdk";
+/**
+ * @typedef {Object} BuiltInBackendEntry
+ * @property {string}   backend        Canonical backend name.
+ * @property {string[]} aliases        All accepted aliases (INCLUDING the canonical name).
+ * @property {string}   defaultVariant Variant used when no structured-output preference is set.
+ * @property {string=}  structuredVariant Optional variant used when structured output is requested.
+ */
+/** @type {BuiltInBackendEntry[]} */
+export const BUILT_IN_BACKENDS = [
+    {
+        backend: "codex",
+        aliases: ["codex", "code"],
+        defaultVariant: CODEX_APP_SERVER_VARIANT,
+        structuredVariant: CODEX_EXEC_VARIANT,
+    },
+    {
+        backend: "claude",
+        aliases: ["claude", "claude-code"],
+        defaultVariant: CLAUDE_AGENT_SDK_VARIANT,
+    },
+    {
+        backend: "copilot",
+        aliases: ["copilot"],
+        defaultVariant: COPILOT_SDK_VARIANT,
+    },
+    {
+        backend: "kimi",
+        aliases: ["kimi", "kimi-cli", "kimi-code"],
+        defaultVariant: KIMI_CLI_WIRE_VARIANT,
+        structuredVariant: KIMI_CLI_PRINT_VARIANT,
+    },
+    {
+        backend: "opencode",
+        aliases: ["opencode", "open-code", "open_code"],
+        defaultVariant: OPENCODE_SDK_VARIANT,
+    },
+];
+const ALIAS_TO_BACKEND = new Map();
+for (const entry of BUILT_IN_BACKENDS) {
+    for (const alias of entry.aliases) {
+        ALIAS_TO_BACKEND.set(alias, entry.backend);
+    }
+}
+const BACKEND_SET = new Set(BUILT_IN_BACKENDS.map((entry) => entry.backend));
+export function listBuiltInBackends() {
+    return BUILT_IN_BACKENDS.map((entry) => entry.backend);
+}
+export function normalizeBuiltInBackend(backend) {
+    const normalized = String(backend || "").trim().toLowerCase();
+    return ALIAS_TO_BACKEND.get(normalized) || normalized;
+}
+export function isBuiltInBackend(backend) {
+    return BACKEND_SET.has(normalizeBuiltInBackend(backend));
+}
+export function getBuiltInBackendEntry(backend) {
+    const canonical = normalizeBuiltInBackend(backend);
+    return BUILT_IN_BACKENDS.find((entry) => entry.backend === canonical) || null;
+}

package/dist/external-provider-registry.js

@@ -113,12 +113,26 @@ function validateDescriptor(descriptor, sourcePath) {
         throw new Error(`External AI SDK provider "${backend}" from ${sourcePath} is missing provider.createSession().`);
     }
     const aliases = Array.isArray(descriptor.aliases) ? descriptor.aliases.map((item) => normalizeName(item)).filter(Boolean) : [];
+    const optionalFn = (fieldName) => {
+        const value = descriptor[fieldName];
+        if (value === undefined || value === null) {
+            return null;
+        }
+        if (typeof value !== "function") {
+            throw new Error(`External AI SDK provider "${backend}" from ${sourcePath} has provider.${fieldName} `
+                + `but it is not a function (got ${typeof value}).`);
+        }
+        return value;
+    };
     return {
         backend,
         variant,
         aliases,
         createSession: descriptor.createSession,
-        isSupported: typeof descriptor.isSupported === "function" ? descriptor.isSupported : null,
+        isSupported: optionalFn("isSupported"),
+        resolveResumeContext: optionalFn("resolveResumeContext"),
+        buildResumeArgs: optionalFn("buildResumeArgs"),
+        findSessionPath: optionalFn("findSessionPath"),
         sourcePath,
     };
 }

package/dist/index.d.ts

@@ -1 +1,3 @@
+export { BUILT_IN_BACKENDS } from "./built-in-backends.js";
 export { createAiSession, RemoteAiSession } from "./client.js";
+export { resolveResumeContext, buildResumeArgsForBackend, resumeProviderForBackend, findSessionPath, resolveSessionRunDirectory, inspectResumeTarget } from "./resume/index.js";

package/dist/index.js

@@ -1 +1,3 @@
 export { createAiSession, RemoteAiSession } from "./client.js";
+export { BUILT_IN_BACKENDS } from "./built-in-backends.js";
+export { resolveResumeContext, buildResumeArgsForBackend, resumeProviderForBackend, findSessionPath, resolveSessionRunDirectory, inspectResumeTarget, } from "./resume/index.js";

package/dist/providers/claude-agent-sdk-session.js

@@ -1,10 +1,10 @@
 import { EventEmitter } from "node:events";
+import { CLAUDE_AGENT_SDK_VARIANT as CLAUDE_PROVIDER_VARIANT } from "../built-in-backends.js";
 import { emitLog, getBoundedEnvInt, loadEnvConfig, normalizeLogger, proxyToEnv, sanitizeForLog, } from "../shared.js";
 const DEFAULT_TURN_DEADLINE_MS = 12 * 60 * 1000;
 const MIN_TURN_DEADLINE_MS = 30 * 1000;
 const MAX_TURN_DEADLINE_MS = 30 * 60 * 1000;
 const DEFAULT_SETTING_SOURCES = ["user", "project", "local"];
-const CLAUDE_PROVIDER_VARIANT = "claude-agent-sdk";
 function waitForever() {
     return new Promise(() => { });
 }

package/dist/providers/codex-app-server-session.js

@@ -1,4 +1,5 @@
 import { EventEmitter } from "node:events";
+import { CODEX_APP_SERVER_VARIANT } from "../built-in-backends.js";
 import { CodexAppServerTransport } from "../transports/codex-app-server-transport.js";
 import { emitLog, getBoundedEnvInt, loadEnvConfig, normalizeLogger, proxyToEnv, sanitizeForLog, } from "../shared.js";
 const DEFAULT_TURN_DEADLINE_MS = 12 * 60 * 1000;
@@ -248,7 +249,7 @@ export class CodexAppServerSession extends EventEmitter {
     getSnapshot() {
         return {
             backend: this.backend,
-            provider: "codex-app-server",
+            provider: CODEX_APP_SERVER_VARIANT,
             cwd: this.cwd,
             sessionId: this.sessionId || undefined,
             sessionInfo: this.getSessionInfo(),
@@ -324,7 +325,7 @@ export class CodexAppServerSession extends EventEmitter {
     }
     markTurnStartedStatus() {
         this.updateCurrentTurnStatus({
-            source: "codex-app-server",
+            source: CODEX_APP_SERVER_VARIANT,
             reply_in_progress: true,
             replyTo: this.getCurrentReplyTarget(),
             phase: "turn_started",
@@ -444,7 +445,7 @@ export class CodexAppServerSession extends EventEmitter {
     }
     normalizeWorkingStatusPayload(payload) {
         return {
-            source: "codex-app-server",
+            source: CODEX_APP_SERVER_VARIANT,
             reply_in_progress: Boolean(payload?.reply_in_progress),
             replyTo: payload?.replyTo || this.getCurrentReplyTarget(),
             state: payload?.state,
@@ -469,7 +470,7 @@ export class CodexAppServerSession extends EventEmitter {
         const payload = {
             text,
             preserveWhitespace: true,
-            source: "codex-app-server",
+            source: CODEX_APP_SERVER_VARIANT,
             replyTo: this.getCurrentReplyTarget(),
             sessionId: this.sessionId || undefined,
             sessionFilePath: this.threadPath || undefined,
@@ -957,7 +958,7 @@ export class CodexAppServerSession extends EventEmitter {
                 events: [],
                 provider: this.backend,
                 metadata: {
-                    source: "codex-app-server",
+                    source: CODEX_APP_SERVER_VARIANT,
                     threadId: this.sessionId,
                     threadPath: this.threadPath || undefined,
                     nativeSessionId: this.nativeSessionId || undefined,

package/dist/providers/codex-exec-session.js

@@ -5,11 +5,11 @@ import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { EventEmitter } from "node:events";
 import readline from "node:readline";
+import { CODEX_EXEC_VARIANT as CODEX_EXEC_PROVIDER_VARIANT } from "../built-in-backends.js";
 import { emitLog, getBoundedEnvInt, loadEnvConfig, normalizeLogger, parseCommandParts, proxyToEnv, sanitizeForLog, } from "../shared.js";
 const DEFAULT_TURN_DEADLINE_MS = 12 * 60 * 1000;
 const MIN_TURN_DEADLINE_MS = 30 * 1000;
 const MAX_TURN_DEADLINE_MS = 30 * 60 * 1000;
-const CODEX_EXEC_PROVIDER_VARIANT = "codex-exec";
 const DEFAULT_CODEX_EXEC_COMMAND = "codex";
 function createTurnError(message, extras = {}) {
     const error = new Error(message);

package/dist/providers/copilot-sdk-session.d.ts

@@ -1,3 +1,10 @@
+export function resolveBundledCopilotCliPath({ platform, arch, resolvePackage, resolvePackagePaths, existsSyncFn, }?: {
+    platform?: NodeJS.Platform | undefined;
+    arch?: NodeJS.Architecture | undefined;
+    resolvePackage?: ((packageName: any) => string) | undefined;
+    resolvePackagePaths?: ((packageName: any) => string[]) | undefined;
+    existsSyncFn?: typeof existsSync | undefined;
+}): string | null;
 export class CopilotSdkSession extends EventEmitter<[never]> {
     constructor(backend: any, options?: {});
     backend: string;
@@ -190,4 +197,5 @@ export class CopilotSdkSession extends EventEmitter<[never]> {
     }>;
     close(): Promise<void>;
 }
+import { existsSync } from "node:fs";
 import { EventEmitter } from "node:events";

package/dist/providers/copilot-sdk-session.js

@@ -1,14 +1,16 @@
 import { EventEmitter } from "node:events";
 import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
 import path from "node:path";
+import { COPILOT_SDK_VARIANT as COPILOT_PROVIDER_VARIANT } from "../built-in-backends.js";
 import { emitLog, getBoundedEnvInt, loadEnvConfig, normalizeLogger, parseCommandParts, proxyToEnv, sanitizeForLog, withoutCopilotGithubTokenEnv, } from "../shared.js";
 const DEFAULT_TURN_DEADLINE_MS = 12 * 60 * 1000;
 const MIN_TURN_DEADLINE_MS = 30 * 1000;
 const MAX_TURN_DEADLINE_MS = 30 * 60 * 1000;
 const DEFAULT_CLOSE_TIMEOUT_MS = 5 * 1000;
 const SDK_SEND_AND_WAIT_TIMEOUT_GRACE_MS = 5 * 1000;
-const COPILOT_PROVIDER_VARIANT = "copilot-sdk";
 const LEGACY_COPILOT_CLI_ARGS = new Set(["--allow-all-paths", "--allow-all-tools"]);
+const moduleRequire = createRequire(import.meta.url);
 function waitForever() {
     return new Promise(() => { });
 }
@@ -192,6 +194,44 @@ function unwrapEnvironmentCommand(command, args) {
 function hasOwnEnumerableKeys(value) {
     return value && typeof value === "object" && Object.keys(value).length > 0;
 }
+function resolveCopilotPlatformPackageName(platform = process.platform, arch = process.arch) {
+    if (!["darwin", "linux", "win32"].includes(platform)) {
+        return null;
+    }
+    if (!["arm64", "x64"].includes(arch)) {
+        return null;
+    }
+    return `@github/copilot-${platform}-${arch}`;
+}
+function resolvePackageFileFromSearchPaths(packageName, relativePath, resolvePackagePaths, existsSyncFn) {
+    const searchPaths = resolvePackagePaths(packageName) || [];
+    const packageParts = packageName.split("/");
+    for (const basePath of searchPaths) {
+        const candidate = path.join(basePath, ...packageParts, relativePath);
+        if (existsSyncFn(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+export function resolveBundledCopilotCliPath({ platform = process.platform, arch = process.arch, resolvePackage = (packageName) => moduleRequire.resolve(packageName), resolvePackagePaths = (packageName) => moduleRequire.resolve.paths(packageName) || [], existsSyncFn = existsSync, } = {}) {
+    const platformPackageName = resolveCopilotPlatformPackageName(platform, arch);
+    if (platformPackageName) {
+        try {
+            const platformExecutablePath = resolvePackage(platformPackageName);
+            if (platformExecutablePath && existsSyncFn(platformExecutablePath)) {
+                return platformExecutablePath;
+            }
+        }
+        catch {
+            // Optional platform packages may be absent when optional dependencies are disabled.
+        }
+    }
+    return resolvePackageFileFromSearchPaths("@github/copilot", "npm-loader.js", resolvePackagePaths, existsSyncFn);
+}
+function hasExplicitCopilotCliPathEnv(env) {
+    return typeof env?.COPILOT_CLI_PATH === "string" && env.COPILOT_CLI_PATH.trim();
+}
 function resolveCopilotCliLaunch(commandLine, env = process.env) {
     const normalized = typeof commandLine === "string" ? commandLine.trim() : "";
     if (!normalized) {
@@ -395,6 +435,14 @@ function buildCopilotClientOptions(options, cwd, env) {
     clientOptions.env = hasExplicitGithubToken
         ? resolvedEnv
         : withoutCopilotGithubTokenEnv(resolvedEnv);
+    if (clientOptions.cliPath === undefined &&
+        clientOptions.cliUrl === undefined &&
+        !hasExplicitCopilotCliPathEnv(clientOptions.env)) {
+        const bundledCliPath = resolveBundledCopilotCliPath();
+        if (bundledCliPath) {
+            clientOptions.cliPath = bundledCliPath;
+        }
+    }
     if (!hasExplicitGithubToken && clientOptions.useLoggedInUser === undefined) {
         clientOptions.useLoggedInUser = true;
     }

package/dist/providers/kimi-cli-session.js

@@ -1,11 +1,11 @@
 import { randomUUID } from "node:crypto";
 import { EventEmitter } from "node:events";
+import { KIMI_CLI_WIRE_VARIANT as KIMI_PROVIDER_VARIANT } from "../built-in-backends.js";
 import { KimiWireTransport } from "../transports/kimi-wire-transport.js";
 import { emitLog, getBoundedEnvInt, loadEnvConfig, normalizeLogger, proxyToEnv, sanitizeForLog, } from "../shared.js";
 const DEFAULT_TURN_DEADLINE_MS = 12 * 60 * 1000;
 const MIN_TURN_DEADLINE_MS = 30 * 1000;
 const MAX_TURN_DEADLINE_MS = 30 * 60 * 1000;
-const KIMI_PROVIDER_VARIANT = "kimi-cli-wire";
 const DEFAULT_STATUS_DEDUPE_MS = 120;
 const DEFAULT_STATUS_THROTTLE_MS = 450;
 const DEFAULT_REASONING_STATUS_THROTTLE_MS = 2500;

package/dist/providers/kimi-print-session.js

@@ -4,11 +4,11 @@ import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { EventEmitter } from "node:events";
 import readline from "node:readline";
+import { KIMI_CLI_PRINT_VARIANT as KIMI_PRINT_PROVIDER_VARIANT } from "../built-in-backends.js";
 import { emitLog, getBoundedEnvInt, loadEnvConfig, normalizeLogger, parseCommandParts, proxyToEnv, sanitizeForLog, } from "../shared.js";
 const DEFAULT_TURN_DEADLINE_MS = 12 * 60 * 1000;
 const MIN_TURN_DEADLINE_MS = 30 * 1000;
 const MAX_TURN_DEADLINE_MS = 30 * 60 * 1000;
-const KIMI_PRINT_PROVIDER_VARIANT = "kimi-cli-print";
 const DEFAULT_KIMI_COMMAND = "kimi";
 function createTurnError(message, extras = {}) {
     const error = new Error(message);

package/dist/providers/opencode-sdk-session.js

@@ -1,10 +1,10 @@
 import { EventEmitter } from "node:events";
+import { OPENCODE_SDK_VARIANT as OPENCODE_PROVIDER_VARIANT } from "../built-in-backends.js";
 import { OpencodeServerTransport } from "../transports/opencode-server-transport.js";
 import { emitLog, getBoundedEnvInt, loadEnvConfig, normalizeLogger, proxyToEnv, sanitizeForLog, } from "../shared.js";
 const DEFAULT_TURN_DEADLINE_MS = 12 * 60 * 1000;
 const MIN_TURN_DEADLINE_MS = 30 * 1000;
 const MAX_TURN_DEADLINE_MS = 30 * 60 * 1000;
-const OPENCODE_PROVIDER_VARIANT = "opencode-sdk";
 function waitForever() {
     return new Promise(() => { });
 }

package/dist/resume/claude.d.ts

@@ -0,0 +1,14 @@
+export function buildCliArgs(sessionId: any): string[];
+export function findSessionPath(sessionId: any, options?: {}): Promise<any>;
+export function extractResumeCwd(sessionPath: any, sessionId: any): Promise<string | null>;
+export function resolveResumeContext(sessionId: any, options?: {}): Promise<{
+    provider: any;
+    sessionId: any;
+    sessionPath: null;
+    cwd: any;
+    debugMetadata: {
+        cwdSource: any;
+        sessionPath: null;
+    };
+}>;
+export const BACKEND: "claude";

package/dist/resume/claude.js

@@ -0,0 +1,138 @@
+import fs from "node:fs";
+import { promises as fsp } from "node:fs";
+import path from "node:path";
+import readline from "node:readline";
+import { buildResumeContext, isExistingDirectory, normalizeSessionId, pathExists, resolveHomeDir, resolveSessionRunDirectory, } from "./shared.js";
+export const BACKEND = "claude";
+export function buildCliArgs(sessionId) {
+    const normalizedSessionId = normalizeSessionId(sessionId);
+    if (!normalizedSessionId) {
+        return [];
+    }
+    return ["--resume", normalizedSessionId];
+}
+export async function findSessionPath(sessionId, options = {}) {
+    const normalizedSessionId = normalizeSessionId(sessionId);
+    if (!normalizedSessionId) {
+        return null;
+    }
+    const homeDir = resolveHomeDir(options);
+    const projectsDir = options.claudeProjectsDir || path.join(homeDir, ".claude", "projects");
+    const sessionEntries = await findClaudeSessionEntries(projectsDir, normalizedSessionId);
+    if (sessionEntries.length > 0) {
+        return sessionEntries[0]?.source || null;
+    }
+    const tasksDir = options.claudeTasksDir || path.join(homeDir, ".claude", "tasks");
+    const directTaskDir = path.join(tasksDir, normalizedSessionId);
+    if (await pathExists(directTaskDir, "directory")) {
+        return directTaskDir;
+    }
+    return null;
+}
+export async function extractResumeCwd(sessionPath, sessionId) {
+    if (!sessionPath || !sessionPath.endsWith(".jsonl")) {
+        return null;
+    }
+    const rl = readline.createInterface({
+        input: fs.createReadStream(sessionPath),
+        crlfDelay: Infinity,
+    });
+    for await (const line of rl) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            continue;
+        }
+        let entry;
+        try {
+            entry = JSON.parse(trimmed);
+        }
+        catch {
+            continue;
+        }
+        const idMatches = String(entry?.sessionId || "").trim() === sessionId;
+        const maybeCwd = entry?.cwd;
+        if (idMatches && typeof maybeCwd === "string" && maybeCwd.trim()) {
+            return maybeCwd.trim();
+        }
+    }
+    return null;
+}
+export async function resolveResumeContext(sessionId, options = {}) {
+    const normalizedSessionId = normalizeSessionId(sessionId);
+    if (!normalizedSessionId) {
+        throw new Error("--resume requires a session id");
+    }
+    const sessionPath = await findSessionPath(normalizedSessionId, options);
+    if (!sessionPath) {
+        throw new Error(`Invalid --resume session id for claude: ${normalizedSessionId}`);
+    }
+    const cwdFromSession = await extractResumeCwd(sessionPath, normalizedSessionId);
+    const fallbackCwd = await resolveSessionRunDirectory(sessionPath);
+    const cwd = cwdFromSession || fallbackCwd;
+    if (!cwd) {
+        throw new Error(`Could not resolve workspace for claude session ${normalizedSessionId}`);
+    }
+    if (!(await isExistingDirectory(cwd))) {
+        throw new Error(`Resume workspace path does not exist: ${cwd}`);
+    }
+    return buildResumeContext({
+        provider: "claude",
+        sessionId: normalizedSessionId,
+        sessionPath,
+        cwd,
+        cwdSource: cwdFromSession ? "session" : "session_path",
+    });
+}
+async function findClaudeSessionEntries(projectsDir, sessionId) {
+    const entries = [];
+    let projectDirs = [];
+    try {
+        projectDirs = await fsp.readdir(projectsDir, { withFileTypes: true });
+    }
+    catch {
+        return entries;
+    }
+    for (const projectDir of projectDirs) {
+        if (!projectDir.isDirectory()) {
+            continue;
+        }
+        const projectPath = path.join(projectsDir, projectDir.name);
+        let files = [];
+        try {
+            files = await fsp.readdir(projectPath, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const file of files) {
+            if (!file.isFile()) {
+                continue;
+            }
+            if (!file.name.endsWith(".jsonl") || file.name.startsWith("agent-")) {
+                continue;
+            }
+            const filePath = path.join(projectPath, file.name);
+            const rl = readline.createInterface({
+                input: fs.createReadStream(filePath),
+                crlfDelay: Infinity,
+            });
+            for await (const line of rl) {
+                const trimmed = line.trim();
+                if (!trimmed) {
+                    continue;
+                }
+                let entry;
+                try {
+                    entry = JSON.parse(trimmed);
+                }
+                catch {
+                    continue;
+                }
+                if (entry.sessionId === sessionId) {
+                    entries.push({ ...entry, source: filePath });
+                }
+            }
+        }
+    }
+    return entries;
+}

package/dist/resume/codex.d.ts

@@ -0,0 +1,14 @@
+export function buildCliArgs(sessionId: any): string[];
+export function findSessionPath(sessionId: any, options?: {}): Promise<string | null>;
+export function extractResumeCwd(sessionPath: any): Promise<string | null>;
+export function resolveResumeContext(sessionId: any, options?: {}): Promise<{
+    provider: any;
+    sessionId: any;
+    sessionPath: null;
+    cwd: any;
+    debugMetadata: {
+        cwdSource: any;
+        sessionPath: null;
+    };
+}>;
+export const BACKEND: "codex";

package/dist/resume/codex.js

@@ -0,0 +1,81 @@
+import { promises as fsp } from "node:fs";
+import path from "node:path";
+import { buildResumeContext, isExistingDirectory, iterateJsonlEntries, normalizeSessionId, resolveHomeDir, resolveSessionRunDirectory, } from "./shared.js";
+export const BACKEND = "codex";
+export function buildCliArgs(sessionId) {
+    const normalizedSessionId = normalizeSessionId(sessionId);
+    if (!normalizedSessionId) {
+        return [];
+    }
+    return ["resume", normalizedSessionId];
+}
+export async function findSessionPath(sessionId, options = {}) {
+    const normalizedSessionId = normalizeSessionId(sessionId);
+    if (!normalizedSessionId) {
+        return null;
+    }
+    const homeDir = resolveHomeDir(options);
+    const sessionsDir = options.codexSessionsDir || path.join(homeDir, ".codex", "sessions");
+    return findCodexSessionFile(sessionsDir, normalizedSessionId);
+}
+export async function extractResumeCwd(sessionPath) {
+    if (!sessionPath || !sessionPath.endsWith(".jsonl")) {
+        return null;
+    }
+    for await (const entry of iterateJsonlEntries(sessionPath)) {
+        const maybeCwd = entry?.type === "session_meta" ? entry?.payload?.cwd : null;
+        if (typeof maybeCwd === "string" && maybeCwd.trim()) {
+            return maybeCwd.trim();
+        }
+    }
+    return null;
+}
+export async function resolveResumeContext(sessionId, options = {}) {
+    const normalizedSessionId = normalizeSessionId(sessionId);
+    if (!normalizedSessionId) {
+        throw new Error("--resume requires a session id");
+    }
+    const sessionPath = await findSessionPath(normalizedSessionId, options);
+    if (!sessionPath) {
+        throw new Error(`Invalid --resume session id for codex: ${normalizedSessionId}`);
+    }
+    const cwdFromSession = await extractResumeCwd(sessionPath);
+    const fallbackCwd = await resolveSessionRunDirectory(sessionPath);
+    const cwd = cwdFromSession || fallbackCwd;
+    if (!cwd) {
+        throw new Error(`Could not resolve workspace for codex session ${normalizedSessionId}`);
+    }
+    if (!(await isExistingDirectory(cwd))) {
+        throw new Error(`Resume workspace path does not exist: ${cwd}`);
+    }
+    return buildResumeContext({
+        provider: "codex",
+        sessionId: normalizedSessionId,
+        sessionPath,
+        cwd,
+        cwdSource: cwdFromSession ? "session" : "session_path",
+    });
+}
+async function findCodexSessionFile(rootDir, sessionId) {
+    const queue = [rootDir];
+    while (queue.length) {
+        const current = queue.pop();
+        let entries = [];
+        try {
+            entries = await fsp.readdir(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const fullPath = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                queue.push(fullPath);
+            }
+            else if (entry.isFile() && entry.name.includes(sessionId) && entry.name.endsWith(".jsonl")) {
+                return fullPath;
+            }
+        }
+    }
+    return null;
+}