ladder-mcp 1.0.0

package/dist/index.js

@@ -0,0 +1,289 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { getKimiStatus } from './environment.js';
+import { runKimiApi, isApiConfigured } from './kimi-api.js';
+import { runKimi } from './kimi-runner.js';
+import { listSessions } from './session-store.js';
+import { cancelAcpSession, listAcpSessions, runAcpPrompt } from './transports/acp.js';
+import { exportKimiSession, getKimiCapabilities, listKimiProviders, runKimiDoctor, visualizeSession, } from './transports/cli-admin.js';
+import { taskStore } from './task-store.js';
+import { generateMcpConfig } from './kimi-mcp-config.js';
+import { buildBudgetProbeGuide, getDesktopStatus } from './desktop-work.js';
+const server = new McpServer({
+    name: 'kimi-code',
+    version: '1.0.0',
+});
+const DEFAULT_MAX_OUTPUT_CHARS = 60_000;
+const FORMAT_INSTRUCTIONS = {
+    summary: `
+OUTPUT FORMAT CONSTRAINTS:
+- Maximum ~2000 words. Be extremely concise.
+- Use bullet points, not paragraphs.
+- List file paths and one-line descriptions only.
+- No code snippets.
+- Structure: ## Overview -> ## Key Findings -> ## File Index`,
+    normal: `
+OUTPUT FORMAT CONSTRAINTS:
+- Maximum ~5000 words. Be concise but thorough.
+- Use structured sections with markdown headers.
+- Include function/class signatures, not full implementations.
+- Reference file paths and line numbers when useful.
+- Structure: ## Overview -> ## Architecture -> ## Key Findings -> ## File Details`,
+    detailed: `
+OUTPUT FORMAT CONSTRAINTS:
+- Maximum ~15000 words.
+- Include relevant snippets only when they materially help.
+- Explain dependency relationships and data flow.`,
+};
+const AI_CONSUMER_NOTICE = `
+IMPORTANT: Your response will be consumed by another AI model with limited context. Prioritize density, concrete file references, and structured markdown.`;
+function wrapPrompt(prompt, detailLevel) {
+    return `${prompt}\n${FORMAT_INSTRUCTIONS[detailLevel]}\n${AI_CONSUMER_NOTICE}`;
+}
+function maxChars(maxOutputTokens) {
+    return maxOutputTokens ? maxOutputTokens * 4 : DEFAULT_MAX_OUTPUT_CHARS;
+}
+function textResponse(text, isError = false) {
+    return { content: [{ type: 'text', text }], isError };
+}
+function buildResponse(text, thinking, includeThinking) {
+    return thinking && includeThinking ? `<kimi-thinking>\n${thinking}\n</kimi-thinking>\n\n${text}` : text;
+}
+server.tool('kimi_analyze', 'Send a prompt to Kimi Code for codebase analysis. Defaults to native continuation for the working directory; set new_session to true for a fresh session.', {
+    prompt: z.string().describe('The analysis prompt for Kimi.'),
+    work_dir: z.string().describe('Absolute path to the codebase root directory.'),
+    session_id: z.string().optional().describe('Explicit Kimi session id to resume via -S.'),
+    new_session: z.boolean().optional().describe('Start fresh without -C or -S. Default: false.'),
+    detail_level: z.enum(['summary', 'normal', 'detailed']).optional(),
+    max_output_tokens: z.number().optional(),
+    include_thinking: z.boolean().optional(),
+}, async ({ prompt, work_dir, session_id, new_session, detail_level, max_output_tokens, include_thinking }) => {
+    const result = await runKimi({
+        prompt: wrapPrompt(prompt, detail_level ?? 'normal'),
+        workDir: work_dir,
+        sessionId: session_id,
+        continueLast: !session_id && new_session !== true,
+        timeoutMs: 600_000,
+        maxOutputChars: maxChars(max_output_tokens),
+        includeThinking: include_thinking ?? false,
+    });
+    if (!result.ok)
+        return textResponse(`Error: ${result.error}`, true);
+    const sessionLine = result.sessionId ? `\n\nSession: ${result.sessionId}` : '';
+    return textResponse(`${buildResponse(result.text, result.thinking, include_thinking ?? false)}${sessionLine}`);
+});
+server.tool('kimi_query', 'Ask Kimi Code a contextless programming question through the Kimi Code API.', {
+    prompt: z.string().describe('The question to ask Kimi.'),
+    max_output_tokens: z.number().optional(),
+    include_thinking: z.boolean().optional(),
+}, async ({ prompt, max_output_tokens, include_thinking }) => {
+    const result = await runKimiApi({ prompt, timeoutMs: 120_000, maxOutputChars: maxChars(max_output_tokens) });
+    if (!result.ok)
+        return textResponse(`Error: ${result.error}`, true);
+    return textResponse(buildResponse(result.text, result.thinking, include_thinking ?? false));
+});
+server.tool('kimi_verify', 'Get an independent second opinion from Kimi Code through the Kimi Code API.', {
+    context: z.string().describe('Self-contained material for Kimi to examine.'),
+    question: z.string().optional().describe('What to verify or focus on.'),
+    role: z.string().optional().describe('Override the reviewer persona.'),
+    max_output_tokens: z.number().optional(),
+    include_thinking: z.boolean().optional(),
+}, async ({ context, question, role, max_output_tokens, include_thinking }) => {
+    const focus = question?.trim() || 'Independently verify correctness. Surface bugs, edge cases, security issues, and concrete improvements.';
+    const system = role?.trim() || 'You are a meticulous, independent senior engineer. Be skeptical, specific, and actionable.';
+    const prompt = `## Your task\n${focus}\n\n## Material to verify\n${context}\n${AI_CONSUMER_NOTICE}`;
+    const result = await runKimiApi({ prompt, system, timeoutMs: 300_000, maxOutputChars: maxChars(max_output_tokens) });
+    if (!result.ok)
+        return textResponse(`Error: ${result.error}`, true);
+    return textResponse(buildResponse(result.text, result.thinking, include_thinking ?? false));
+});
+server.tool('kimi_resume', 'Resume an explicit Kimi Code session with a new prompt via -S.', {
+    session_id: z.string().describe('Session ID to resume.'),
+    prompt: z.string().describe('New prompt to send.'),
+    work_dir: z.string().describe('Working directory for the session.'),
+    detail_level: z.enum(['summary', 'normal', 'detailed']).optional(),
+    max_output_tokens: z.number().optional(),
+    include_thinking: z.boolean().optional(),
+}, async ({ session_id, prompt, work_dir, detail_level, max_output_tokens, include_thinking }) => {
+    const result = await runKimi({
+        prompt: wrapPrompt(prompt, detail_level ?? 'normal'),
+        workDir: work_dir,
+        sessionId: session_id,
+        timeoutMs: 600_000,
+        maxOutputChars: maxChars(max_output_tokens),
+        includeThinking: include_thinking ?? false,
+    });
+    if (!result.ok)
+        return textResponse(`Error: ${result.error}`, true);
+    return textResponse(buildResponse(result.text, result.thinking, include_thinking ?? false));
+});
+server.tool('kimi_list_sessions', 'List existing Kimi Code sessions with ids, titles, working directories, and timestamps.', {
+    work_dir: z.string().optional().describe('Filter sessions by working directory path.'),
+    limit: z.number().optional().describe('Max sessions to return. Default: 20.'),
+}, async ({ work_dir, limit }) => {
+    const sessions = listSessions({ workDir: work_dir, limit: limit ?? 20 });
+    return textResponse(sessions.length ? JSON.stringify(sessions, null, 2) : 'No Kimi sessions found.');
+});
+server.tool('kimi_status', 'Check Kimi CLI installation, version, authentication, catalog, and API availability.', {}, async () => {
+    const status = await getKimiStatus();
+    const lines = [
+        '## Kimi CLI Status',
+        `- Installed: ${status.installed ? 'Yes' : 'No'}`,
+        `- Binary: ${status.binPath ? `\`${status.binPath}\`` : 'Not found'}`,
+        `- Version: ${status.version ?? '(unable to detect)'}`,
+        `- Authenticated: ${status.authenticated ? 'Yes' : 'No'}`,
+        `- Catalog Found: ${status.catalogFound ? 'Yes' : 'No'}`,
+        `- Catalog: \`${status.catalogPath}\``,
+        `- Credentials Found: ${status.credentialsFound ? 'Yes' : 'No'}`,
+        `- Config Found: ${status.configFound ? 'Yes' : 'No'}`,
+        '',
+        '## Kimi Code API',
+        `- Configured: ${isApiConfigured() ? 'Yes' : 'No'}`,
+    ];
+    if (status.error)
+        lines.push('', `Action required: ${status.error}`);
+    return textResponse(lines.join('\n'), !status.installed && !status.apiConfigured);
+});
+server.tool('kimi_capabilities', 'Report Kimi CLI, admin command, ACP, and experimental desktop-read-only capabilities.', {}, async () => textResponse(JSON.stringify(await getKimiCapabilities(), null, 2)));
+server.tool('kimi_doctor', 'Run Kimi Code configuration doctor for config.toml or tui.toml.', {
+    target: z.enum(['config', 'tui']).optional(),
+    path: z.string().optional().describe('Optional config/tui path to validate.'),
+}, async ({ target, path }) => {
+    const result = await runKimiDoctor(target ?? 'config', path);
+    return textResponse(JSON.stringify(result, null, 2), !result.ok);
+});
+server.tool('kimi_provider_list', 'List configured Kimi providers and models using `kimi provider list --json`.', {}, async () => textResponse(JSON.stringify(await listKimiProviders(), null, 2)));
+server.tool('kimi_export_session', 'Export a Kimi session ZIP. Requires explicit output_path and excludes the global diagnostic log by default.', {
+    output_path: z.string().describe('Explicit ZIP output path.'),
+    session_id: z.string().optional().describe('Session id to export; defaults to most recent Kimi session.'),
+    include_global_log: z.boolean().optional().describe('Include active global diagnostic log. Default: false.'),
+    overwrite_existing: z.boolean().optional().describe('Overwrite output_path if it already exists. Default: false.'),
+}, async ({ output_path, session_id, include_global_log, overwrite_existing }) => {
+    const result = await exportKimiSession({
+        outputPath: output_path,
+        sessionId: session_id,
+        includeGlobalLog: include_global_log ?? false,
+        overwriteExisting: overwrite_existing ?? false,
+    });
+    return textResponse(JSON.stringify(result, null, 2), !result.ok);
+});
+server.tool('kimi_visualize_session', 'Preview or launch Kimi session visualizer on localhost using `kimi vis --no-open`.', {
+    session_id: z.string().optional(),
+    host: z.enum(['127.0.0.1', 'localhost', '::1']).optional().describe('Localhost host to bind. Default: 127.0.0.1.'),
+    port: z.number().int().min(1).max(65535).optional().describe('Port to bind. Default: 58628.'),
+    launch: z.boolean().optional().describe('Actually start the visualizer process. Default: false.'),
+}, async ({ session_id, host, port, launch }) => {
+    try {
+        return textResponse(JSON.stringify(visualizeSession({ sessionId: session_id, host, port, launch }), null, 2));
+    }
+    catch (error) {
+        return textResponse(`Error: ${error instanceof Error ? error.message : String(error)}`, true);
+    }
+});
+server.tool('kimi_chat', 'Send a prompt through Kimi ACP over stdio. Set background=true for long-running work tracked by task tools.', {
+    prompt: z.string(),
+    work_dir: z.string().optional(),
+    session_id: z.string().optional(),
+    session_mode: z.enum(['new', 'load', 'resume']).optional(),
+    background: z.boolean().optional(),
+    timeout_ms: z.number().int().positive().optional(),
+}, async ({ prompt, work_dir, session_id, session_mode, background, timeout_ms }) => {
+    if (background) {
+        const task = taskStore.create('acp-chat', async (signal) => {
+            const result = await runAcpPrompt({
+                prompt,
+                workDir: work_dir,
+                sessionId: session_id,
+                sessionMode: session_mode ?? (session_id ? 'resume' : 'new'),
+                timeoutMs: timeout_ms,
+                signal,
+            });
+            if (!result.ok)
+                throw new Error(result.error ?? 'ACP chat failed');
+            const metadata = { ...(result.metadata ?? {}) };
+            if (!('sessionId' in metadata)) {
+                metadata.sessionId = result.sessionId;
+            }
+            return { output: result.text, metadata };
+        });
+        return textResponse(JSON.stringify(task, null, 2));
+    }
+    const result = await runAcpPrompt({
+        prompt,
+        workDir: work_dir,
+        sessionId: session_id,
+        sessionMode: session_mode ?? (session_id ? 'resume' : 'new'),
+        timeoutMs: timeout_ms,
+    });
+    return textResponse(JSON.stringify(result, null, 2), !result.ok);
+});
+server.tool('kimi_acp_sessions', 'List Kimi ACP sessions through `session/list`.', {}, async () => {
+    const result = await listAcpSessions();
+    return textResponse(result.ok ? result.text : `Error: ${result.error}`, !result.ok);
+});
+server.tool('kimi_cancel', 'Cancel an active Ladder task by task_id or a Kimi ACP session by session_id.', {
+    task_id: z.string().optional(),
+    session_id: z.string().optional(),
+}, async ({ task_id, session_id }) => {
+    // Require exactly one target. Previously, passing both silently cancelled the task
+    // and ignored session_id, hiding the ambiguity from the caller.
+    if (task_id && session_id) {
+        return textResponse('Provide either task_id or session_id, not both.', true);
+    }
+    if (task_id) {
+        const task = await taskStore.cancel(task_id);
+        return textResponse(task ? JSON.stringify(task, null, 2) : `Task not found: ${task_id}`, !task);
+    }
+    if (session_id) {
+        const result = await cancelAcpSession(session_id);
+        return textResponse(JSON.stringify(result, null, 2), !result.ok);
+    }
+    return textResponse('Provide task_id or session_id.', true);
+});
+server.tool('kimi_task_status', 'Return status for one background task or all recent in-process tasks.', {
+    task_id: z.string().optional(),
+}, async ({ task_id }) => {
+    if (task_id) {
+        const task = taskStore.get(task_id);
+        return textResponse(task ? JSON.stringify(task, null, 2) : `Task not found: ${task_id}`, !task);
+    }
+    return textResponse(JSON.stringify(taskStore.list(), null, 2));
+});
+server.tool('kimi_task_output', 'Return accumulated output and error for a background task.', {
+    task_id: z.string(),
+}, async ({ task_id }) => {
+    const task = taskStore.get(task_id);
+    return textResponse(task ? JSON.stringify({ id: task.id, status: task.status, output: task.output, outputChunks: task.outputChunks, error: task.error }, null, 2) : `Task not found: ${task_id}`, !task);
+});
+server.tool('kimi_task_cancel', 'Cancel a pending or running background task.', {
+    task_id: z.string(),
+}, async ({ task_id }) => {
+    const task = await taskStore.cancel(task_id);
+    return textResponse(task ? JSON.stringify(task, null, 2) : `Task not found: ${task_id}`, !task);
+});
+server.tool('kimi_generate_mcp_config', 'Generate or write a Kimi Code .kimi-code/mcp.json entry that lets Kimi host Ladder_mcp as an MCP server.', {
+    scope: z.enum(['project', 'user']).optional(),
+    project_dir: z.string().optional(),
+    server_name: z.string().optional(),
+    write: z.boolean().optional().describe('When false/omitted, only preview the merged config.'),
+    command: z.string().optional(),
+    args: z.array(z.string()).optional(),
+}, async ({ scope, project_dir, server_name, write, command, args }) => {
+    const result = generateMcpConfig({
+        scope,
+        projectDir: project_dir,
+        serverName: server_name,
+        write: write ?? false,
+        command,
+        args,
+    });
+    return textResponse(JSON.stringify(result, null, 2));
+});
+server.tool('kimi_desktop_status', 'Experimental read-only Kimi Desktop Work status probe. Does not read token stores or replay web auth.', {}, async () => textResponse(JSON.stringify(await getDesktopStatus(), null, 2)));
+server.tool('kimi_budget_probe', 'Experimental guided budget-separation evidence workflow. Does not submit desktop Work tasks.', {
+    include_cli_probe_note: z.boolean().optional(),
+}, async ({ include_cli_probe_note }) => textResponse(buildBudgetProbeGuide(include_cli_probe_note ?? false)));
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/dist/kimi-api.js

@@ -0,0 +1,72 @@
+import { loadApiAuth } from './environment.js';
+import { truncateAtBoundary } from './kimi-runner.js';
+const KIMI_USER_AGENT = 'KimiCLI/1.0';
+const DEFAULT_MODEL = 'kimi-for-coding';
+export function isApiConfigured() {
+    return loadApiAuth() !== null;
+}
+export async function runKimiApi(config) {
+    const auth = loadApiAuth();
+    if (!auth) {
+        return {
+            ok: false,
+            text: '',
+            error: 'Kimi Code API key not found. Set KIMICODE_API_KEY or add api_key to ~/.kimi-code/config.toml.',
+        };
+    }
+    const controller = new AbortController();
+    const timeoutMs = config.timeoutMs ?? 300_000;
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const maxOutputChars = config.maxOutputChars ?? 60_000;
+    const maxTokens = Math.ceil(maxOutputChars / 4) + 4000;
+    const messages = [];
+    if (config.system)
+        messages.push({ role: 'system', content: config.system });
+    messages.push({ role: 'user', content: config.prompt });
+    try {
+        const response = await fetch(`${auth.baseUrl}/chat/completions`, {
+            method: 'POST',
+            signal: controller.signal,
+            headers: {
+                Authorization: `Bearer ${auth.apiKey}`,
+                'Content-Type': 'application/json',
+                'User-Agent': KIMI_USER_AGENT,
+            },
+            body: JSON.stringify({
+                model: config.model ?? DEFAULT_MODEL,
+                messages,
+                temperature: 1,
+                max_tokens: maxTokens,
+            }),
+        });
+        const bodyText = await response.text();
+        if (!response.ok) {
+            let message = bodyText.slice(0, 400);
+            try {
+                const parsed = JSON.parse(bodyText);
+                message = parsed.error?.message ?? message;
+            }
+            catch {
+                // Keep raw body slice.
+            }
+            return { ok: false, text: '', error: `Kimi API HTTP ${response.status}: ${message}` };
+        }
+        const data = JSON.parse(bodyText);
+        const message = data.choices?.[0]?.message;
+        const text = message?.content?.trim() ?? '';
+        const thinking = message?.reasoning_content;
+        if (!text) {
+            return { ok: false, text: '', thinking, error: 'Kimi API returned an empty answer.' };
+        }
+        return { ok: true, text: truncateAtBoundary(text, maxOutputChars), thinking };
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === 'AbortError') {
+            return { ok: false, text: '', error: `Kimi API timed out after ${Math.round(timeoutMs / 1000)}s` };
+        }
+        return { ok: false, text: '', error: `Kimi API network error: ${error instanceof Error ? error.message : String(error)}` };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/dist/kimi-mcp-config.js

@@ -0,0 +1,85 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { getWindowsHome } from './environment.js';
+function defaultServerCommand() {
+    const distIndex = path.resolve(path.dirname(fileURLToPath(import.meta.url)), 'index.js');
+    return { command: 'node', args: [distIndex] };
+}
+export function resolveMcpConfigPath(options = {}) {
+    if (options.scope === 'user') {
+        return path.join(getWindowsHome(), '.kimi-code', 'mcp.json');
+    }
+    const projectDir = options.projectDir ? path.resolve(options.projectDir) : process.cwd();
+    return path.join(projectDir, '.kimi-code', 'mcp.json');
+}
+function readExistingConfig(configPath) {
+    let raw;
+    try {
+        raw = fs.readFileSync(configPath, 'utf-8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return {};
+        }
+        throw new Error(`Existing MCP config could not be read and was not modified: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        throw new Error(`Existing MCP config is not valid JSON and was not modified: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function assertWritableProjectTarget(projectDir) {
+    let resolved;
+    try {
+        resolved = fs.realpathSync(projectDir);
+    }
+    catch {
+        resolved = path.resolve(projectDir);
+    }
+    const parts = resolved.split(path.sep).map((part) => part.toLowerCase());
+    if (parts.includes('kimi-code-mcp')) {
+        throw new Error('Refusing to write MCP config under read-only kimi-code-mcp reference tree.');
+    }
+}
+function readMcpServers(existing) {
+    const value = existing.mcpServers;
+    if (value === undefined || value === null)
+        return {};
+    if (typeof value === 'object' && !Array.isArray(value)) {
+        return value;
+    }
+    throw new Error('Existing mcpServers entry is not a valid object and was not modified.');
+}
+export function generateMcpConfig(options = {}) {
+    const configPath = resolveMcpConfigPath(options);
+    // Only enforce the read-only-tree guard when we are actually going to write. A
+    // dry-run/preview (`write` falsy) produces no file, so it must not throw merely
+    // because the cwd happens to sit under a `kimi-code-mcp` reference tree.
+    if (options.write && options.scope !== 'user') {
+        assertWritableProjectTarget(options.projectDir ?? process.cwd());
+    }
+    const serverName = options.serverName?.trim() || 'ladder_mcp';
+    if (!/^[a-zA-Z0-9_-]+$/.test(serverName)) {
+        throw new Error('server_name must contain only letters, digits, underscores, and hyphens.');
+    }
+    const defaults = defaultServerCommand();
+    const serverConfig = {
+        command: options.command ?? defaults.command,
+        args: options.args ?? defaults.args,
+        env: {},
+    };
+    const existing = readExistingConfig(configPath);
+    const mcpServers = {
+        ...readMcpServers(existing),
+        [serverName]: serverConfig,
+    };
+    const config = { ...existing, mcpServers };
+    if (options.write) {
+        fs.mkdirSync(path.dirname(configPath), { recursive: true });
+        fs.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`, 'utf-8');
+    }
+    return { path: configPath, serverName, config, wrote: options.write === true };
+}

package/dist/kimi-runner.js

@@ -0,0 +1,142 @@
+import { spawn } from 'node:child_process';
+import * as path from 'node:path';
+import { buildKimiEnv, resolveKimiPaths } from './environment.js';
+export function buildKimiArgs(config) {
+    const args = ['-p', config.prompt, '--output-format', 'stream-json'];
+    if (config.sessionId) {
+        args.push('-S', config.sessionId);
+    }
+    else if (config.continueLast) {
+        args.push('-C');
+    }
+    return args;
+}
+function contentToText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    return content.map((part) => {
+        if (typeof part === 'string')
+            return part;
+        if (part && typeof part === 'object') {
+            const value = part;
+            if (typeof value.text === 'string')
+                return value.text;
+            if (typeof value.content === 'string')
+                return value.content;
+        }
+        return '';
+    }).join('');
+}
+function extractResumeHint(record) {
+    if (record.role !== 'meta' || record.type !== 'session.resume_hint')
+        return undefined;
+    for (const key of ['session_id', 'sessionId', 'id', 'session']) {
+        const value = record[key];
+        if (typeof value === 'string' && value.trim())
+            return value.trim();
+    }
+    if (record.content && typeof record.content === 'object') {
+        const content = record.content;
+        for (const key of ['session_id', 'sessionId', 'id', 'session']) {
+            const value = content[key];
+            if (typeof value === 'string' && value.trim())
+                return value.trim();
+        }
+    }
+    return undefined;
+}
+export function parseKimiStreamJson(stdout) {
+    let lastAssistant = '';
+    let sessionId;
+    for (const rawLine of stdout.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line.startsWith('{'))
+            continue;
+        try {
+            const record = JSON.parse(line);
+            if (record.role === 'assistant') {
+                const text = contentToText(record.content);
+                if (text.trim())
+                    lastAssistant = text;
+            }
+            sessionId = extractResumeHint(record) ?? sessionId;
+        }
+        catch {
+            // Ignore non-JSON status lines.
+        }
+    }
+    return {
+        text: lastAssistant.trim() || '(empty response from Kimi)',
+        sessionId,
+    };
+}
+export function truncateAtBoundary(text, maxChars) {
+    if (text.length <= maxChars)
+        return text;
+    const slice = text.slice(0, maxChars);
+    const cutPoint = Math.max(slice.lastIndexOf('\n## '), slice.lastIndexOf('\n\n'), Math.floor(maxChars * 0.8));
+    return `${slice.slice(0, cutPoint).trimEnd()}\n\n---\nOutput truncated (${text.length.toLocaleString()} chars exceeded ${maxChars.toLocaleString()} char budget). Use kimi_resume with the same session for follow-up questions.`;
+}
+function killProcessTree(pid) {
+    if (!pid)
+        return;
+    const killer = spawn('taskkill', ['/PID', String(pid), '/T', '/F'], {
+        stdio: 'ignore',
+        windowsHide: true,
+    });
+    killer.on('error', () => undefined);
+}
+export function runKimi(config) {
+    const timeoutMs = config.timeoutMs ?? 300_000;
+    const maxOutputChars = config.maxOutputChars ?? 60_000;
+    const paths = resolveKimiPaths();
+    if (!paths.binaryPath) {
+        return Promise.resolve({
+            ok: false,
+            text: '',
+            error: 'Kimi CLI binary was not found on PATH or at ~/.kimi-code/bin/kimi.exe.',
+        });
+    }
+    return new Promise((resolve) => {
+        let settled = false;
+        const proc = spawn(paths.binaryPath, buildKimiArgs(config), {
+            env: buildKimiEnv(),
+            stdio: ['ignore', 'pipe', 'pipe'],
+            windowsHide: true,
+            cwd: config.workDir ? path.resolve(config.workDir) : undefined,
+        });
+        let stdout = '';
+        let stderr = '';
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(result);
+        };
+        const timer = setTimeout(() => {
+            killProcessTree(proc.pid);
+            finish({ ok: false, text: '', error: `Kimi timed out after ${Math.round(timeoutMs / 1000)}s` });
+        }, timeoutMs);
+        proc.stdout?.on('data', (chunk) => { stdout += chunk.toString('utf-8'); });
+        proc.stderr?.on('data', (chunk) => { stderr += chunk.toString('utf-8'); });
+        proc.on('error', (err) => {
+            finish({ ok: false, text: '', error: err instanceof Error ? err.message : String(err) });
+        });
+        proc.on('close', (code) => {
+            if (settled)
+                return;
+            if (code !== 0) {
+                const message = stderr.trim() || stdout.trim() || `kimi exited with code ${code}`;
+                finish({ ok: false, text: '', error: message });
+                return;
+            }
+            const parsed = parseKimiStreamJson(stdout);
+            const text = truncateAtBoundary(parsed.text, maxOutputChars);
+            const thinking = config.includeThinking ? stderr.trim() || undefined : undefined;
+            finish({ ok: true, text, thinking, sessionId: parsed.sessionId });
+        });
+    });
+}