@axhub/acp 0.1.0

package/dist/lib/acp2aisdk/provider-registry.mjs

@@ -0,0 +1,196 @@
+export const ACP_PROVIDER_KEYS = [
+    "claude",
+    "codex",
+    "gemini",
+    "opencode",
+];
+export const ACP_PROVIDER_DEFAULT_MODE_IDS = {
+    claude: "bypassPermissions",
+    codex: "full-access",
+    gemini: "bypassPermissions",
+    opencode: "build",
+};
+export const ACP_PROVIDER_ALIASES = {
+    openai: "codex",
+};
+export const ACP_PROVIDER_REGISTRY = {
+    claude: {
+        provider: "claude",
+        label: "Claude",
+        command: "npx",
+        args: ["-y", "@agentclientprotocol/claude-agent-acp@^0.39.0"],
+        defaultModel: "sonnet",
+        defaultModeId: ACP_PROVIDER_DEFAULT_MODE_IDS.claude,
+        supportsImages: true,
+        enabledInP0: false,
+    },
+    codex: {
+        provider: "codex",
+        label: "Codex",
+        command: "./node_modules/.bin/codex-acp",
+        defaultModeId: ACP_PROVIDER_DEFAULT_MODE_IDS.codex,
+        supportsImages: true,
+        enabledInP0: true,
+    },
+    gemini: {
+        provider: "gemini",
+        label: "Gemini",
+        command: "npx",
+        args: ["-y", "@google/gemini-cli@^0.44.1", "--acp", "--skip-trust"],
+        defaultModel: "gemini-3-pro-preview",
+        defaultModeId: ACP_PROVIDER_DEFAULT_MODE_IDS.gemini,
+        supportsImages: false,
+        enabledInP0: false,
+    },
+    opencode: {
+        provider: "opencode",
+        label: "OpenCode",
+        command: "npx",
+        args: ["-y", "opencode-ai@^1.15.13", "acp"],
+        defaultModel: "opencode/big-pickle",
+        defaultModeId: ACP_PROVIDER_DEFAULT_MODE_IDS.opencode,
+        supportsImages: false,
+        enabledInP0: false,
+    },
+};
+export function isAcpProviderKey(value) {
+    return ACP_PROVIDER_KEYS.includes(value);
+}
+export function normalizeAcpProvider(value) {
+    var _a;
+    const normalized = String(value || "codex")
+        .trim()
+        .toLowerCase();
+    const aliased = (_a = ACP_PROVIDER_ALIASES[normalized]) !== null && _a !== void 0 ? _a : normalized;
+    return isAcpProviderKey(aliased) ? aliased : "codex";
+}
+export function getAcpProviderDefaultModeId(value) {
+    var _a;
+    const provider = normalizeAcpProvider(value);
+    return (_a = ACP_PROVIDER_REGISTRY[provider].defaultModeId) !== null && _a !== void 0 ? _a : null;
+}
+function normalizeBoolean(value) {
+    if (value === undefined)
+        return undefined;
+    const normalized = value.trim().toLowerCase();
+    if (["1", "true", "yes", "on"].includes(normalized))
+        return true;
+    if (["0", "false", "no", "off"].includes(normalized))
+        return false;
+    return undefined;
+}
+function normalizeNumber(value) {
+    if (value === undefined)
+        return undefined;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : undefined;
+}
+function parseCommandLine(value) {
+    var _a;
+    const parts = (_a = value.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g)) !== null && _a !== void 0 ? _a : [];
+    const [command, ...args] = parts.map((part) => part.replace(/^["']|["']$/g, ""));
+    return {
+        command: command || value,
+        args,
+    };
+}
+function parseProviderOverrideObject(value) {
+    if (typeof value === "string") {
+        const commandLine = value.trim();
+        return commandLine ? parseCommandLine(commandLine) : null;
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const record = value;
+    const command = typeof record.command === "string" && record.command.trim()
+        ? record.command.trim()
+        : null;
+    const args = Array.isArray(record.args)
+        ? record.args
+            .map((item) => String(item).trim())
+            .filter((item) => Boolean(item))
+        : undefined;
+    const sessionDelayMs = typeof record.sessionDelayMs === "number" &&
+        Number.isFinite(record.sessionDelayMs) &&
+        record.sessionDelayMs >= 0
+        ? record.sessionDelayMs
+        : undefined;
+    const override = {};
+    if (command)
+        override.command = command;
+    if (args)
+        override.args = args;
+    if (typeof record.authMethodId === "string") {
+        override.authMethodId = record.authMethodId.trim() || null;
+    }
+    if (sessionDelayMs !== undefined)
+        override.sessionDelayMs = sessionDelayMs;
+    if (typeof record.persistSession === "boolean") {
+        override.persistSession = record.persistSession;
+    }
+    if (typeof record.defaultModel === "string") {
+        override.defaultModel = record.defaultModel.trim() || null;
+    }
+    if (typeof record.defaultModeId === "string") {
+        override.defaultModeId = record.defaultModeId.trim() || null;
+    }
+    return Object.keys(override).length ? override : null;
+}
+function mergeOverride(overrides, provider, override) {
+    if (!override)
+        return;
+    overrides[provider] = Object.assign(Object.assign({}, overrides[provider]), override);
+}
+export function readProviderOverridesFromEnv(env = process.env) {
+    const overrides = {};
+    const rawJson = env.ACP_PROVIDER_COMMAND_OVERRIDES || env.AXHUB_ACP_COMMAND_OVERRIDES;
+    if (rawJson) {
+        try {
+            const parsed = JSON.parse(rawJson);
+            for (const [providerName, value] of Object.entries(parsed)) {
+                const provider = normalizeAcpProvider(providerName);
+                mergeOverride(overrides, provider, parseProviderOverrideObject(value));
+            }
+        }
+        catch (_a) {
+            // Ignore malformed overrides; explicit per-provider envs still apply.
+        }
+    }
+    for (const provider of ACP_PROVIDER_KEYS) {
+        const prefix = `ACP_${provider.toUpperCase()}`;
+        const commandLine = env[`${prefix}_COMMAND`];
+        if (commandLine) {
+            mergeOverride(overrides, provider, parseCommandLine(commandLine));
+        }
+        const authMethodId = env[`${prefix}_AUTH_METHOD_ID`];
+        const sessionDelayMs = normalizeNumber(env[`${prefix}_SESSION_DELAY_MS`]);
+        const persistSession = normalizeBoolean(env[`${prefix}_PERSIST_SESSION`]);
+        const defaultModel = env[`${prefix}_DEFAULT_MODEL`];
+        const defaultModeId = env[`${prefix}_DEFAULT_MODE_ID`];
+        const explicitOverride = {};
+        if (authMethodId !== undefined) {
+            explicitOverride.authMethodId = authMethodId.trim() || null;
+        }
+        if (sessionDelayMs !== undefined) {
+            explicitOverride.sessionDelayMs = sessionDelayMs;
+        }
+        if (persistSession !== undefined) {
+            explicitOverride.persistSession = persistSession;
+        }
+        if (defaultModel !== undefined) {
+            explicitOverride.defaultModel = defaultModel.trim() || null;
+        }
+        if (defaultModeId !== undefined) {
+            explicitOverride.defaultModeId = defaultModeId.trim() || null;
+        }
+        if (Object.keys(explicitOverride).length) {
+            mergeOverride(overrides, provider, explicitOverride);
+        }
+    }
+    return overrides;
+}
+export function resolveAcpProviderConfig(providerInput, overrides = readProviderOverridesFromEnv()) {
+    var _a;
+    const provider = normalizeAcpProvider(providerInput);
+    return Object.assign(Object.assign({}, ACP_PROVIDER_REGISTRY[provider]), ((_a = overrides[provider]) !== null && _a !== void 0 ? _a : {}));
+}

package/dist/lib/acp2aisdk/response.d.ts

@@ -0,0 +1,3 @@
+import type { AcpRuntimeMetadata } from "./types";
+export declare function createRuntimeHeaders(metadata: AcpRuntimeMetadata): HeadersInit;
+export declare function createDirectMessageResponse(metadata: AcpRuntimeMetadata, text: string): Response;

package/dist/lib/acp2aisdk/response.mjs

@@ -0,0 +1,33 @@
+import { consumeStream, createUIMessageStream, createUIMessageStreamResponse, } from "ai";
+export function createRuntimeHeaders(metadata) {
+    var _a, _b, _c, _d, _e;
+    return {
+        "x-acp-provider": metadata.provider,
+        "x-acp-thread-id": encodeURIComponent(metadata.threadId),
+        "x-acp-session-key": encodeURIComponent(metadata.sessionKey),
+        "x-acp-session-id": (_a = metadata.acpSessionId) !== null && _a !== void 0 ? _a : "",
+        "x-acp-resumed-session-id": (_b = metadata.resumedAcpSessionId) !== null && _b !== void 0 ? _b : "",
+        "x-acp-cold-start": String(metadata.coldStart),
+        "x-acp-run-state": metadata.runState,
+        "x-acp-model": (_c = metadata.model) !== null && _c !== void 0 ? _c : "",
+        "x-acp-mode-id": (_d = metadata.modeId) !== null && _d !== void 0 ? _d : "",
+        "x-acp-thought-level": (_e = metadata.thoughtLevel) !== null && _e !== void 0 ? _e : "",
+        "x-acp-warning-count": String(metadata.warnings.length),
+    };
+}
+export function createDirectMessageResponse(metadata, text) {
+    const textId = "acp-ui-message";
+    const stream = createUIMessageStream({
+        execute: ({ writer }) => {
+            writer.write({ type: "text-start", id: textId });
+            writer.write({ type: "text-delta", id: textId, delta: text });
+            writer.write({ type: "text-end", id: textId });
+            writer.write({ type: "finish", finishReason: "error" });
+        },
+    });
+    return createUIMessageStreamResponse({
+        headers: createRuntimeHeaders(metadata),
+        stream,
+        consumeSseStream: consumeStream,
+    });
+}

package/dist/lib/acp2aisdk/runtime-options.d.ts

@@ -0,0 +1,2 @@
+import type { AcpPermissionMode } from "./types";
+export declare function normalizePermissionMode(value?: string | null): AcpPermissionMode;

package/dist/lib/acp2aisdk/runtime-options.mjs

@@ -0,0 +1,10 @@
+import { DEFAULT_PERMISSION_MODE } from "./session-store.mjs";
+export function normalizePermissionMode(value) {
+    if (value === "default" ||
+        value === "acceptEdits" ||
+        value === "bypassPermissions" ||
+        value === "plan") {
+        return value;
+    }
+    return DEFAULT_PERMISSION_MODE;
+}

package/dist/lib/acp2aisdk/session-runtime.d.ts

@@ -0,0 +1,5 @@
+import type { AcpChatRequest, AcpRuntimeMetadata, AcpSessionEntry, AcpSessionLookupRequest, AcpToolsInput } from "./types";
+export declare function getOrCreateSession(request: AcpChatRequest, tools?: AcpToolsInput): Promise<AcpSessionEntry>;
+export declare function applyRequestedModelAndMode(entry: AcpSessionEntry): Promise<void>;
+export declare function updateMetadataFromProvider(entry: AcpSessionEntry): AcpRuntimeMetadata;
+export declare function getSessionKeyForLookup(request: AcpSessionLookupRequest): string;

package/dist/lib/acp2aisdk/session-runtime.mjs

@@ -0,0 +1,186 @@
+import process from "node:process";
+import { getConversation } from "../conversations/store.mjs";
+import { getBuiltinToolRuntimeKey, mergeToolMcpServers, } from "../../tools/registry.mjs";
+import { buildAcpCapabilitySnapshot } from "./capabilities.mjs";
+import { applyAcpConfigOption, applyAcpThoughtLevel } from "./config-options.mjs";
+import { normalizeAdditionalDirectories, normalizeMcpServers, } from "./mcp-servers.mjs";
+import { installAcpProviderCompatibility } from "./provider-compat.mjs";
+import { getAcpProviderDefaultModeId, normalizeAcpProvider, resolveAcpProviderConfig, } from "./provider-registry.mjs";
+import { normalizePermissionMode } from "./runtime-options.mjs";
+import { createAcpSessionKey, createInitialMetadata, getGlobalAcpSessionStore, normalizeThreadId, normalizeWorkspacePath, } from "./session-store.mjs";
+import { createACPProvider, } from "./vendor/acp-ai-provider/index.mjs";
+function buildProviderSettings({ command, args, authMethodId, sessionDelayMs, persistSession, workspacePath, mcpServers, additionalDirectories, existingSessionId, }) {
+    const session = Object.assign({ cwd: workspacePath, mcpServers }, (additionalDirectories.length > 0 ? { additionalDirectories } : {}));
+    return Object.assign(Object.assign(Object.assign(Object.assign({ command,
+        args, env: Object.assign({}, process.env), initialize: {
+            clientCapabilities: {
+                fs: {
+                    readTextFile: false,
+                    writeTextFile: false,
+                },
+                terminal: false,
+                planCapabilities: {},
+                elicitation: {
+                    form: {},
+                    url: {},
+                },
+            },
+        }, session }, (existingSessionId ? { existingSessionId } : {})), (authMethodId ? { authMethodId } : {})), (sessionDelayMs ? { sessionDelayMs } : {})), { persistSession: persistSession !== null && persistSession !== void 0 ? persistSession : true });
+}
+async function prepareSessionCapabilities(entry, tools) {
+    try {
+        entry.provider.languageModel();
+        installAcpProviderCompatibility(entry.provider, entry.metadata);
+        const sessionResponse = await entry.provider.initSession(tools);
+        const capabilitySnapshot = buildAcpCapabilitySnapshot({
+            provider: entry.metadata.provider,
+            sessionResponse,
+        });
+        entry.metadata.acpSessionId = sessionResponse.sessionId;
+        entry.metadata.capabilitySnapshot = capabilitySnapshot;
+    }
+    catch (error) {
+        entry.metadata.runState = "error";
+        throw error;
+    }
+}
+export async function getOrCreateSession(request, tools) {
+    var _a, _b;
+    const store = getGlobalAcpSessionStore();
+    store.cleanupIdle();
+    const providerKey = normalizeAcpProvider(request.provider);
+    const providerConfig = resolveAcpProviderConfig(providerKey);
+    const threadId = normalizeThreadId((_a = request.threadId) !== null && _a !== void 0 ? _a : request.id);
+    const workspacePath = normalizeWorkspacePath(request.workspacePath);
+    const sessionKey = createAcpSessionKey({
+        threadId,
+        provider: providerKey,
+        workspacePath,
+    });
+    const permissionMode = normalizePermissionMode(request.permissionMode);
+    const requestedModel = request.model || null;
+    const requestedModeId = request.modeId || getAcpProviderDefaultModeId(providerKey);
+    const requestedThoughtLevel = request.thoughtLevel || null;
+    const requestedBuiltinToolRuntimeKey = getBuiltinToolRuntimeKey({
+        toolIds: request.builtinTools,
+        builtinToolSettings: request.builtinToolSettings,
+    });
+    const existing = store.get(sessionKey);
+    if (existing) {
+        if (existing.metadata.builtinToolRuntimeKey !== requestedBuiltinToolRuntimeKey) {
+            store.cleanup(sessionKey);
+        }
+        else {
+            existing.metadata = Object.assign(Object.assign({}, existing.metadata), { model: requestedModel, modeId: requestedModeId, thoughtLevel: requestedThoughtLevel, permissionMode, runState: "queued", coldStart: false, lastUsedAt: Date.now() });
+            return existing;
+        }
+    }
+    const conversation = await getConversation(threadId, workspacePath);
+    const resumableSessionId = (conversation === null || conversation === void 0 ? void 0 : conversation.provider) === providerKey
+        ? ((_b = conversation.providerSessionId) !== null && _b !== void 0 ? _b : null)
+        : null;
+    const createEntry = (existingSessionId, warnings = []) => {
+        const normalizedMcp = normalizeMcpServers(request.mcpServers);
+        const mergedMcpServers = mergeToolMcpServers(normalizedMcp.servers, {
+            workspacePath,
+            threadId,
+            toolIds: request.builtinTools,
+            builtinToolSettings: request.builtinToolSettings,
+        });
+        const normalizedAdditionalDirectories = normalizeAdditionalDirectories({
+            additionalDirectories: request.additionalDirectories,
+            workspacePath,
+            context: request.context,
+        });
+        const provider = createACPProvider(buildProviderSettings({
+            command: providerConfig.command,
+            args: providerConfig.args,
+            authMethodId: providerConfig.authMethodId,
+            sessionDelayMs: providerConfig.sessionDelayMs,
+            persistSession: providerConfig.persistSession,
+            workspacePath,
+            mcpServers: mergedMcpServers,
+            additionalDirectories: normalizedAdditionalDirectories.directories,
+            existingSessionId,
+        }));
+        return {
+            provider,
+            metadata: Object.assign(Object.assign({}, createInitialMetadata({
+                sessionKey,
+                threadId,
+                provider: providerKey,
+                workspacePath,
+                model: requestedModel,
+                modeId: requestedModeId,
+                thoughtLevel: requestedThoughtLevel,
+                permissionMode,
+            })), { resumedAcpSessionId: existingSessionId !== null && existingSessionId !== void 0 ? existingSessionId : null, builtinToolRuntimeKey: requestedBuiltinToolRuntimeKey, warnings: [
+                    ...warnings,
+                    ...normalizedMcp.warnings,
+                    ...normalizedAdditionalDirectories.warnings,
+                ] }),
+            promptHistoryStrategy: existingSessionId ? "session" : "full",
+        };
+    };
+    const entry = createEntry(resumableSessionId);
+    store.set(sessionKey, entry);
+    try {
+        await prepareSessionCapabilities(entry, tools);
+        return entry;
+    }
+    catch (error) {
+        store.cleanup(sessionKey);
+        if (!resumableSessionId)
+            throw error;
+    }
+    const fallbackEntry = createEntry(null, [
+        `Failed to resume ACP session "${resumableSessionId}"; started a new session with UI message history instead.`,
+    ]);
+    store.set(sessionKey, fallbackEntry);
+    await prepareSessionCapabilities(fallbackEntry, tools);
+    return fallbackEntry;
+}
+export async function applyRequestedModelAndMode(entry) {
+    const { model, modeId } = entry.metadata;
+    if (model) {
+        const applied = await applyAcpConfigOption(entry.provider, entry.metadata, "model", model, "model");
+        if (!applied) {
+            try {
+                entry.provider.languageModel(model, undefined);
+                await entry.provider.setModel(model);
+            }
+            catch (error) {
+                entry.metadata.warnings.push(`Failed to set ACP model "${model}": ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+    if (modeId) {
+        const applied = await applyAcpConfigOption(entry.provider, entry.metadata, "mode", modeId, "mode");
+        if (!applied) {
+            try {
+                entry.provider.languageModel(undefined, modeId);
+                await entry.provider.setMode(modeId);
+            }
+            catch (error) {
+                entry.metadata.warnings.push(`Failed to set ACP mode "${modeId}": ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+    await applyAcpThoughtLevel(entry.provider, entry.metadata);
+}
+export function updateMetadataFromProvider(entry) {
+    entry.metadata.acpSessionId = entry.provider.getSessionId();
+    entry.metadata.lastUsedAt = Date.now();
+    return entry.metadata;
+}
+export function getSessionKeyForLookup(request) {
+    var _a;
+    const providerKey = normalizeAcpProvider(request.provider);
+    const threadId = normalizeThreadId((_a = request.threadId) !== null && _a !== void 0 ? _a : request.id);
+    const workspacePath = normalizeWorkspacePath(request.workspacePath);
+    return createAcpSessionKey({
+        threadId,
+        provider: providerKey,
+        workspacePath,
+    });
+}

package/dist/lib/acp2aisdk/session-store.d.ts

@@ -0,0 +1,31 @@
+import type { AcpCapabilitySnapshot, AcpPermissionMode, AcpProviderKey, AcpRuntimeMetadata, AcpSessionEntry, AcpSessionKeyParts } from "./types";
+export declare const DEFAULT_THREAD_ID = "default";
+export declare const DEFAULT_PERMISSION_MODE: AcpPermissionMode;
+export declare const SESSION_IDLE_TTL_MS: number;
+export declare function getDefaultWorkspacePath(): string;
+export declare function normalizeWorkspacePath(workspacePath?: string | null): string;
+export declare function normalizeThreadId(id?: string | null): string;
+export declare function createAcpSessionKey(parts: AcpSessionKeyParts): string;
+export declare function createInitialMetadata({ sessionKey, threadId, provider, workspacePath, model, modeId, thoughtLevel, permissionMode, }: {
+    sessionKey: string;
+    threadId: string;
+    provider: AcpProviderKey;
+    workspacePath: string;
+    model?: string | null;
+    modeId?: string | null;
+    thoughtLevel?: string | null;
+    permissionMode?: AcpPermissionMode;
+}): AcpRuntimeMetadata;
+export declare class AcpInMemorySessionStore {
+    private sessions;
+    get(sessionKey: string): AcpSessionEntry | null;
+    set(sessionKey: string, entry: AcpSessionEntry): void;
+    touch(sessionKey: string): void;
+    updateMetadata(sessionKey: string, metadata: Partial<Omit<AcpRuntimeMetadata, "sessionKey">> & {
+        capabilitySnapshot?: AcpCapabilitySnapshot | null;
+    }): void;
+    cleanupIdle(now?: number): void;
+    cleanup(sessionKey: string): boolean;
+    list(): AcpRuntimeMetadata[];
+}
+export declare function getGlobalAcpSessionStore(): AcpInMemorySessionStore;

package/dist/lib/acp2aisdk/session-store.mjs

@@ -0,0 +1,169 @@
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+export const DEFAULT_THREAD_ID = "default";
+export const DEFAULT_PERMISSION_MODE = "bypassPermissions";
+export const SESSION_IDLE_TTL_MS = 30 * 60 * 1000;
+export function getDefaultWorkspacePath() {
+    return path.resolve(
+    /* turbopackIgnore: true */ process.env.ACP_UI_DEFAULT_WORKSPACE_PATH ||
+        process.cwd());
+}
+export function normalizeWorkspacePath(workspacePath) {
+    const fallback = getDefaultWorkspacePath();
+    const raw = typeof workspacePath === "string" && workspacePath.trim()
+        ? workspacePath.trim()
+        : fallback;
+    const resolved = path.resolve(/* turbopackIgnore: true */ raw);
+    try {
+        return fs.statSync(/* turbopackIgnore: true */ resolved).isDirectory()
+            ? resolved
+            : fallback;
+    }
+    catch (_a) {
+        return fallback;
+    }
+}
+export function normalizeThreadId(id) {
+    const normalized = String(id || "").trim();
+    return normalized || DEFAULT_THREAD_ID;
+}
+export function createAcpSessionKey(parts) {
+    return [
+        parts.provider,
+        encodeURIComponent(parts.workspacePath),
+        encodeURIComponent(parts.threadId),
+    ].join(":");
+}
+export function createInitialMetadata({ sessionKey, threadId, provider, workspacePath, model, modeId, thoughtLevel, permissionMode = DEFAULT_PERMISSION_MODE, }) {
+    return {
+        sessionKey,
+        threadId,
+        provider,
+        workspacePath,
+        acpSessionId: null,
+        resumedAcpSessionId: null,
+        sessionTitle: null,
+        model: model || null,
+        modeId: modeId || null,
+        thoughtLevel: thoughtLevel || null,
+        permissionMode,
+        runState: "queued",
+        coldStart: true,
+        warnings: [],
+        lastUsedAt: Date.now(),
+        capabilitySnapshot: null,
+        builtinToolRuntimeKey: null,
+    };
+}
+function getAgentProcess(provider) {
+    const model = provider
+        .model;
+    const agentProcess = model === null || model === void 0 ? void 0 : model.agentProcess;
+    if (!agentProcess || typeof agentProcess !== "object")
+        return null;
+    return agentProcess;
+}
+function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+function collectDescendantPids(pid, seen = new Set()) {
+    if (process.platform === "win32" || seen.has(pid))
+        return [];
+    seen.add(pid);
+    let output = "";
+    try {
+        output = execFileSync("pgrep", ["-P", String(pid)], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+    }
+    catch (_a) {
+        return [];
+    }
+    const childPids = output
+        .split(/\s+/)
+        .map((value) => Number(value))
+        .filter((value) => Number.isInteger(value) && value > 0);
+    return childPids.flatMap((childPid) => [
+        childPid,
+        ...collectDescendantPids(childPid, seen),
+    ]);
+}
+function forceKillProcess(pid) {
+    if (!isProcessRunning(pid))
+        return;
+    try {
+        process.kill(pid, "SIGKILL");
+    }
+    catch (_a) {
+        // The process may already have exited after the liveness check.
+    }
+}
+function cleanupAcpProvider(provider) {
+    const agentProcess = getAgentProcess(provider);
+    const pid = agentProcess === null || agentProcess === void 0 ? void 0 : agentProcess.pid;
+    const descendantPids = pid ? collectDescendantPids(pid) : [];
+    provider.cleanup();
+    for (const childPid of descendantPids) {
+        forceKillProcess(childPid);
+    }
+    if (pid)
+        forceKillProcess(pid);
+}
+export class AcpInMemorySessionStore {
+    constructor() {
+        this.sessions = new Map();
+    }
+    get(sessionKey) {
+        var _a;
+        return (_a = this.sessions.get(sessionKey)) !== null && _a !== void 0 ? _a : null;
+    }
+    set(sessionKey, entry) {
+        entry.metadata.lastUsedAt = Date.now();
+        this.sessions.set(sessionKey, entry);
+    }
+    touch(sessionKey) {
+        const entry = this.sessions.get(sessionKey);
+        if (entry)
+            entry.metadata.lastUsedAt = Date.now();
+    }
+    updateMetadata(sessionKey, metadata) {
+        const entry = this.sessions.get(sessionKey);
+        if (!entry)
+            return;
+        entry.metadata = Object.assign(Object.assign(Object.assign({}, entry.metadata), metadata), { lastUsedAt: Date.now() });
+    }
+    cleanupIdle(now = Date.now()) {
+        for (const [sessionKey, entry] of this.sessions) {
+            if (now - entry.metadata.lastUsedAt <= SESSION_IDLE_TTL_MS)
+                continue;
+            cleanupAcpProvider(entry.provider);
+            this.sessions.delete(sessionKey);
+        }
+    }
+    cleanup(sessionKey) {
+        const entry = this.sessions.get(sessionKey);
+        if (!entry)
+            return false;
+        cleanupAcpProvider(entry.provider);
+        this.sessions.delete(sessionKey);
+        return true;
+    }
+    list() {
+        return [...this.sessions.values()].map((entry) => entry.metadata);
+    }
+}
+const globalForAcp2AiSdk = globalThis;
+export function getGlobalAcpSessionStore() {
+    var _a;
+    const store = (_a = globalForAcp2AiSdk.__acp2AiSdkSessionStore) !== null && _a !== void 0 ? _a : new AcpInMemorySessionStore();
+    globalForAcp2AiSdk.__acp2AiSdkSessionStore = store;
+    return store;
+}

package/dist/lib/acp2aisdk/skill-command-cache.d.ts

@@ -0,0 +1,20 @@
+import type { AcpUiCommand } from "./commands";
+type StorageLike = Pick<Storage, "getItem" | "removeItem" | "setItem">;
+export type SkillCommandSnapshot = {
+    provider: string;
+    workspacePath: string | null;
+    updatedAt: string;
+    ttl: number;
+    commands: AcpUiCommand[];
+};
+export declare const SKILL_COMMAND_CACHE_TTL_MS: number;
+export declare function normalizeSkillCommandSnapshot(provider: string, workspacePath: string | null | undefined, snapshotOrCommands?: unknown): SkillCommandSnapshot | null;
+export declare function getSkillCommandCacheKey(provider: string, workspacePath?: string | null): string;
+export declare function readSkillCommandCache(provider: string, workspacePath?: string | null, storage?: StorageLike): SkillCommandSnapshot | null;
+export declare function persistSkillCommandCache(provider: string, workspacePath?: string | null, commands?: AcpUiCommand[] | SkillCommandSnapshot | null, storage?: StorageLike): SkillCommandSnapshot | null;
+export declare function isSkillCommandCacheFresh(snapshot?: SkillCommandSnapshot | null, now?: number): boolean;
+export declare function shouldFetchSkillCommands(snapshot?: SkillCommandSnapshot | null, { force, now }?: {
+    force?: boolean;
+    now?: number;
+}): boolean;
+export {};