@love-moon/ai-sdk 0.2.41 → 0.3.1

package/dist/resume/copilot.js

@@ -0,0 +1,375 @@
+import fs from "node:fs";
+import path from "node:path";
+import { loadAllowCliList, loadEnvConfig, parseCommandParts, proxyToEnv, withoutCopilotGithubTokenEnv, } from "../shared.js";
+import { buildResumeContext, isExistingDirectory, normalizeProjectPathCandidate, normalizeSessionId, } from "./shared.js";
+export const BACKEND = "copilot";
+const LEGACY_COPILOT_CLI_ARGS = new Set(["--allow-all-paths", "--allow-all-tools"]);
+const DEFAULT_COPILOT_RESUME_TIMEOUT_MS = 20_000;
+const DEFAULT_COPILOT_RESUME_STOP_TIMEOUT_MS = 5_000;
+const COPILOT_GITHUB_TOKEN_ENV_KEYS = ["COPILOT_GITHUB_TOKEN", "GH_TOKEN", "GITHUB_TOKEN"];
+export function buildCliArgs(sessionId) {
+    const normalizedSessionId = normalizeSessionId(sessionId);
+    if (!normalizedSessionId) {
+        return [];
+    }
+    return [`--resume=${normalizedSessionId}`];
+}
+export async function findSessionPath() {
+    // Copilot sessions are managed through the GitHub Copilot SDK; they do not
+    // have a local session file path that we can enumerate directly.
+    return null;
+}
+export async function resolveResumeContext(sessionId, options = {}) {
+    const normalizedSessionId = normalizeSessionId(sessionId);
+    if (!normalizedSessionId) {
+        throw new Error("--resume requires a session id");
+    }
+    const sessionMetadata = await withCopilotClient(options, async (client) => {
+        const sessions = await client.listSessions();
+        return sessions.find((entry) => normalizeSessionId(entry?.sessionId) === normalizedSessionId) || null;
+    });
+    if (!sessionMetadata) {
+        throw new Error(`Invalid --resume session id for copilot: ${normalizedSessionId}`);
+    }
+    const cwd = normalizeProjectPathCandidate(sessionMetadata?.context?.cwd);
+    if (!cwd) {
+        throw new Error(`Could not resolve workspace for copilot session ${normalizedSessionId}`);
+    }
+    if (!(await isExistingDirectory(cwd))) {
+        throw new Error(`Resume workspace path does not exist: ${cwd}`);
+    }
+    return buildResumeContext({
+        provider: "copilot",
+        sessionId: normalizedSessionId,
+        sessionPath: null,
+        cwd,
+        cwdSource: "sdk_list_sessions",
+        extraDebug: {
+            context: sessionMetadata?.context && typeof sessionMetadata.context === "object"
+                ? { ...sessionMetadata.context }
+                : undefined,
+        },
+    });
+}
+async function getCopilotSdkModule(options = {}) {
+    if (options.copilotSdkModule && typeof options.copilotSdkModule === "object") {
+        return options.copilotSdkModule;
+    }
+    return import("@github/copilot-sdk");
+}
+async function withCopilotClient(options, fn) {
+    const sdkModule = await getCopilotSdkModule(options);
+    if (!sdkModule || typeof sdkModule.CopilotClient !== "function") {
+        throw new Error("GitHub Copilot SDK client is unavailable");
+    }
+    const timeoutMs = resolvePositiveTimeoutMs(options.copilotResumeTimeoutMs ?? options.timeoutMs, DEFAULT_COPILOT_RESUME_TIMEOUT_MS);
+    const startedAtMs = Date.now();
+    const client = new sdkModule.CopilotClient(await buildCopilotClientOptions(options));
+    try {
+        if (typeof client.start === "function") {
+            const startTimeoutMs = remainingTimeoutMs(startedAtMs, timeoutMs, "copilot resume lookup timed out");
+            await withTimeout(client.start(), startTimeoutMs, "copilot resume SDK start timed out");
+        }
+        const lookupTimeoutMs = remainingTimeoutMs(startedAtMs, timeoutMs, "copilot resume lookup timed out");
+        return await withTimeout(fn(client), lookupTimeoutMs, "copilot resume lookup timed out");
+    }
+    finally {
+        try {
+            if (typeof client.stop === "function") {
+                const stopTimeoutMs = resolvePositiveTimeoutMs(options.copilotResumeStopTimeoutMs, DEFAULT_COPILOT_RESUME_STOP_TIMEOUT_MS);
+                await withTimeout(client.stop(), stopTimeoutMs, "copilot resume SDK stop timed out");
+            }
+        }
+        catch {
+            try {
+                await client.forceStop?.();
+            }
+            catch {
+                // best effort
+            }
+        }
+    }
+}
+async function buildCopilotClientOptions(options = {}) {
+    const clientOptions = options.copilotClientOptions && typeof options.copilotClientOptions === "object"
+        ? { ...options.copilotClientOptions }
+        : {};
+    const configFilePath = options.configFilePath || options.configFile;
+    const allowCliList = options.allowCliList && typeof options.allowCliList === "object"
+        ? options.allowCliList
+        : loadAllowCliList(configFilePath);
+    const configEnv = buildConfiguredEnvMap(configFilePath);
+    const commandLine = resolveCopilotCommandLine({ ...options, allowCliList });
+    const cliLaunch = resolveCopilotCliLaunch(commandLine, {
+        ...process.env,
+        ...configEnv,
+        ...options.env,
+    });
+    if (cliLaunch &&
+        clientOptions.cliPath === undefined &&
+        clientOptions.cliArgs === undefined &&
+        clientOptions.cliUrl === undefined) {
+        if (cliLaunch.cliPath !== undefined) {
+            clientOptions.cliPath = cliLaunch.cliPath;
+        }
+        if (cliLaunch.cliArgs !== undefined) {
+            clientOptions.cliArgs = cliLaunch.cliArgs;
+        }
+    }
+    const explicitGithubToken = typeof clientOptions.githubToken === "string" && clientOptions.githubToken.trim()
+        ? clientOptions.githubToken.trim()
+        : typeof options.githubToken === "string" && options.githubToken.trim()
+            ? options.githubToken.trim()
+            : "";
+    if (clientOptions.githubToken === undefined && explicitGithubToken) {
+        clientOptions.githubToken = explicitGithubToken;
+    }
+    if (clientOptions.useLoggedInUser === undefined && typeof options.useLoggedInUser === "boolean") {
+        clientOptions.useLoggedInUser = options.useLoggedInUser;
+    }
+    let resolvedEnv;
+    if (clientOptions.env === undefined) {
+        resolvedEnv = {
+            ...process.env,
+            ...configEnv,
+            ...(options.env && typeof options.env === "object" ? options.env : {}),
+            ...(hasOwnEnumerableKeys(cliLaunch?.env) ? cliLaunch.env : {}),
+        };
+    }
+    else if (hasOwnEnumerableKeys(cliLaunch?.env)) {
+        resolvedEnv = { ...clientOptions.env, ...cliLaunch.env };
+    }
+    else {
+        resolvedEnv = { ...clientOptions.env };
+    }
+    clientOptions.env = explicitGithubToken
+        ? resolvedEnv
+        : withoutCopilotGithubTokenEnv(resolvedEnv);
+    if (!explicitGithubToken && clientOptions.useLoggedInUser === undefined) {
+        clientOptions.useLoggedInUser = true;
+    }
+    if (clientOptions.cwd === undefined) {
+        const cwd = typeof options.cwd === "string" && options.cwd.trim()
+            ? options.cwd.trim()
+            : process.cwd();
+        clientOptions.cwd = cwd;
+    }
+    return clientOptions;
+}
+function resolveCopilotCommandLine(options = {}) {
+    if (typeof options.commandLine === "string" && options.commandLine.trim()) {
+        return options.commandLine.trim();
+    }
+    const allowCliList = options.allowCliList && typeof options.allowCliList === "object" ? options.allowCliList : {};
+    const backendCandidates = [];
+    const pushCandidate = (backend) => {
+        const normalized = typeof backend === "string" ? backend.trim().toLowerCase() : "";
+        if (normalized && !backendCandidates.includes(normalized)) {
+            backendCandidates.push(normalized);
+        }
+    };
+    pushCandidate(options.backend);
+    pushCandidate(options.runtimeBackend);
+    pushCandidate("copilot");
+    for (const candidate of backendCandidates) {
+        const entry = allowCliList[candidate];
+        if (typeof entry === "string" && entry.trim()) {
+            return entry.trim();
+        }
+    }
+    return "";
+}
+function resolveCopilotCliLaunch(commandLine, env = process.env) {
+    const normalized = typeof commandLine === "string" ? commandLine.trim() : "";
+    if (!normalized) {
+        return null;
+    }
+    const parsed = parseCommandParts(normalized);
+    const unwrapped = unwrapEnvironmentCommand(parsed.command, parsed.args);
+    const command = unwrapped.command;
+    const args = unwrapped.args;
+    if (!command) {
+        return null;
+    }
+    const cliArgs = normalizeCopilotCliArgs(args);
+    if (isDefaultCopilotCommand(command)) {
+        if (cliArgs.length === 0 && !hasOwnEnumerableKeys(unwrapped.env)) {
+            return null;
+        }
+        return { cliArgs, env: unwrapped.env };
+    }
+    const launchEnv = { ...process.env, ...env, ...unwrapped.env };
+    const resolvedPath = resolveExecutablePath(command, launchEnv);
+    return {
+        cliPath: resolvedPath || command,
+        cliArgs,
+        env: unwrapped.env,
+    };
+}
+function normalizeCopilotCliArgs(args) {
+    if (!Array.isArray(args)) {
+        return [];
+    }
+    return args.filter((item) => {
+        const normalized = typeof item === "string" ? item.trim().toLowerCase() : "";
+        return normalized && !LEGACY_COPILOT_CLI_ARGS.has(normalized);
+    });
+}
+function stripExecutableSuffix(name) {
+    return String(name || "")
+        .trim()
+        .toLowerCase()
+        .replace(/\.(cmd|bat|exe)$/i, "");
+}
+function isDefaultCopilotCommand(command) {
+    const normalized = String(command || "").trim();
+    if (!normalized || /[\\/]/.test(normalized)) {
+        return false;
+    }
+    return stripExecutableSuffix(normalized) === "copilot";
+}
+function isEnvironmentAssignment(token) {
+    return /^[A-Za-z_][A-Za-z0-9_]*=/.test(String(token || "").trim());
+}
+function parseEnvironmentAssignment(token) {
+    const normalized = String(token || "");
+    const index = normalized.indexOf("=");
+    if (index <= 0) {
+        return null;
+    }
+    return {
+        key: normalized.slice(0, index),
+        value: normalized.slice(index + 1),
+    };
+}
+function isEnvCommand(command) {
+    return stripExecutableSuffix(path.basename(String(command || ""))) === "env";
+}
+function isPathLikeCommand(command) {
+    const normalized = String(command || "").trim();
+    return (normalized.startsWith(".") ||
+        normalized.startsWith("/") ||
+        normalized.includes("/") ||
+        normalized.includes("\\") ||
+        /^[A-Za-z]:[\\/]/.test(normalized));
+}
+function resolveExecutablePath(command, env = process.env) {
+    const normalized = String(command || "").trim();
+    if (!normalized) {
+        return "";
+    }
+    if (isPathLikeCommand(normalized)) {
+        return normalized;
+    }
+    const pathEnv = typeof env?.PATH === "string" ? env.PATH : process.env.PATH || "";
+    const pathExt = process.platform === "win32" && !path.extname(normalized)
+        ? String(env?.PATHEXT || process.env.PATHEXT || ".COM;.EXE;.BAT;.CMD")
+            .split(";")
+            .filter(Boolean)
+        : [""];
+    for (const dir of pathEnv.split(path.delimiter)) {
+        if (!dir) {
+            continue;
+        }
+        for (const ext of pathExt) {
+            const candidate = path.join(dir, `${normalized}${ext}`);
+            if (fs.existsSync(candidate)) {
+                return candidate;
+            }
+        }
+    }
+    return "";
+}
+function unwrapEnvironmentCommand(command, args) {
+    const parts = [command, ...args].filter((item) => typeof item === "string" && item.length > 0);
+    const extraEnv = {};
+    let index = 0;
+    while (index < parts.length && isEnvironmentAssignment(parts[index])) {
+        const assignment = parseEnvironmentAssignment(parts[index]);
+        if (assignment) {
+            extraEnv[assignment.key] = assignment.value;
+        }
+        index += 1;
+    }
+    if (index > 0) {
+        return {
+            command: parts[index] || "",
+            args: parts.slice(index + 1),
+            env: extraEnv,
+        };
+    }
+    if (!isEnvCommand(command)) {
+        return { command, args, env: extraEnv };
+    }
+    index = 0;
+    while (index < args.length) {
+        const token = args[index];
+        if (token === "--") {
+            index += 1;
+            break;
+        }
+        if (isEnvironmentAssignment(token)) {
+            const assignment = parseEnvironmentAssignment(token);
+            if (assignment) {
+                extraEnv[assignment.key] = assignment.value;
+            }
+            index += 1;
+            continue;
+        }
+        if (String(token || "").startsWith("-")) {
+            return { command, args, env: extraEnv };
+        }
+        break;
+    }
+    return {
+        command: args[index] || "",
+        args: args.slice(index + 1),
+        env: extraEnv,
+    };
+}
+function hasOwnEnumerableKeys(value) {
+    return value && typeof value === "object" && Object.keys(value).length > 0;
+}
+function resolvePositiveTimeoutMs(value, fallback) {
+    const n = Number(value);
+    return Number.isFinite(n) && n > 0 ? Math.round(n) : fallback;
+}
+function remainingTimeoutMs(startedAtMs, timeoutMs, message) {
+    const remaining = timeoutMs - (Date.now() - startedAtMs);
+    if (remaining <= 0) {
+        throw new Error(message);
+    }
+    return remaining;
+}
+async function withTimeout(promise, timeoutMs, message) {
+    let timer = null;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new Error(message)), timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timer) {
+            clearTimeout(timer);
+        }
+    }
+}
+function buildConfiguredEnvMap(configFilePath) {
+    const envConfig = loadEnvConfig(configFilePath);
+    if (!envConfig) {
+        return {};
+    }
+    const normalizedEnv = { ...proxyToEnv(envConfig) };
+    for (const [key, value] of Object.entries(envConfig)) {
+        const normalized = typeof value === "string" && value.trim() ? value.trim() : undefined;
+        if (normalized !== undefined) {
+            normalizedEnv[key] = normalized;
+        }
+    }
+    return normalizedEnv;
+}
+// Suppress unused-import lint for COPILOT_GITHUB_TOKEN_ENV_KEYS — retained for reference.
+export const _COPILOT_GITHUB_TOKEN_ENV_KEYS = COPILOT_GITHUB_TOKEN_ENV_KEYS;

package/dist/resume/index.d.ts

@@ -0,0 +1,26 @@
+export function resumeProviderForBackend(backend: any): "codex" | null;
+export function buildResumeArgsForBackend(backend: any, sessionId: any): string[];
+export function findSessionPath(provider: any, sessionId: any, options?: {}): Promise<string | null>;
+export function resolveResumeContext(backend: any, sessionId: any, options?: {}): Promise<{
+    provider: any;
+    sessionId: any;
+    sessionPath: null;
+    cwd: any;
+    debugMetadata: {
+        cwdSource: any;
+        sessionPath: null;
+    };
+}>;
+export function inspectResumeTarget(backend: any, sessionId: any, options?: {}): Promise<{
+    provider: any;
+    sessionId: any;
+    sessionPath: null;
+    cwd: any;
+    debugMetadata: {
+        cwdSource: any;
+        sessionPath: null;
+    };
+}>;
+import { resolveSessionRunDirectory } from "./shared.js";
+import { BUILT_IN_BACKENDS } from "../built-in-backends.js";
+export { resolveSessionRunDirectory, BUILT_IN_BACKENDS };

package/dist/resume/index.js

@@ -0,0 +1,132 @@
+import { BUILT_IN_BACKENDS, getBuiltInBackendEntry, normalizeBuiltInBackend, } from "../built-in-backends.js";
+import { getExternalProviderDescriptor, resolveExternalBackend, } from "../external-provider-registry.js";
+import * as claude from "./claude.js";
+import * as codex from "./codex.js";
+import * as copilot from "./copilot.js";
+import * as kimi from "./kimi.js";
+import * as opencode from "./opencode.js";
+import { buildResumeContext, isExistingDirectory, normalizeBackend, normalizeProjectPathCandidate, normalizeSessionId, resolveSessionRunDirectory, } from "./shared.js";
+/**
+ * Map of canonical built-in backend name → resume module.
+ *
+ * **Every built-in backend MUST be registered here.** Resume is a required
+ * capability for every provider in ai-sdk; the invariant is enforced by the
+ * module-load self-check below.
+ *
+ * Adding a new built-in backend:
+ *   1. Add an entry to {@link BUILT_IN_BACKENDS} in `../built-in-backends.js`.
+ *   2. Create `./<backend>.js` exporting
+ *      `{ BACKEND, buildCliArgs, findSessionPath, resolveResumeContext }`.
+ *   3. Register the new module in this map.
+ */
+const RESUME_MODULES_BY_BACKEND = new Map([
+    ["codex", codex],
+    ["claude", claude],
+    ["copilot", copilot],
+    ["kimi", kimi],
+    ["opencode", opencode],
+]);
+// Sanity-check at module load:
+// (1) Every registered resume module must point at a real built-in backend.
+//     Catches typos like registering "kimii" by mistake.
+// (2) Every built-in backend must have a registered resume module.
+//     Enforces the "all providers support resume" invariant — a new backend
+//     cannot be added to BUILT_IN_BACKENDS without its resume module.
+for (const backend of RESUME_MODULES_BY_BACKEND.keys()) {
+    if (!getBuiltInBackendEntry(backend)) {
+        throw new Error(`ai-sdk resume dispatcher references unknown built-in backend "${backend}". `
+            + `Did you forget to add it to BUILT_IN_BACKENDS in src/built-in-backends.js?`);
+    }
+}
+for (const entry of BUILT_IN_BACKENDS) {
+    if (!RESUME_MODULES_BY_BACKEND.has(entry.backend)) {
+        throw new Error(`ai-sdk built-in backend "${entry.backend}" has no resume module registered. `
+            + `Resume is required for every built-in backend. Add src/resume/${entry.backend}.js and `
+            + `register it in RESUME_MODULES_BY_BACKEND in src/resume/index.js.`);
+    }
+}
+function lookupBuiltInProvider(backend) {
+    const canonical = normalizeBuiltInBackend(normalizeBackend(backend));
+    return RESUME_MODULES_BY_BACKEND.get(canonical) || null;
+}
+export function resumeProviderForBackend(backend) {
+    const provider = lookupBuiltInProvider(backend);
+    return provider ? provider.BACKEND : null;
+}
+export function buildResumeArgsForBackend(backend, sessionId) {
+    const normalizedSessionId = normalizeSessionId(sessionId);
+    if (!normalizedSessionId) {
+        return [];
+    }
+    const provider = lookupBuiltInProvider(backend);
+    if (!provider) {
+        throw new Error(`--resume is not supported for backend "${backend}"`);
+    }
+    return provider.buildCliArgs(normalizedSessionId);
+}
+export async function findSessionPath(provider, sessionId, options = {}) {
+    const descriptor = lookupBuiltInProvider(provider);
+    if (!descriptor) {
+        throw new Error(`Unsupported provider: ${provider}`);
+    }
+    return descriptor.findSessionPath(sessionId, options);
+}
+export { resolveSessionRunDirectory };
+export async function resolveResumeContext(backend, sessionId, options = {}) {
+    const normalizedSessionId = normalizeSessionId(sessionId);
+    if (!normalizedSessionId) {
+        throw new Error("--resume requires a session id");
+    }
+    const builtInProvider = lookupBuiltInProvider(backend);
+    if (builtInProvider) {
+        return builtInProvider.resolveResumeContext(normalizedSessionId, options);
+    }
+    const externalContext = await resolveExternalResumeContext(backend, normalizedSessionId, options);
+    if (externalContext) {
+        return externalContext;
+    }
+    throw new Error(`--resume is not supported for backend "${backend}"`);
+}
+async function resolveExternalResumeContext(backend, sessionId, options = {}) {
+    const normalizedBackend = await resolveExternalBackend(normalizeBackend(backend), options);
+    if (!normalizedBackend) {
+        return null;
+    }
+    const descriptor = await getExternalProviderDescriptor(normalizedBackend, options);
+    if (!descriptor) {
+        return null;
+    }
+    if (typeof descriptor.resolveResumeContext !== "function") {
+        return null;
+    }
+    const resolvedContext = await descriptor.resolveResumeContext(sessionId, options);
+    if (!resolvedContext) {
+        return null;
+    }
+    const cwd = normalizeProjectPathCandidate(resolvedContext?.cwd);
+    if (!cwd) {
+        throw new Error(`Could not resolve workspace for backend "${normalizedBackend}" session ${sessionId}`);
+    }
+    if (!(await isExistingDirectory(cwd))) {
+        throw new Error(`Resume workspace path does not exist: ${cwd}`);
+    }
+    const sessionPath = normalizeProjectPathCandidate(resolvedContext?.sessionPath);
+    const cwdSource = typeof resolvedContext?.debugMetadata?.cwdSource === "string"
+        && resolvedContext.debugMetadata.cwdSource.trim()
+        ? resolvedContext.debugMetadata.cwdSource.trim()
+        : "provider";
+    return buildResumeContext({
+        provider: normalizedBackend,
+        sessionId,
+        sessionPath,
+        cwd,
+        cwdSource,
+        extraDebug: resolvedContext?.debugMetadata && typeof resolvedContext.debugMetadata === "object"
+            ? resolvedContext.debugMetadata
+            : {},
+    });
+}
+export async function inspectResumeTarget(backend, sessionId, options = {}) {
+    return resolveResumeContext(backend, sessionId, options);
+}
+export { BUILT_IN_BACKENDS };

package/dist/resume/kimi.d.ts

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

package/dist/resume/kimi.js

@@ -0,0 +1,89 @@
+import crypto from "node:crypto";
+import { promises as fsp } from "node:fs";
+import path from "node:path";
+import { buildResumeContext, isExistingDirectory, listCandidateWorkingDirectories, normalizeSessionId, pathExists, resolveHomeDir, } from "./shared.js";
+export const BACKEND = "kimi";
+export function buildCliArgs(sessionId) {
+    const normalizedSessionId = normalizeSessionId(sessionId);
+    if (!normalizedSessionId) {
+        return [];
+    }
+    return ["--session", normalizedSessionId];
+}
+export async function findSessionPath(sessionId, options = {}) {
+    const normalizedSessionId = normalizeSessionId(sessionId);
+    if (!normalizedSessionId) {
+        return null;
+    }
+    const homeDir = resolveHomeDir(options);
+    const sessionsDir = options.kimiSessionsDir || path.join(homeDir, ".kimi", "sessions");
+    return findKimiSessionDirectory(sessionsDir, normalizedSessionId);
+}
+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 kimi: ${normalizedSessionId}`);
+    }
+    const cwdFromSession = await resolveKimiResumeCwd(sessionPath, normalizedSessionId, options);
+    if (!cwdFromSession) {
+        throw new Error(`Could not resolve workspace for Kimi session ${normalizedSessionId}. Re-run from the original workspace or resume a session previously started by conductor fire.`);
+    }
+    if (!(await isExistingDirectory(cwdFromSession))) {
+        throw new Error(`Resume workspace path does not exist: ${cwdFromSession}`);
+    }
+    return buildResumeContext({
+        provider: "kimi",
+        sessionId: normalizedSessionId,
+        sessionPath,
+        cwd: cwdFromSession,
+        cwdSource: "session",
+    });
+}
+export function md5Hex(value) {
+    return crypto.createHash("md5").update(String(value ?? "")).digest("hex");
+}
+async function resolveKimiResumeCwd(sessionPath, _sessionId, options = {}) {
+    const sessionDirectory = typeof sessionPath === "string" ? sessionPath.trim() : "";
+    if (!sessionDirectory) {
+        return null;
+    }
+    const worktreeHash = path.basename(path.dirname(sessionDirectory));
+    if (!worktreeHash) {
+        return null;
+    }
+    for (const candidate of listCandidateWorkingDirectories(options)) {
+        if (md5Hex(candidate) === worktreeHash) {
+            return candidate;
+        }
+    }
+    if (typeof options.lookupWorkspaceByHash === "function") {
+        const resolved = await options.lookupWorkspaceByHash(worktreeHash, { sessionId: _sessionId });
+        if (typeof resolved === "string" && resolved.trim()) {
+            return resolved.trim();
+        }
+    }
+    return null;
+}
+async function findKimiSessionDirectory(rootDir, sessionId) {
+    let hashDirs = [];
+    try {
+        hashDirs = await fsp.readdir(rootDir, { withFileTypes: true });
+    }
+    catch {
+        return null;
+    }
+    for (const hashDir of hashDirs) {
+        if (!hashDir.isDirectory()) {
+            continue;
+        }
+        const candidateDir = path.join(rootDir, hashDir.name, sessionId);
+        if (await pathExists(candidateDir, "directory")) {
+            return candidateDir;
+        }
+    }
+    return null;
+}

package/dist/resume/opencode.d.ts

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