@jungjaehoon/mama-os 0.32.0 → 0.32.2

package/dist/agent/cline-cli-adapter.js

@@ -0,0 +1,1040 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClineCLIAdapter = void 0;
+exports.resolveClineDataDir = resolveClineDataDir;
+exports.hasPersistedClineCredential = hasPersistedClineCredential;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_url_1 = require("node:url");
+const node_crypto_1 = require("node:crypto");
+const node_events_1 = require("node:events");
+const node_os_1 = require("node:os");
+const model_runner_js_1 = require("./model-runner.js");
+const cline_native_tool_policy_js_1 = require("./cline-native-tool-policy.js");
+const completed_terminal_result_js_1 = require("./code-act/completed-terminal-result.js");
+const types_js_1 = require("./types.js");
+const CLINE_CODE_ACT_TOOL_NAME = 'mcp__code-act__code_act';
+const MAMA_CODE_ACT_TOOL_NAME = 'code_act';
+const CLINE_MUTATION_SETTLEMENT_GRACE_MS = 5_250;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function stringValue(record, key) {
+    const value = record[key];
+    return typeof value === 'string' ? value : undefined;
+}
+function numberValue(record, key) {
+    const value = record[key];
+    return typeof value === 'number' ? value : undefined;
+}
+function normalizeToolOutput(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (value === undefined) {
+        return '';
+    }
+    return JSON.stringify(value);
+}
+function classifyFailure(message) {
+    const normalized = message.toLowerCase();
+    if (/quota|rate.?limit|\b429\b/.test(normalized)) {
+        return 'rate_limit';
+    }
+    if (/unauthorized|authentication|invalid api key|credentials?|\b401\b|\b403\b/.test(normalized)) {
+        return 'auth_failure';
+    }
+    if (/context.{0,20}(length|window|overflow)|too many tokens/.test(normalized)) {
+        return 'context_overflow';
+    }
+    if (/timed? out|timeout/.test(normalized)) {
+        return 'timeout';
+    }
+    return 'crash';
+}
+function resolveClineDataDir(dataDir) {
+    if (dataDir === '~') {
+        return (0, node_os_1.homedir)();
+    }
+    if (dataDir.startsWith('~/')) {
+        return (0, node_path_1.resolve)((0, node_os_1.homedir)(), dataDir.slice(2));
+    }
+    return (0, node_path_1.resolve)(dataDir);
+}
+function safeProviderFailure(rawText, finishReason) {
+    const code = classifyFailure(rawText || finishReason);
+    let providerCode;
+    let providerMessage = '';
+    try {
+        const parsed = JSON.parse(rawText);
+        if (isRecord(parsed) && isRecord(parsed.error)) {
+            providerCode = stringValue(parsed.error, 'code')
+                ?.replace(/[^A-Za-z0-9_.-]/g, '')
+                .slice(0, 64);
+            providerMessage = stringValue(parsed.error, 'message') ?? '';
+        }
+    }
+    catch {
+        providerMessage = rawText;
+    }
+    const reason = finishReason.replace(/[^A-Za-z0-9_.-]/g, '').slice(0, 32) || 'unknown';
+    const suffix = providerCode ? `, provider=${providerCode}` : '';
+    if (code === 'rate_limit') {
+        const retryHint = providerMessage.match(/try again in\s+\d+\s*(?:days?|hours?|minutes?|seconds?|[dhms])(?:\s+\d+\s*(?:days?|hours?|minutes?|seconds?|[dhms])){0,3}/i)?.[0];
+        return {
+            code,
+            message: `Cline Hub run failed (rate_limit${suffix}): Daily free limit reached${retryHint ? `. ${retryHint}` : ''}`.slice(0, 320),
+        };
+    }
+    if (code === 'auth_failure') {
+        return {
+            code,
+            message: `Cline Hub authentication failed${suffix}. Run: cline auth cline`.slice(0, 320),
+        };
+    }
+    const label = code === 'context_overflow'
+        ? 'context limit exceeded'
+        : code === 'timeout'
+            ? 'request timed out'
+            : `run ended with finish reason ${reason}`;
+    return { code, message: `Cline Hub ${label}${suffix}`.slice(0, 320) };
+}
+function executableCandidates(command) {
+    if ((0, node_path_1.isAbsolute)(command) || command.includes('/')) {
+        return [(0, node_path_1.resolve)(command)];
+    }
+    const pathEntries = (process.env.PATH ?? '').split(node_path_1.delimiter).filter(Boolean);
+    const suffixes = process.platform === 'win32' ? ['', '.cmd', '.exe', '.bat'] : [''];
+    return pathEntries.flatMap((entry) => suffixes.map((suffix) => (0, node_path_1.join)(entry, `${command}${suffix}`)));
+}
+function resolveClineWrapper(command) {
+    for (const candidate of executableCandidates(command)) {
+        try {
+            (0, node_fs_1.accessSync)(candidate, node_fs_1.constants.X_OK);
+            return (0, node_fs_1.realpathSync)(candidate);
+        }
+        catch {
+            // Continue through PATH candidates.
+        }
+    }
+    throw new Error(`Cline CLI executable not found: ${command}`);
+}
+function resolveClineSdkEntry(wrapperPath) {
+    let current = (0, node_path_1.dirname)(wrapperPath);
+    for (let depth = 0; depth < 8; depth += 1) {
+        const candidate = (0, node_path_1.join)(current, 'node_modules', '@cline', 'core', 'dist', 'index.js');
+        if ((0, node_fs_1.existsSync)(candidate)) {
+            return candidate;
+        }
+        const parent = (0, node_path_1.dirname)(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+    throw new Error(`The installed Cline CLI does not include its companion @cline/core runtime: ${wrapperPath}`);
+}
+function validateImportedSdk(value) {
+    if (!isRecord(value)) {
+        throw new Error('Cline companion SDK did not export an object');
+    }
+    const clineCore = value.ClineCore;
+    const providerManager = value.ProviderSettingsManager;
+    const clineCoreCreate = (typeof clineCore === 'function' || isRecord(clineCore)) &&
+        typeof clineCore.create === 'function';
+    if (!clineCoreCreate ||
+        typeof providerManager !== 'function' ||
+        typeof value.getPersistedProviderApiKey !== 'function' ||
+        typeof value.createTool !== 'function') {
+        throw new Error('Cline companion SDK is missing the Hub session API required by MAMA');
+    }
+    return value;
+}
+async function hasPersistedClineCredential(options = {}) {
+    const wrapperPath = resolveClineWrapper(options.command ?? process.env.MAMA_CLINE_COMMAND ?? process.env.CLINE_COMMAND ?? 'cline');
+    const sdkEntry = resolveClineSdkEntry(wrapperPath);
+    const imported = await import((0, node_url_1.pathToFileURL)(sdkEntry).href);
+    const sdk = validateImportedSdk(imported);
+    const dataDir = options.dataDir ? resolveClineDataDir(options.dataDir) : undefined;
+    const manager = new sdk.ProviderSettingsManager(dataDir ? { dataDir } : undefined);
+    const provider = options.provider ?? 'cline';
+    return Boolean(sdk.getPersistedProviderApiKey(provider, manager.getProviderSettings(provider)));
+}
+const defaultRuntimeFactory = async (input) => {
+    const wrapperPath = resolveClineWrapper(input.command);
+    const sdkEntry = resolveClineSdkEntry(wrapperPath);
+    if (input.dataDir) {
+        const requestedDataDir = resolveClineDataDir(input.dataDir);
+        const existingDataDir = process.env.CLINE_DATA_DIR?.trim();
+        if (existingDataDir && resolveClineDataDir(existingDataDir) !== requestedDataDir) {
+            throw new Error(`Cline Hub data directory is already bound to ${existingDataDir}; cannot switch to ${input.dataDir}`);
+        }
+        process.env.CLINE_DATA_DIR = requestedDataDir;
+    }
+    process.env.CLINE_WRAPPER_PATH = wrapperPath;
+    const imported = await import((0, node_url_1.pathToFileURL)(sdkEntry).href);
+    const sdk = validateImportedSdk(imported);
+    const providerManager = new sdk.ProviderSettingsManager(input.dataDir ? { dataDir: resolveClineDataDir(input.dataDir) } : undefined);
+    const providerSettings = providerManager.getProviderSettings(input.provider);
+    const apiKey = sdk.getPersistedProviderApiKey(input.provider, providerSettings);
+    const client = await sdk.ClineCore.create({
+        clientName: 'mama-os',
+        backendMode: 'hub',
+        hub: {
+            cwd: input.cwd,
+            workspaceRoot: input.cwd,
+            clientType: 'mama-os',
+            displayName: 'MAMA OS',
+            strategy: 'require-hub',
+        },
+    });
+    return {
+        client,
+        source: sdk.SessionSource?.CORE ?? 'core',
+        apiKey,
+        createTool: (definition) => sdk.createTool(definition),
+    };
+};
+function parseAgentResult(value) {
+    if (!isRecord(value)) {
+        throw new Error('Cline Hub returned no agent result');
+    }
+    const usage = isRecord(value.usage) ? value.usage : undefined;
+    return {
+        text: stringValue(value, 'text') ?? '',
+        finishReason: stringValue(value, 'finishReason') ?? 'unknown',
+        durationMs: numberValue(value, 'durationMs'),
+        usage: usage
+            ? {
+                inputTokens: numberValue(usage, 'inputTokens'),
+                outputTokens: numberValue(usage, 'outputTokens'),
+                cacheReadTokens: numberValue(usage, 'cacheReadTokens'),
+                cacheWriteTokens: numberValue(usage, 'cacheWriteTokens'),
+                totalCost: numberValue(usage, 'totalCost'),
+            }
+            : undefined,
+    };
+}
+function toolFingerprint(bridge, allowedTools, disallowedTools, allowSpawnAgent, allowAgentTeams) {
+    return JSON.stringify({
+        projectedTools: (bridge?.tools ?? []).map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            inputSchema: tool.inputSchema,
+        })),
+        allowedTools,
+        disallowedTools,
+        allowSpawnAgent,
+        allowAgentTeams,
+    });
+}
+function buildToolPolicies(bridge, allowedTools, disallowedTools) {
+    const allowAll = allowedTools.includes('*');
+    const policies = {
+        '*': { enabled: allowAll, autoApprove: allowAll },
+    };
+    if (!allowAll) {
+        for (const tool of allowedTools) {
+            policies[tool] = { enabled: true, autoApprove: true };
+        }
+    }
+    for (const tool of disallowedTools) {
+        policies[tool] = { enabled: false, autoApprove: false };
+    }
+    for (const definition of bridge?.tools ?? []) {
+        const name = definition.name === MAMA_CODE_ACT_TOOL_NAME ? CLINE_CODE_ACT_TOOL_NAME : definition.name;
+        policies[name] = { enabled: true, autoApprove: true };
+    }
+    return policies;
+}
+function combineSignals(...signals) {
+    const present = signals.filter((signal) => signal !== undefined);
+    if (present.length === 0) {
+        return new AbortController().signal;
+    }
+    return present.length === 1 ? present[0] : AbortSignal.any(present);
+}
+function abortError(signal) {
+    return signal.reason instanceof Error
+        ? signal.reason
+        : new model_runner_js_1.ModelRunnerError('Cline Hub request was aborted', 'unknown', false);
+}
+function raceWithAbort(operation, signal) {
+    if (signal.aborted) {
+        return Promise.reject(abortError(signal));
+    }
+    return new Promise((resolvePromise, rejectPromise) => {
+        const onAbort = () => rejectPromise(abortError(signal));
+        signal.addEventListener('abort', onAbort, { once: true });
+        operation.then((value) => {
+            signal.removeEventListener('abort', onAbort);
+            resolvePromise(value);
+        }, (error) => {
+            signal.removeEventListener('abort', onAbort);
+            rejectPromise(error);
+        });
+    });
+}
+class ClineCLIAdapter extends node_events_1.EventEmitter {
+    backendType = 'cline';
+    options;
+    runtimeFactory;
+    sessions = new Map();
+    stableRoutes = new Map();
+    routesRequiringRebuild = new Set();
+    routeTails = new Map();
+    activeRoutes = new Set();
+    sessionLifecycleTail = Promise.resolve();
+    runtimePromise = null;
+    disposedRuntimes = new WeakSet();
+    runtimeWaiters = 0;
+    sessionId;
+    systemPrompt;
+    requestCount = 0;
+    failureCount = 0;
+    totalLatencyMs = 0;
+    lastRequestAt = null;
+    stopped = false;
+    maxSessions;
+    sessionTtlMs;
+    constructor(options = {}) {
+        super();
+        this.options = {
+            ...options,
+            command: options.command ?? process.env.MAMA_CLINE_COMMAND ?? process.env.CLINE_COMMAND,
+        };
+        this.runtimeFactory = options.runtimeFactory ?? defaultRuntimeFactory;
+        this.sessionId = options.sessionId ?? 'cline';
+        this.systemPrompt = options.systemPrompt ?? '';
+        this.maxSessions = Math.max(1, options.maxSessions ?? 100);
+        this.sessionTtlMs = Math.max(1, options.sessionTtlMs ?? 1_800_000);
+    }
+    async prompt(content, callbacks, promptOptions) {
+        const startedAt = Date.now();
+        const routeId = promptOptions?.sessionId ?? promptOptions?.sessionKey ?? this.sessionId;
+        const stableRouteId = promptOptions?.sessionKey ?? routeId;
+        const timeoutMs = promptOptions?.requestTimeout ?? this.options.requestTimeout ?? 600_000;
+        const deadlineController = new AbortController();
+        let lockAcquired = false;
+        const timeoutHandle = setTimeout(() => {
+            const error = new model_runner_js_1.ModelRunnerError(`Cline Hub request timed out after ${timeoutMs}ms`, 'timeout', true);
+            deadlineController.abort(error);
+            if (lockAcquired) {
+                void this.abortRoute(routeId, error);
+            }
+        }, timeoutMs);
+        timeoutHandle.unref();
+        this.requestCount += 1;
+        this.lastRequestAt = startedAt;
+        try {
+            return await this.withRouteLock(stableRouteId, deadlineController.signal, () => {
+                lockAcquired = true;
+                this.activeRoutes.add(routeId);
+            }, async () => {
+                try {
+                    return await this.runHubPrompt(routeId, stableRouteId, content, callbacks, promptOptions, deadlineController.signal, timeoutMs);
+                }
+                finally {
+                    this.activeRoutes.delete(routeId);
+                }
+            });
+        }
+        catch (error) {
+            this.failureCount += 1;
+            const normalized = this.normalizeError(error);
+            if (lockAcquired && normalized instanceof model_runner_js_1.ModelRunnerError && normalized.code === 'timeout') {
+                await this.quarantineRoute(routeId);
+            }
+            callbacks?.onError?.(normalized);
+            throw normalized;
+        }
+        finally {
+            clearTimeout(timeoutHandle);
+            this.totalLatencyMs += Date.now() - startedAt;
+            if (this.routeTails.size === 0) {
+                this.emit('idle');
+            }
+        }
+    }
+    async withRouteLock(routeId, signal, onAcquired, run) {
+        const previous = this.routeTails.get(routeId) ?? Promise.resolve();
+        let acquired = false;
+        const current = previous
+            .catch(() => undefined)
+            .then(async () => {
+            if (signal.aborted) {
+                throw signal.reason instanceof Error
+                    ? signal.reason
+                    : new model_runner_js_1.ModelRunnerError('Cline Hub request was aborted', 'unknown');
+            }
+            acquired = true;
+            onAcquired();
+            return await run();
+        });
+        const tail = current.then(() => undefined, () => undefined);
+        this.routeTails.set(routeId, tail);
+        void tail.then(() => {
+            if (this.routeTails.get(routeId) === tail) {
+                this.routeTails.delete(routeId);
+            }
+        });
+        return await new Promise((resolvePromise, rejectPromise) => {
+            const onAbort = () => {
+                if (!acquired) {
+                    rejectPromise(abortError(signal));
+                }
+            };
+            signal.addEventListener('abort', onAbort, { once: true });
+            current.then((value) => {
+                signal.removeEventListener('abort', onAbort);
+                resolvePromise(value);
+            }, (error) => {
+                signal.removeEventListener('abort', onAbort);
+                rejectPromise(error);
+            });
+        });
+    }
+    async withSessionLifecycleLock(signal, run) {
+        const current = this.sessionLifecycleTail
+            .catch(() => undefined)
+            .then(async () => {
+            if (signal.aborted) {
+                throw abortError(signal);
+            }
+            return await run();
+        });
+        this.sessionLifecycleTail = current.then(() => undefined, () => undefined);
+        return await raceWithAbort(current, signal);
+    }
+    async getRuntime(signal) {
+        if (this.stopped) {
+            throw new model_runner_js_1.ModelRunnerError('Cline Hub adapter is stopped', 'crash', false);
+        }
+        if (!this.runtimePromise) {
+            const pending = this.runtimeFactory({
+                command: this.options.command ?? 'cline',
+                cwd: this.options.cwd ?? process.cwd(),
+                dataDir: this.options.dataDir,
+                provider: this.options.provider ?? 'cline',
+            });
+            this.runtimePromise = pending;
+            void pending.catch(() => {
+                if (this.runtimePromise === pending) {
+                    this.runtimePromise = null;
+                }
+            });
+        }
+        const pending = this.runtimePromise;
+        this.runtimeWaiters += 1;
+        try {
+            const runtime = await raceWithAbort(pending, signal);
+            if (this.stopped) {
+                void this.disposeRuntimeOnce(runtime, 'mama_shutdown').catch(() => undefined);
+                throw new model_runner_js_1.ModelRunnerError('Cline Hub adapter is stopped', 'crash', false);
+            }
+            return runtime;
+        }
+        catch (error) {
+            if (signal.aborted && this.runtimePromise === pending && this.runtimeWaiters === 1) {
+                this.runtimePromise = null;
+                void pending
+                    .then((runtime) => this.disposeRuntimeOnce(runtime, 'mama_request_deadline'))
+                    .catch(() => undefined);
+            }
+            throw error;
+        }
+        finally {
+            this.runtimeWaiters -= 1;
+        }
+    }
+    async abortRoute(routeId, reason) {
+        const pendingRuntime = this.runtimePromise;
+        const session = this.sessions.get(routeId);
+        if (!pendingRuntime || !session) {
+            return;
+        }
+        const runtime = await pendingRuntime.catch(() => null);
+        await runtime?.client.abort(session.hubSessionId, reason).catch(() => undefined);
+    }
+    async quarantineRoute(routeId) {
+        const session = this.sessions.get(routeId);
+        if (!session) {
+            return;
+        }
+        if (this.sessions.get(routeId) === session) {
+            this.sessions.delete(routeId);
+            this.removeStableRoute(routeId);
+            this.markRouteForRebuild(routeId);
+        }
+        const pendingRuntime = this.runtimePromise;
+        if (pendingRuntime) {
+            void pendingRuntime
+                .then((runtime) => runtime.client.stop(session.hubSessionId))
+                .catch(() => undefined);
+        }
+    }
+    async disposeRuntimeOnce(runtime, reason) {
+        if (this.disposedRuntimes.has(runtime)) {
+            return;
+        }
+        this.disposedRuntimes.add(runtime);
+        await runtime.client.dispose(reason);
+    }
+    async runHubPrompt(routeId, stableRouteId, content, callbacks, promptOptions, deadlineSignal, timeoutMs) {
+        const runtime = await this.getRuntime(deadlineSignal);
+        const model = promptOptions?.model ?? this.options.model;
+        if (!model) {
+            throw new model_runner_js_1.ModelRunnerError('Cline model is required', 'auth_failure', false);
+        }
+        if (!runtime.apiKey && (this.options.provider ?? 'cline') === 'cline') {
+            const unauthenticatedRuntime = this.runtimePromise;
+            this.runtimePromise = null;
+            if (unauthenticatedRuntime) {
+                void this.disposeRuntimeOnce(runtime, 'mama_auth_reload').catch(() => undefined);
+            }
+            throw new model_runner_js_1.ModelRunnerError('Cline credentials are unavailable. Run: cline auth cline', 'auth_failure', false);
+        }
+        const previousRouteId = this.stableRoutes.get(stableRouteId);
+        if (previousRouteId && previousRouteId !== routeId) {
+            const previousSession = this.sessions.get(previousRouteId);
+            if (previousSession) {
+                await raceWithAbort(runtime.client.stop(previousSession.hubSessionId).catch(() => undefined), deadlineSignal);
+                this.sessions.delete(previousRouteId);
+            }
+        }
+        const requestedPolicy = promptOptions?.sessionPolicyFingerprint;
+        const allowedTools = promptOptions?.allowedTools ?? this.options.allowedTools ?? [];
+        const disallowedTools = promptOptions?.disallowedTools ?? this.options.disallowedTools ?? [];
+        const allowSpawnAgent = promptOptions?.allowSpawnAgent ?? this.options.allowSpawnAgent ?? false;
+        const allowAgentTeams = promptOptions?.allowAgentTeams ?? this.options.allowAgentTeams ?? false;
+        const requestedToolFingerprint = toolFingerprint(promptOptions?.hostToolBridge, allowedTools, disallowedTools, allowSpawnAgent, allowAgentTeams);
+        let session = this.sessions.get(routeId);
+        const mappedSessionWasMissing = session !== undefined &&
+            !(await raceWithAbort(runtime.client.get(session.hubSessionId), deadlineSignal));
+        if (mappedSessionWasMissing) {
+            this.sessions.delete(routeId);
+            this.removeStableRoute(routeId);
+            session = undefined;
+        }
+        const incompatibleSession = session &&
+            (promptOptions?.resumeSession === false ||
+                session.model !== model ||
+                session.policyFingerprint !== requestedPolicy ||
+                session.toolFingerprint !== requestedToolFingerprint)
+            ? session
+            : undefined;
+        let systemPrompt = promptOptions?.systemPrompt ?? this.systemPrompt;
+        if (mappedSessionWasMissing && promptOptions?.resumeInstructions) {
+            systemPrompt = await raceWithAbort(promptOptions.resumeInstructions(), deadlineSignal);
+        }
+        if (incompatibleSession) {
+            await raceWithAbort(runtime.client.stop(incompatibleSession.hubSessionId).catch(() => undefined), deadlineSignal);
+            this.sessions.delete(routeId);
+            this.removeStableRoute(routeId);
+            session = undefined;
+            if (promptOptions?.resumeInstructions) {
+                systemPrompt = await raceWithAbort(promptOptions.resumeInstructions(), deadlineSignal);
+            }
+        }
+        if (!session &&
+            promptOptions?.resumeSession !== false &&
+            this.routesRequiringRebuild.has(routeId) &&
+            promptOptions?.resumeInstructions) {
+            systemPrompt = await raceWithAbort(promptOptions.resumeInstructions(), deadlineSignal);
+        }
+        if (!session) {
+            session = await this.withSessionLifecycleLock(deadlineSignal, async () => {
+                const existingSession = this.sessions.get(routeId);
+                if (existingSession) {
+                    return existingSession;
+                }
+                await this.retireStaleSessions(runtime, routeId, deadlineSignal);
+                if (this.sessions.size >= this.maxSessions) {
+                    throw new model_runner_js_1.ModelRunnerError('Cline Hub session capacity is fully active; retry after an active request completes', 'crash', true);
+                }
+                const createdSession = await this.startHubSession(runtime, routeId, model, systemPrompt, requestedPolicy, promptOptions?.hostToolBridge, requestedToolFingerprint, promptOptions?.requestTimeout, allowedTools, disallowedTools, allowSpawnAgent, allowAgentTeams, deadlineSignal);
+                this.sessions.set(routeId, createdSession);
+                return createdSession;
+            });
+        }
+        this.stableRoutes.set(stableRouteId, routeId);
+        this.routesRequiringRebuild.delete(routeId);
+        session.lastActiveAt = Date.now();
+        const attemptController = new AbortController();
+        const ownerSignal = promptOptions?.toolExecutionContext?.signal;
+        const pendingTools = new Map();
+        const attempt = {
+            bridge: promptOptions?.hostToolBridge,
+            controller: attemptController,
+            signal: combineSignals(ownerSignal, attemptController.signal, deadlineSignal),
+            completed: new Map(),
+            pendingTools,
+            claimedToolCallIds: new Set(),
+            executedToolCallIds: new Set(),
+            inFlightTools: new Set(),
+        };
+        session.activeAttempt = attempt;
+        const unsubscribe = runtime.client.subscribe((event) => this.processHubEvent(event, session, attempt, pendingTools, callbacks), { sessionId: session.hubSessionId });
+        const abortOwner = () => {
+            const error = new model_runner_js_1.ModelRunnerError('Cline Hub request was aborted by its owner', 'unknown');
+            attemptController.abort(error);
+            void runtime.client.abort(session.hubSessionId, error).catch(() => undefined);
+        };
+        ownerSignal?.addEventListener('abort', abortOwner, { once: true });
+        try {
+            if (ownerSignal?.aborted) {
+                abortOwner();
+                throw new model_runner_js_1.ModelRunnerError('Cline Hub request was aborted by its owner', 'unknown');
+            }
+            const rawResult = await raceWithAbort(runtime.client.send({ sessionId: session.hubSessionId, prompt: content, timeoutMs }), deadlineSignal);
+            const result = parseAgentResult(rawResult);
+            const completedToolExchanges = [...attempt.completed.values()];
+            const completedTerminal = attempt.terminalResult?.terminalCode && attempt.terminalResult.abort
+                ? {
+                    code: attempt.terminalResult.terminalCode,
+                    message: attempt.terminalResult.content,
+                }
+                : (0, completed_terminal_result_js_1.completedCodeActTerminalError)(completedToolExchanges);
+            if (!completedTerminal && (attempt.terminalResult?.abort || attempt.terminalResult?.stop)) {
+                throw new model_runner_js_1.HostToolAbortError('MAMA host tool aborted the active Cline run', completedToolExchanges);
+            }
+            if (result.finishReason !== 'completed') {
+                const failure = safeProviderFailure(result.text.trim(), result.finishReason);
+                throw new model_runner_js_1.ModelRunnerError(failure.message, failure.code, failure.code !== 'auth_failure');
+            }
+            const unresolvedCodeActIds = [...pendingTools.values()]
+                .filter((toolUse) => toolUse.name === CLINE_CODE_ACT_TOOL_NAME)
+                .map((toolUse) => toolUse.id);
+            if (unresolvedCodeActIds.length > 0) {
+                throw new types_js_1.McpResultMissingError(unresolvedCodeActIds);
+            }
+            const promptResult = {
+                response: result.text,
+                session_id: session.hubSessionId,
+                cost_usd: result.usage?.totalCost,
+                duration_ms: result.durationMs,
+                usage: {
+                    input_tokens: result.usage?.inputTokens ?? 0,
+                    output_tokens: result.usage?.outputTokens ?? 0,
+                    cache_creation_input_tokens: result.usage?.cacheWriteTokens,
+                    cache_read_input_tokens: result.usage?.cacheReadTokens,
+                },
+                hasToolUse: false,
+                completedToolExchanges,
+                ...(completedTerminal ? { terminalError: completedTerminal } : {}),
+            };
+            if (completedTerminal) {
+                callbacks?.onError?.(new model_runner_js_1.HostToolTerminalError(completedTerminal.code, completedTerminal.message, completedToolExchanges));
+            }
+            else {
+                callbacks?.onFinal?.({ content: result.text, toolUseBlocks: [] });
+            }
+            return promptResult;
+        }
+        catch (error) {
+            const inFlightAtInterruption = [...attempt.inFlightTools];
+            if (inFlightAtInterruption.length > 0) {
+                if (!attempt.signal.aborted) {
+                    attemptController.abort(error instanceof Error
+                        ? error
+                        : new model_runner_js_1.ModelRunnerError('Cline Hub tool transport was interrupted', 'crash', false));
+                }
+                await this.waitForToolSettlement(inFlightAtInterruption);
+            }
+            const completedToolExchanges = [...attempt.completed.values()];
+            const completedTerminal = attempt.terminalResult?.terminalCode && attempt.terminalResult.abort
+                ? {
+                    code: attempt.terminalResult.terminalCode,
+                    message: attempt.terminalResult.content,
+                }
+                : (0, completed_terminal_result_js_1.completedCodeActTerminalError)(completedToolExchanges);
+            if (completedTerminal) {
+                throw new model_runner_js_1.HostToolTerminalError(completedTerminal.code, completedTerminal.message, completedToolExchanges);
+            }
+            if (attempt.terminalResult?.abort || attempt.terminalResult?.stop) {
+                throw new model_runner_js_1.HostToolAbortError('MAMA host tool aborted the active Cline run', completedToolExchanges);
+            }
+            if ((0, completed_terminal_result_js_1.completedCodeActMutationWasObserved)(completedToolExchanges)) {
+                throw new types_js_1.McpCompletedMutationInterruptedError(completedToolExchanges);
+            }
+            if (inFlightAtInterruption.length > 0) {
+                const unresolvedIds = [...attempt.pendingTools.values()]
+                    .filter((toolUse) => toolUse.name === CLINE_CODE_ACT_TOOL_NAME)
+                    .map((toolUse) => toolUse.id);
+                throw new types_js_1.McpResultMissingError(unresolvedIds.length > 0 ? unresolvedIds : [...attempt.claimedToolCallIds]);
+            }
+            throw error;
+        }
+        finally {
+            ownerSignal?.removeEventListener('abort', abortOwner);
+            unsubscribe();
+            if (session.activeAttempt === attempt) {
+                session.activeAttempt = undefined;
+            }
+            if (attempt.signal.aborted) {
+                if (this.sessions.get(routeId) === session) {
+                    this.sessions.delete(routeId);
+                    this.removeStableRoute(routeId);
+                    this.markRouteForRebuild(routeId);
+                }
+                void runtime.client.stop(session.hubSessionId).catch(() => undefined);
+            }
+        }
+    }
+    async waitForToolSettlement(inFlight) {
+        let timeoutHandle;
+        const timeout = new Promise((resolvePromise) => {
+            timeoutHandle = setTimeout(resolvePromise, CLINE_MUTATION_SETTLEMENT_GRACE_MS);
+            timeoutHandle.unref();
+        });
+        await Promise.race([Promise.all(inFlight).then(() => undefined), timeout]);
+        if (timeoutHandle) {
+            clearTimeout(timeoutHandle);
+        }
+    }
+    async startHubSession(runtime, routeId, model, systemPrompt, policyFingerprint, bridge, projectedToolFingerprint, requestTimeout, allowedTools, disallowedTools, allowSpawnAgent, allowAgentTeams, deadlineSignal) {
+        const session = {
+            routeId,
+            hubSessionId: '',
+            model,
+            policyFingerprint,
+            toolFingerprint: projectedToolFingerprint,
+            lastActiveAt: Date.now(),
+        };
+        const tools = (bridge?.tools ?? []).map((definition) => this.createProjectedTool(runtime, session, definition, requestTimeout));
+        const provider = this.options.provider ?? 'cline';
+        const cwd = this.options.cwd ?? process.cwd();
+        const toolPolicies = buildToolPolicies(bridge, allowedTools, disallowedTools);
+        const hasProjectedTools = (bridge?.tools.length ?? 0) > 0;
+        const hasNativeTools = allowedTools.includes('*') || allowedTools.length > 0;
+        const startPromise = runtime.client.start({
+            source: runtime.source,
+            interactive: true,
+            config: {
+                providerId: provider,
+                modelId: model,
+                apiKey: runtime.apiKey,
+                cwd,
+                workspaceRoot: cwd,
+                systemPrompt,
+                enableTools: hasNativeTools || hasProjectedTools,
+                enableSpawnAgent: allowSpawnAgent,
+                enableAgentTeams: allowAgentTeams,
+                disableMcpSettingsTools: !allowedTools.includes('*') && !allowedTools.some(cline_native_tool_policy_js_1.isClineMcpToolGrant),
+                toolPolicies,
+            },
+            localRuntime: { extraTools: tools },
+            sessionMetadata: {
+                source: 'mama-os',
+                routeId,
+                policyFingerprint,
+            },
+        });
+        let started;
+        try {
+            started = await raceWithAbort(startPromise, deadlineSignal);
+        }
+        catch (error) {
+            if (deadlineSignal.aborted) {
+                void startPromise
+                    .then((lateSession) => runtime.client.stop(lateSession.sessionId))
+                    .catch(() => undefined);
+            }
+            throw error;
+        }
+        if (!started.sessionId?.trim()) {
+            throw new Error('Cline Hub returned an empty session id');
+        }
+        session.hubSessionId = started.sessionId.trim();
+        return session;
+    }
+    createProjectedTool(runtime, session, definition, requestTimeout) {
+        const exposedName = definition.name === MAMA_CODE_ACT_TOOL_NAME ? CLINE_CODE_ACT_TOOL_NAME : definition.name;
+        return runtime.createTool({
+            name: exposedName,
+            description: definition.description,
+            inputSchema: { ...definition.inputSchema },
+            timeoutMs: Math.max(requestTimeout ?? this.options.requestTimeout ?? 600_000, 310_000),
+            retryable: false,
+            maxRetries: 0,
+            execute: async (input, context) => {
+                const attempt = session.activeAttempt;
+                const bridge = attempt?.bridge;
+                if (!attempt || !bridge) {
+                    throw new Error(`MAMA bridge is not active for Cline session ${session.hubSessionId}`);
+                }
+                if (attempt.terminalResult?.abort ||
+                    attempt.terminalResult?.stop ||
+                    attempt.terminalResult?.terminalCode) {
+                    throw new Error('MAMA host-tool attempt is already sealed');
+                }
+                const streamedToolUse = [...attempt.pendingTools.values()].find((toolUse) => toolUse.name === exposedName && !attempt.claimedToolCallIds.has(toolUse.id));
+                const callId = context.toolCallId?.trim() || streamedToolUse?.id || (0, node_crypto_1.randomUUID)();
+                attempt.claimedToolCallIds.add(callId);
+                const signal = combineSignals(context.signal, attempt.signal);
+                let settleTool = () => undefined;
+                const settlement = new Promise((resolvePromise) => {
+                    settleTool = resolvePromise;
+                });
+                attempt.inFlightTools.add(settlement);
+                try {
+                    const result = await bridge.execute({
+                        callId,
+                        name: definition.name,
+                        input,
+                        signal,
+                    });
+                    attempt.executedToolCallIds.add(callId);
+                    const exchange = {
+                        toolUse: {
+                            type: 'tool_use',
+                            id: callId,
+                            name: exposedName,
+                            input,
+                        },
+                        toolResult: {
+                            type: 'tool_result',
+                            tool_use_id: callId,
+                            content: result.content,
+                            is_error: result.isError,
+                        },
+                    };
+                    attempt.completed.set(callId, exchange);
+                    if (result.terminalCode || result.abort || result.stop) {
+                        attempt.terminalResult = result;
+                        void runtime.client
+                            .abort(session.hubSessionId, new Error('MAMA host tool sealed run'))
+                            .catch(() => undefined);
+                    }
+                    if (result.isError) {
+                        throw new Error('MAMA projected tool returned an error');
+                    }
+                    return result.content;
+                }
+                finally {
+                    settleTool();
+                    attempt.inFlightTools.delete(settlement);
+                }
+            },
+        });
+    }
+    processHubEvent(raw, session, attempt, pendingTools, callbacks) {
+        if (!isRecord(raw) || raw.type !== 'agent_event' || !isRecord(raw.payload)) {
+            return;
+        }
+        if (stringValue(raw.payload, 'sessionId') !== session.hubSessionId ||
+            !isRecord(raw.payload.event)) {
+            return;
+        }
+        const event = raw.payload.event;
+        const eventType = stringValue(event, 'type');
+        const contentType = stringValue(event, 'contentType');
+        if (eventType === 'content_start' && contentType === 'text') {
+            const text = stringValue(event, 'text');
+            if (text) {
+                callbacks?.onDelta?.(text);
+            }
+            return;
+        }
+        if (contentType !== 'tool') {
+            return;
+        }
+        const toolCallId = stringValue(event, 'toolCallId');
+        if (!toolCallId) {
+            return;
+        }
+        if (eventType === 'content_start') {
+            const toolName = stringValue(event, 'toolName');
+            if (!toolName) {
+                return;
+            }
+            const input = isRecord(event.input) ? event.input : {};
+            pendingTools.set(toolCallId, {
+                type: 'tool_use',
+                id: toolCallId,
+                name: toolName,
+                input,
+            });
+            callbacks?.onToolUse?.(toolName, input);
+            return;
+        }
+        if (eventType !== 'content_end') {
+            return;
+        }
+        const toolUse = pendingTools.get(toolCallId);
+        if (!toolUse) {
+            return;
+        }
+        const isError = typeof event.error === 'string' && event.error.length > 0;
+        if (attempt.executedToolCallIds.has(toolCallId) && !attempt.completed.has(toolCallId)) {
+            attempt.completed.set(toolCallId, {
+                toolUse,
+                toolResult: {
+                    type: 'tool_result',
+                    tool_use_id: toolCallId,
+                    content: normalizeToolOutput(isError ? event.error : event.output),
+                    is_error: isError,
+                },
+            });
+        }
+        pendingTools.delete(toolCallId);
+        attempt.claimedToolCallIds.delete(toolCallId);
+        callbacks?.onToolComplete?.(toolUse.name, toolCallId, isError);
+    }
+    removeStableRoute(routeId) {
+        for (const [stableRouteId, mappedRouteId] of this.stableRoutes) {
+            if (mappedRouteId === routeId) {
+                this.stableRoutes.delete(stableRouteId);
+            }
+        }
+    }
+    markRouteForRebuild(routeId) {
+        this.routesRequiringRebuild.delete(routeId);
+        this.routesRequiringRebuild.add(routeId);
+        while (this.routesRequiringRebuild.size > this.maxSessions) {
+            const oldest = this.routesRequiringRebuild.values().next().value;
+            if (!oldest) {
+                break;
+            }
+            this.routesRequiringRebuild.delete(oldest);
+        }
+    }
+    async retireRoute(runtime, routeId, signal) {
+        const session = this.sessions.get(routeId);
+        if (!session) {
+            return;
+        }
+        await raceWithAbort(runtime.client.stop(session.hubSessionId).catch(() => undefined), signal);
+        this.sessions.delete(routeId);
+        this.removeStableRoute(routeId);
+    }
+    async retireStaleSessions(runtime, protectedRouteId, signal) {
+        const expiry = Date.now() - this.sessionTtlMs;
+        const expired = [...this.sessions.entries()]
+            .filter(([routeId, session]) => routeId !== protectedRouteId &&
+            !this.activeRoutes.has(routeId) &&
+            !session.activeAttempt &&
+            session.lastActiveAt < expiry)
+            .map(([routeId]) => routeId);
+        for (const routeId of expired) {
+            await this.retireRoute(runtime, routeId, signal);
+        }
+        if (this.sessions.has(protectedRouteId)) {
+            return;
+        }
+        while (this.sessions.size >= this.maxSessions) {
+            const oldest = [...this.sessions.entries()]
+                .filter(([routeId, session]) => !this.activeRoutes.has(routeId) && !session.activeAttempt)
+                .sort((left, right) => left[1].lastActiveAt - right[1].lastActiveAt)[0]?.[0];
+            if (!oldest) {
+                return;
+            }
+            await this.retireRoute(runtime, oldest, signal);
+        }
+    }
+    normalizeError(error) {
+        if (error instanceof model_runner_js_1.ModelRunnerError ||
+            error instanceof model_runner_js_1.HostToolAbortError ||
+            error instanceof model_runner_js_1.HostToolTerminalError ||
+            error instanceof types_js_1.McpCompletedMutationInterruptedError ||
+            error instanceof types_js_1.McpResultMissingError) {
+            return error;
+        }
+        const rawMessage = error instanceof Error ? error.message : String(error);
+        const failure = safeProviderFailure(rawMessage, 'exception');
+        return new model_runner_js_1.ModelRunnerError(failure.message, failure.code, failure.code !== 'auth_failure');
+    }
+    getSessionPolicyStatus(options) {
+        const routeId = options.sessionId ?? options.sessionKey ?? this.sessionId;
+        const session = this.sessions.get(routeId);
+        if (!session) {
+            return 'missing';
+        }
+        const allowedTools = options.allowedTools ?? this.options.allowedTools ?? [];
+        const disallowedTools = options.disallowedTools ?? this.options.disallowedTools ?? [];
+        return session.policyFingerprint === options.sessionPolicyFingerprint &&
+            session.toolFingerprint ===
+                toolFingerprint(options.hostToolBridge, allowedTools, disallowedTools, options.allowSpawnAgent ?? this.options.allowSpawnAgent ?? false, options.allowAgentTeams ?? this.options.allowAgentTeams ?? false)
+            ? 'compatible'
+            : 'mismatch';
+    }
+    setSessionId(id) {
+        this.sessionId = id;
+    }
+    setSystemPrompt(prompt) {
+        this.systemPrompt = prompt;
+    }
+    async sendMessage(content, callbacks) {
+        return this.prompt(content, callbacks, { resumeSession: true });
+    }
+    getSessionId() {
+        return this.sessionId;
+    }
+    isHealthy() {
+        return !this.stopped;
+    }
+    isReady() {
+        return !this.stopped;
+    }
+    getMetrics() {
+        return {
+            requestCount: this.requestCount,
+            failureCount: this.failureCount,
+            avgLatencyMs: this.requestCount > 0 ? Math.round(this.totalLatencyMs / this.requestCount) : 0,
+            lastRequestAt: this.lastRequestAt,
+        };
+    }
+    async stop() {
+        if (this.stopped) {
+            return;
+        }
+        this.stopped = true;
+        const pendingRuntime = this.runtimePromise;
+        const runtime = pendingRuntime ? await this.waitForCleanup(pendingRuntime, 1_000, null) : null;
+        if (!runtime) {
+            this.sessions.clear();
+            this.stableRoutes.clear();
+            this.routesRequiringRebuild.clear();
+            if (pendingRuntime) {
+                void pendingRuntime
+                    .then((lateRuntime) => this.disposeRuntimeOnce(lateRuntime, 'mama_shutdown'))
+                    .catch(() => undefined);
+            }
+            return;
+        }
+        const sessions = [...this.sessions.values()];
+        const shutdownError = new model_runner_js_1.ModelRunnerError('Cline Hub adapter is shutting down', 'crash', false);
+        for (const session of sessions) {
+            session.activeAttempt?.controller.abort(shutdownError);
+            if (session.activeAttempt) {
+                void runtime.client.abort(session.hubSessionId, shutdownError).catch(() => undefined);
+            }
+        }
+        const inFlight = sessions.flatMap((session) => [
+            ...(session.activeAttempt?.inFlightTools ?? []),
+        ]);
+        if (inFlight.length > 0) {
+            await this.waitForToolSettlement(inFlight);
+        }
+        this.sessions.clear();
+        this.stableRoutes.clear();
+        this.routesRequiringRebuild.clear();
+        this.activeRoutes.clear();
+        void Promise.allSettled(sessions.map((session) => runtime.client.stop(session.hubSessionId)));
+        await this.waitForCleanup(this.disposeRuntimeOnce(runtime, 'mama_shutdown'), 1_000, undefined);
+    }
+    async waitForCleanup(operation, timeoutMs, fallback) {
+        let timeoutHandle;
+        const timeout = new Promise((resolvePromise) => {
+            timeoutHandle = setTimeout(() => resolvePromise(fallback), timeoutMs);
+            timeoutHandle.unref();
+        });
+        const result = await Promise.race([operation, timeout]);
+        if (timeoutHandle) {
+            clearTimeout(timeoutHandle);
+        }
+        return result;
+    }
+}
+exports.ClineCLIAdapter = ClineCLIAdapter;
+//# sourceMappingURL=cline-cli-adapter.js.map