@undefineds.co/xpod 0.2.44 → 0.3.0

package/dist/api/chatkit/runtime/AcpAgentRuntime.d.ts

@@ -0,0 +1,41 @@
+import type { AgentRuntimeConfig, AgentRuntimeEvent } from '../../runs/AgentRuntimeTypes';
+interface AgentRuntimeRunInput {
+    threadId: string;
+    prompt: string;
+    config: AgentRuntimeConfig;
+}
+/**
+ * Request-scoped ACP Agent Runtime.
+ *
+ * This class intentionally keeps no per-thread runner/session map. Durable
+ * conversation state belongs in the Pod; each invocation starts an ACP runner,
+ * creates one ACP session, streams events, then stops the runner.
+ */
+export declare class AcpAgentRuntime {
+    private readonly options;
+    private readonly logger;
+    private readonly git;
+    private readonly codexProjector;
+    constructor(options?: {
+        worktreeRootDirName?: string;
+    });
+    run(input: AgentRuntimeRunInput): AsyncIterable<AgentRuntimeEvent>;
+    private createSession;
+    private runPrompt;
+    private isRuntimeHandledRequest;
+    private resolveWorkdir;
+    private canResolveFileWorkspace;
+    private resolveAcpRunnerType;
+    private resolveRunnerArgv;
+    private resolveLocalBin;
+    private buildRunnerEnv;
+    private getIsolatedHomeDir;
+    private normalizeClaudeBaseUrl;
+    private convertMcpServersForAcp;
+    private extractTextDeltaFromSessionUpdate;
+    private extractTextFromPromptResult;
+    private extractAuthUrl;
+    private extractAuthOptions;
+    private formatError;
+}
+export {};

package/dist/api/chatkit/runtime/AcpAgentRuntime.js

@@ -0,0 +1,573 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AcpAgentRuntime = void 0;
+const path = __importStar(require("node:path"));
+const crypto = __importStar(require("node:crypto"));
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const global_logger_factory_1 = require("global-logger-factory");
+const platform_ai_config_1 = require("../../service/platform-ai-config");
+const runtime_1 = require("../../../runtime");
+const GitWorktreeService_1 = require("./GitWorktreeService");
+const AcpRunner_1 = require("./AcpRunner");
+const CodexRuntimeProjector_1 = require("./CodexRuntimeProjector");
+const provider_registry_1 = require("../../service/provider-registry");
+/**
+ * Request-scoped ACP Agent Runtime.
+ *
+ * This class intentionally keeps no per-thread runner/session map. Durable
+ * conversation state belongs in the Pod; each invocation starts an ACP runner,
+ * creates one ACP session, streams events, then stops the runner.
+ */
+class AcpAgentRuntime {
+    constructor(options = {}) {
+        this.options = options;
+        this.logger = (0, global_logger_factory_1.getLoggerFor)(this);
+        this.git = new GitWorktreeService_1.GitWorktreeService();
+        this.codexProjector = new CodexRuntimeProjector_1.CodexRuntimeProjector();
+    }
+    async *run(input) {
+        const { threadId, prompt, config } = input;
+        const workdir = await this.resolveWorkdir(threadId, config.workspace, config);
+        if (config.runner.protocol && config.runner.protocol !== 'acp') {
+            throw new Error(`Unsupported runner protocol: ${config.runner.protocol}. Only 'acp' is supported.`);
+        }
+        const runnerType = this.resolveAcpRunnerType(config.runner.type);
+        const argv = this.resolveRunnerArgv(runnerType, config.runner.argv);
+        const command = argv[0];
+        const args = argv.slice(1);
+        const env = this.buildRunnerEnv(runnerType, threadId, workdir, config.agentConfig);
+        const runner = new AcpRunner_1.AcpRunner();
+        const queue = new AsyncPushQueue();
+        try {
+            runner.start({ command, args, cwd: workdir, env });
+            const sessionId = await this.createSession(runner, workdir, config.agentConfig);
+            const runPromise = this.runPrompt(runner, sessionId, prompt, {
+                idleMs: config.idleMs ?? 500,
+                authWaitMs: Math.max(config.authWaitMs ?? 300_000, config.idleMs ?? 500),
+                queue,
+            }).catch((error) => {
+                queue.push({ type: 'error', message: this.formatError(error) });
+                queue.close();
+            });
+            for await (const event of queue.iterate()) {
+                yield event;
+            }
+            await runPromise;
+        }
+        catch (error) {
+            const message = this.formatError(error);
+            this.logger.warn(`ACP agent runtime failed: ${message}`);
+            yield { type: 'error', message };
+        }
+        finally {
+            runner.stop('SIGINT');
+        }
+    }
+    async createSession(runner, workdir, agentConfig) {
+        await runner.request('initialize', {
+            protocolVersion: 1,
+            clientCapabilities: {},
+            clientInfo: { name: 'xpod', version: 'dev' },
+        });
+        const sessionParams = { cwd: workdir };
+        if (agentConfig) {
+            sessionParams.mcpServers = Object.keys(agentConfig.mcpServers).length > 0
+                ? this.convertMcpServersForAcp(agentConfig.mcpServers)
+                : [];
+            if (agentConfig.systemPrompt)
+                sessionParams.systemPrompt = agentConfig.systemPrompt;
+            if (agentConfig.skillsContent)
+                sessionParams.appendSystemPrompt = agentConfig.skillsContent;
+            if (agentConfig.maxTurns)
+                sessionParams.maxTurns = agentConfig.maxTurns;
+            if (agentConfig.allowedTools)
+                sessionParams.allowedTools = agentConfig.allowedTools;
+            if (agentConfig.disallowedTools)
+                sessionParams.disallowedTools = agentConfig.disallowedTools;
+            if (agentConfig.permissionMode)
+                sessionParams.permissionMode = agentConfig.permissionMode;
+        }
+        else {
+            sessionParams.mcpServers = [];
+        }
+        const newSession = await runner.request('session/new', sessionParams);
+        if (!newSession?.sessionId) {
+            throw new Error('ACP session/new did not return sessionId');
+        }
+        return newSession.sessionId;
+    }
+    async runPrompt(runner, sessionId, prompt, options) {
+        const { idleMs, authWaitMs, queue } = options;
+        let idleTimer;
+        let done = false;
+        const finish = () => {
+            if (done)
+                return;
+            done = true;
+            if (idleTimer) {
+                clearTimeout(idleTimer);
+                idleTimer = undefined;
+            }
+            runner.off('notification', onNotification);
+            runner.off('request', onRequest);
+            queue.close();
+        };
+        const bumpIdle = (ms = idleMs) => {
+            if (done)
+                return;
+            if (idleTimer)
+                clearTimeout(idleTimer);
+            idleTimer = setTimeout(() => finish(), ms);
+        };
+        const onRequest = (req) => {
+            if (!req || typeof req.method !== 'string')
+                return;
+            if (this.isRuntimeHandledRequest(req.method)) {
+                const hint = req.params?.message || req.params?.reason || req.method;
+                const url = this.extractAuthUrl(req.params);
+                const authOptions = this.extractAuthOptions(req.params) ??
+                    (url ? [{ label: 'Continue in browser', url, method: req.method }] : undefined);
+                queue.push({
+                    type: 'auth_required',
+                    method: req.method,
+                    url,
+                    message: typeof hint === 'string' ? hint : undefined,
+                    options: authOptions,
+                });
+                bumpIdle(authWaitMs);
+                if (req.method === 'session/request_permission') {
+                    req.respond({ granted: true });
+                }
+                else {
+                    req.respond({ handled: true });
+                }
+                return;
+            }
+            const requestId = `acp:${String(req.id)}`;
+            queue.push({
+                type: 'tool_call',
+                requestId,
+                name: req.method,
+                arguments: JSON.stringify(req.params ?? {}),
+            });
+            req.fail(-32601, `Unsupported ACP client request in stateless runtime: ${req.method}`);
+            finish();
+        };
+        const onNotification = (method, params) => {
+            if (method !== 'session/update')
+                return;
+            if (!params || params.sessionId !== sessionId)
+                return;
+            const update = params.update;
+            if (!update || typeof update !== 'object')
+                return;
+            const text = this.extractTextDeltaFromSessionUpdate(update);
+            if (typeof text === 'string' && text.length > 0) {
+                queue.push({ type: 'text', text });
+                bumpIdle();
+            }
+        };
+        runner.on('request', onRequest);
+        runner.on('notification', onNotification);
+        try {
+            void runner.request('session/prompt', {
+                sessionId,
+                prompt: [{ type: 'text', text: prompt }],
+            }).then((result) => {
+                const text = this.extractTextFromPromptResult(result);
+                if (typeof text === 'string' && text.length > 0) {
+                    queue.push({ type: 'text', text });
+                    bumpIdle();
+                }
+                else {
+                    bumpIdle();
+                }
+            }).catch((error) => {
+                if (!done) {
+                    queue.push({ type: 'error', message: this.formatError(error) });
+                    finish();
+                }
+            });
+            bumpIdle();
+            await queue.waitClosed();
+        }
+        finally {
+            finish();
+        }
+    }
+    isRuntimeHandledRequest(method) {
+        return method === 'session/request_permission' ||
+            method === 'auth/request' ||
+            method === 'auth/authorize';
+    }
+    async resolveWorkdir(threadId, workspace, config) {
+        const url = new URL(workspace);
+        if (url.protocol !== 'file:') {
+            throw new Error('ACP runtime only supports file:// workspaces; use pi Agent Runtime for Pod-backed runs');
+        }
+        if (!this.canResolveFileWorkspace(url)) {
+            throw new Error(`Workspace is not resolvable by this ACP runner: ${workspace}`);
+        }
+        const repoRoot = decodeURIComponent(url.pathname);
+        if (!fs.existsSync(repoRoot)) {
+            throw new Error(`workspace URI does not exist on this runner: ${workspace}`);
+        }
+        const worktree = config.worktree;
+        if (!worktree) {
+            return repoRoot;
+        }
+        if (worktree.mode === 'existing') {
+            if (!fs.existsSync(worktree.path)) {
+                throw new Error(`worktree.path not found: ${worktree.path}`);
+            }
+            return worktree.path;
+        }
+        await this.git.assertGitRepo(repoRoot);
+        const rootDirName = this.options.worktreeRootDirName ?? '.xpod-worktrees';
+        const root = path.join(repoRoot, rootDirName);
+        const worktreePath = path.join(root, threadId);
+        if (fs.existsSync(worktreePath)) {
+            return worktreePath;
+        }
+        const baseRef = worktree.baseRef ?? 'main';
+        await this.git.createWorktree({
+            repoPath: repoRoot,
+            worktreePath,
+            baseRef,
+            branch: worktree.branch,
+        });
+        return worktreePath;
+    }
+    canResolveFileWorkspace(url) {
+        const authority = url.hostname;
+        if (!authority || authority === 'localhost') {
+            return true;
+        }
+        const configured = process.env.XPOD_RUNNER_AUTHORITY?.trim();
+        return authority === configured || authority === os.hostname();
+    }
+    resolveAcpRunnerType(type) {
+        if (type === 'codebuddy' || type === 'claude' || type === 'codex') {
+            return type;
+        }
+        throw new Error(`Unsupported ACP runner type: ${type}`);
+    }
+    resolveRunnerArgv(type, argv) {
+        if (argv && argv.length > 0) {
+            return argv;
+        }
+        switch (type) {
+            case 'codebuddy':
+                return [this.resolveLocalBin('codebuddy'), '--acp'];
+            case 'claude':
+                return [this.resolveLocalBin('claude-code-acp')];
+            case 'codex':
+                return [this.resolveLocalBin('codex-acp')];
+            default:
+                return [type];
+        }
+    }
+    resolveLocalBin(binName) {
+        const localBin = path.join(runtime_1.PACKAGE_ROOT, 'node_modules', '.bin', binName);
+        if (fs.existsSync(localBin)) {
+            return localBin;
+        }
+        return binName;
+    }
+    buildRunnerEnv(type, threadId, workdir, agentConfig) {
+        const defaultApiKey = agentConfig?.apiKey || process.env.DEFAULT_API_KEY?.trim();
+        const rawApiBase = agentConfig?.baseUrl || (0, platform_ai_config_1.getPlatformApiBaseUrl)();
+        const defaultModel = agentConfig?.model || process.env.DEFAULT_MODEL?.trim();
+        if (type === 'codebuddy') {
+            return undefined;
+        }
+        const home = this.getIsolatedHomeDir(type, threadId, workdir);
+        if (type === 'codex') {
+            const defaultApiBase = rawApiBase || (0, provider_registry_1.getDefaultBaseUrl)();
+            const codexHome = path.join(home, '.codex');
+            this.codexProjector.project({
+                codexHome,
+                baseUrl: defaultApiBase,
+                apiKey: defaultApiKey,
+                wireApi: (0, provider_registry_1.codexWireApi)(defaultApiBase),
+                model: defaultModel,
+                agentConfig,
+            });
+            const env = {
+                HOME: home,
+                XDG_CONFIG_HOME: path.join(home, '.config'),
+                XDG_STATE_HOME: path.join(home, '.local', 'state'),
+                XDG_DATA_HOME: path.join(home, '.local', 'share'),
+                XDG_CACHE_HOME: path.join(home, '.cache'),
+                CODEX_HOME: codexHome,
+            };
+            if (defaultApiKey) {
+                env.CODEX_API_KEY = defaultApiKey;
+                env.OPENAI_API_KEY = defaultApiKey;
+            }
+            env.OPENAI_BASE_URL = defaultApiBase;
+            env.OPENAI_API_BASE = defaultApiBase;
+            if (defaultModel) {
+                env.OPENAI_MODEL = defaultModel;
+                env.CODEX_MODEL = defaultModel;
+            }
+            return env;
+        }
+        const defaultApiBase = rawApiBase || (0, provider_registry_1.getDefaultBaseUrl)();
+        const env = {
+            HOME: home,
+            XDG_CONFIG_HOME: path.join(home, '.config'),
+            XDG_STATE_HOME: path.join(home, '.local', 'state'),
+            XDG_DATA_HOME: path.join(home, '.local', 'share'),
+            XDG_CACHE_HOME: path.join(home, '.cache'),
+        };
+        const normalizedBase = defaultApiBase ? this.normalizeClaudeBaseUrl(defaultApiBase) : undefined;
+        const isOpenRouterLike = (typeof normalizedBase === 'string' && normalizedBase.includes('openrouter.ai'));
+        if (defaultApiKey) {
+            if (isOpenRouterLike) {
+                env.ANTHROPIC_AUTH_TOKEN = defaultApiKey;
+                delete env.ANTHROPIC_API_KEY;
+            }
+            else {
+                env.ANTHROPIC_API_KEY = defaultApiKey;
+                delete env.ANTHROPIC_AUTH_TOKEN;
+            }
+        }
+        if (normalizedBase) {
+            env.ANTHROPIC_BASE_URL = normalizedBase;
+        }
+        if (defaultModel) {
+            env.ANTHROPIC_DEFAULT_SONNET_MODEL = defaultModel;
+            env.ANTHROPIC_DEFAULT_HAIKU_MODEL = defaultModel;
+            env.ANTHROPIC_DEFAULT_OPUS_MODEL = defaultModel;
+        }
+        return env;
+    }
+    getIsolatedHomeDir(type, threadId, workdir) {
+        const hash = crypto.createHash('sha256').update(`${type}:${threadId}:${workdir}`).digest('hex').slice(0, 16);
+        const root = path.join(os.tmpdir(), 'xpod-acp-home', type, hash);
+        fs.mkdirSync(root, { recursive: true });
+        return root;
+    }
+    normalizeClaudeBaseUrl(baseUrl) {
+        if (baseUrl.endsWith('/v1')) {
+            return baseUrl.slice(0, -3);
+        }
+        if (baseUrl.endsWith('/v1/')) {
+            return baseUrl.slice(0, -4);
+        }
+        return baseUrl;
+    }
+    convertMcpServersForAcp(servers) {
+        return Object.entries(servers).map(([name, config]) => ({
+            name,
+            ...config,
+        }));
+    }
+    extractTextDeltaFromSessionUpdate(update) {
+        if (!update)
+            return undefined;
+        if (typeof update === 'string')
+            return update;
+        if (typeof update.delta === 'string')
+            return update.delta;
+        if (typeof update.text === 'string')
+            return update.text;
+        const content = update.content?.content ?? update.content;
+        if (typeof content === 'string')
+            return content;
+        if (content && typeof content === 'object') {
+            if (typeof content.text === 'string')
+                return content.text;
+            if (Array.isArray(content)) {
+                const parts = content
+                    .map((part) => (part && typeof part === 'object' ? part.text : undefined))
+                    .filter((text) => typeof text === 'string');
+                if (parts.length)
+                    return parts.join('');
+            }
+        }
+        const message = update.message ?? update.item ?? update.assistant_message;
+        if (message && typeof message === 'object') {
+            const msgContent = message.content?.content ?? message.content;
+            if (typeof msgContent === 'string')
+                return msgContent;
+            if (Array.isArray(msgContent)) {
+                const parts = msgContent
+                    .map((part) => {
+                    if (!part || typeof part !== 'object')
+                        return undefined;
+                    if (typeof part.text === 'string')
+                        return part.text;
+                    if (typeof part.delta === 'string')
+                        return part.delta;
+                    return undefined;
+                })
+                    .filter((text) => typeof text === 'string');
+                if (parts.length)
+                    return parts.join('');
+            }
+        }
+        return undefined;
+    }
+    extractTextFromPromptResult(result) {
+        if (!result)
+            return undefined;
+        if (typeof result === 'string')
+            return result;
+        if (typeof result.text === 'string')
+            return result.text;
+        if (typeof result.output_text === 'string')
+            return result.output_text;
+        const message = result.message ?? result.item ?? result.assistant_message;
+        if (message && typeof message === 'object') {
+            const msgContent = message.content?.content ?? message.content;
+            if (typeof msgContent === 'string')
+                return msgContent;
+            if (Array.isArray(msgContent)) {
+                const parts = msgContent
+                    .map((part) => (part && typeof part === 'object' ? (typeof part.text === 'string' ? part.text : undefined) : undefined))
+                    .filter((text) => typeof text === 'string');
+                if (parts.length)
+                    return parts.join('');
+            }
+        }
+        const content = result.content?.content ?? result.content;
+        if (typeof content === 'string')
+            return content;
+        if (Array.isArray(content)) {
+            const parts = content
+                .map((part) => (part && typeof part === 'object' ? (typeof part.text === 'string' ? part.text : undefined) : undefined))
+                .filter((text) => typeof text === 'string');
+            if (parts.length)
+                return parts.join('');
+        }
+        return undefined;
+    }
+    extractAuthUrl(params) {
+        if (!params || typeof params !== 'object')
+            return undefined;
+        const candidates = [
+            params.url,
+            params.authorizationUrl,
+            params.authorization_url,
+            params.authUrl,
+            params.auth_url,
+            params.browserUrl,
+            params.browser_url,
+            params.verification_uri,
+            params.verificationUri,
+            params.verificationUrl,
+        ];
+        return candidates.find((value) => typeof value === 'string' && value.startsWith('http'));
+    }
+    extractAuthOptions(params) {
+        if (!params || typeof params !== 'object')
+            return undefined;
+        const raw = Array.isArray(params.methods) ? params.methods
+            : Array.isArray(params.options) ? params.options
+                : Array.isArray(params.authMethods) ? params.authMethods
+                    : Array.isArray(params.auth_methods) ? params.auth_methods
+                        : undefined;
+        if (!raw)
+            return undefined;
+        const options = raw
+            .map((method) => {
+            if (!method || typeof method !== 'object')
+                return undefined;
+            const url = this.extractAuthUrl(method);
+            const label = typeof method.label === 'string' ? method.label :
+                typeof method.name === 'string' ? method.name :
+                    typeof method.type === 'string' ? method.type :
+                        undefined;
+            const optionMethod = typeof method.method === 'string' ? method.method :
+                typeof method.type === 'string' ? method.type :
+                    undefined;
+            return { label, url, method: optionMethod };
+        })
+            .filter(Boolean);
+        return options.length > 0 ? options : undefined;
+    }
+    formatError(error) {
+        const anyError = error;
+        const dataMessage = anyError?.data && typeof anyError.data === 'object' && typeof anyError.data.message === 'string'
+            ? anyError.data.message
+            : undefined;
+        const message = String(anyError?.message ?? error);
+        return dataMessage ? `${message} | data.message=${dataMessage.slice(0, 800)}` : message;
+    }
+}
+exports.AcpAgentRuntime = AcpAgentRuntime;
+class AsyncPushQueue {
+    constructor() {
+        this.items = [];
+        this.resolvers = [];
+        this.closed = false;
+        this.closeResolvers = [];
+    }
+    push(item) {
+        if (this.closed) {
+            return;
+        }
+        this.items.push(item);
+        const resolver = this.resolvers.shift();
+        resolver?.();
+    }
+    close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        for (const resolver of this.resolvers) {
+            resolver();
+        }
+        this.resolvers = [];
+        for (const resolver of this.closeResolvers) {
+            resolver();
+        }
+        this.closeResolvers = [];
+    }
+    async waitClosed() {
+        if (this.closed) {
+            return;
+        }
+        await new Promise((resolve) => this.closeResolvers.push(resolve));
+    }
+    async *iterate() {
+        while (true) {
+            if (this.items.length > 0) {
+                yield this.items.shift();
+                continue;
+            }
+            if (this.closed) {
+                return;
+            }
+            await new Promise((resolve) => this.resolvers.push(resolve));
+        }
+    }
+}
+//# sourceMappingURL=AcpAgentRuntime.js.map