ladder-mcp 1.1.0 → 1.1.2

package/CHANGELOG.md

@@ -4,6 +4,33 @@ All notable changes to Ladder_mcp are documented here. Format loosely follows
 [Keep a Changelog](https://keepachangelog.com/); this project uses
 [Semantic Versioning](https://semver.org/).
 
+## [1.1.2] - 2026-06-28
+
+Live-progress and cancellation reliability for `kimi_code`.
+
+### Added
+
+- The CLI transport now surfaces the running action: `stream-json` `tool_calls`
+  records emit immediate `tool_call` progress events (e.g. `Read src/types.ts`)
+  and `plan` records emit `plan` events, matching the ACP transport. A CLI job
+  no longer looks idle while it works.
+
+### Fixed
+
+- Cancelling a `kimi_code` call now actually kills the underlying `kimi.exe`
+  process in every mode (foreground CLI, background CLI, foreground ACP).
+  Previously only background ACP honored cancellation; the others leaked the
+  child until the timeout fired. `runKimi` accepts an `AbortSignal`, skips
+  spawning when already aborted, and kills the process tree on abort.
+- The ACP client is hardened against a `close()`-before-`start()` race, and an
+  aborted ACP run now reports `Kimi cancelled` instead of a raw exit code.
+
+### Changed
+
+- `kimi_code`'s `transport` and `background` parameter descriptions now explain
+  the cli/acp trade-off and where to read the full progress log, so agents pick
+  a mode deliberately.
+
 ## [1.1.0] - 2026-06-28
 
 Breaking tool-surface redesign: the MCP tool list is now an intent-first set of

package/README.md

@@ -6,7 +6,7 @@ client like Claude Code can run codebase analysis, native sessions, API
 queries, ACP chat, background tasks, and CLI admin/diagnostics — all on Windows
 without hardcoded POSIX assumptions.
 
-> Status: **v1.0.1** ([npm](https://www.npmjs.com/package/ladder-mcp)).
+> Status: **v1.1.2** ([npm](https://www.npmjs.com/package/ladder-mcp)).
 > Supported platform is **Windows 11 only**.
 
 ## Requirements
@@ -19,7 +19,7 @@ without hardcoded POSIX assumptions.
 ## Quick start (from npm)
 
 You don't need to clone or build — the package is published on npm and your MCP
-client launches it via `npx`.
+client launches it via `npx`, or you can install the package directly.
 
 **Claude Code (one command):**
 
@@ -50,7 +50,16 @@ Then in Claude Code run `/mcp` (should show `kimi-code: connected`) and call
 Prefer a global install? `npm install -g ladder-mcp`, then use `ladder-mcp` as the
 command instead of `npx -y ladder-mcp`.
 
-To let Kimi Code itself host this server, use the `kimi_generate_mcp_config`
+Or install locally into your project:
+
+```bash
+npm install ladder-mcp
+```
+
+Then point your MCP config at `./node_modules/.bin/ladder-mcp` (or use
+`npx -y ladder-mcp`, which resolves the locally installed copy when available).
+
+To let Kimi Code itself host this server, use the `kimi_setup`
 tool to produce/merge a `.kimi-code/mcp.json` entry.
 
 ## Build from source (contributors)
@@ -63,26 +72,23 @@ npm run build      # compiles src/ -> dist/ (tests excluded)
 Quick checks:
 
 ```bash
-npm test           # vitest (50 tests)
+npm test           # vitest (153 tests)
 npm run typecheck  # tsc --noEmit (incl. tests)
 npm run dev        # run the server from source via tsx
 ```
 
 ## Tools
 
-**Core (v1)** — `kimi_analyze`, `kimi_query`, `kimi_verify`, `kimi_resume`,
-`kimi_list_sessions`, `kimi_status`
-
-**CLI admin & capabilities** — `kimi_capabilities`, `kimi_doctor`,
-`kimi_provider_list`, `kimi_export_session`, `kimi_visualize_session`
-
-**ACP (chat over stdio)** — `kimi_chat`, `kimi_acp_sessions`, `kimi_cancel`
+**Core (v1.1)** — `kimi_code`, `kimi_ask`, `kimi_sessions`, `kimi_tasks`,
+`kimi_status`, `kimi_setup`
 
-**Background tasks** — `kimi_task_status`, `kimi_task_output`, `kimi_task_cancel`
-(set `background=true` on `kimi_chat`)
+`kimi_code` supports both the native CLI transport (default) and the ACP
+JSON-RPC transport (`transport: 'acp'`); set `background=true` to track long
+work as a background task.
 
-**Kimi-hosted config & desktop (read-only)** — `kimi_generate_mcp_config`,
-`kimi_desktop_status`, `kimi_budget_probe`
+**Experimental (off by default)** — `kimi_export_session`,
+`kimi_visualize_session`, `kimi_desktop_status`, `kimi_budget_probe`. Enable
+with the environment variable `LADDER_EXPERIMENTAL=1`.
 
 ## Safety boundaries
 

package/dist/index.js

@@ -62,8 +62,8 @@ server.tool('kimi_code', 'Agentic work in a repository: analyze and edit files.
     session_id: z.string().optional().describe('Explicit Kimi session id to resume.'),
     new_session: z.boolean().optional().describe('Start fresh instead of continuing the last session. Default: false.'),
     edit: z.boolean().optional().describe('Allow file modifications. Default: false (analysis-only intent).'),
-    background: z.boolean().optional().describe('Track as a long-running background task.'),
-    transport: z.enum(['cli', 'acp']).optional().describe("Transport: 'cli' edits in-process; 'acp' uses JSON-RPC. Default: 'cli'."),
+    background: z.boolean().optional().describe('Track as a long-running background task. Every progress event (including each action) is appended to the task log, readable via kimi_tasks — the full accumulating transcript, unlike the single overwriting live-progress line of a foreground call.'),
+    transport: z.enum(['cli', 'acp']).optional().describe("How the server drives Kimi. Both edit files and resume sessions; they differ in robustness and live-progress detail. 'cli' (default): one-shot process, most robust on Windows, but live progress is coarse — only streaming-output volume, no per-action lines. 'acp': persistent JSON-RPC session that emits granular live progress (tool calls, plan steps) and supports interactive permission prompts, but is heavier and more fragile. Prefer 'cli' for plain codegen/analysis; choose 'acp' when you need to watch each action live or handle mid-run prompts."),
     session_mode: z.enum(['new', 'load', 'resume']).optional().describe("ACP session mode when transport='acp'. Default: inferred from session_id/new_session."),
     detail_level: z.enum(['summary', 'normal', 'detailed']).optional(),
     max_output_tokens: z.number().optional(),
@@ -89,6 +89,7 @@ server.tool('kimi_code', 'Agentic work in a repository: analyze and edit files.
                     maxOutputChars: maxChars(max_output_tokens),
                     includeThinking: includeThinkingValue,
                     onProgress: appendReporter(append),
+                    signal: _signal,
                 });
                 if (!result.ok)
                     throw new Error(result.error ?? 'CLI code task failed');
@@ -106,6 +107,7 @@ server.tool('kimi_code', 'Agentic work in a repository: analyze and edit files.
             maxOutputChars: maxChars(max_output_tokens),
             includeThinking: includeThinkingValue,
             onProgress: createMcpProgressReporter(extra),
+            signal: extra?.signal,
         });
         if (!result.ok)
             return textResponse(`Error: ${result.error}`, true);
@@ -135,7 +137,7 @@ server.tool('kimi_code', 'Agentic work in a repository: analyze and edit files.
         });
         return textResponse(JSON.stringify(task, null, 2));
     }
-    const result = await runAcp(undefined, createMcpProgressReporter(extra));
+    const result = await runAcp(extra?.signal, createMcpProgressReporter(extra));
     return textResponse(JSON.stringify(result, null, 2), !result.ok);
 });
 server.tool('kimi_ask', 'Stateless question or independent review. Text only, no repo, no edits.', {

package/dist/kimi-runner.js

@@ -52,6 +52,46 @@ function contentToText(content) {
         return '[non-text]';
     }).join('');
 }
+// The Kimi CLI emits tool calls on `role:assistant` records as a `tool_calls`
+// array shaped like OpenAI function calls. Extract a concise "Action target"
+// string so CLI runs can surface the current action as an immediate progress
+// event, matching the ACP transport behavior.
+function extractCliToolTarget(argsJson) {
+    if (!argsJson)
+        return undefined;
+    try {
+        const parsed = JSON.parse(argsJson);
+        const value = parsed.path ?? parsed.skill ?? parsed.command;
+        if (typeof value === 'string' && value.trim()) {
+            const trimmed = value.trim();
+            return trimmed.length > 80 ? `${trimmed.slice(0, 80)}…` : trimmed;
+        }
+    }
+    catch {
+        // Ignore malformed argument JSON.
+    }
+    return undefined;
+}
+function formatCliToolCall(toolCall) {
+    if (!toolCall || typeof toolCall !== 'object')
+        return undefined;
+    const tc = toolCall;
+    let name;
+    let args;
+    if (tc.function && typeof tc.function === 'object') {
+        const fn = tc.function;
+        name = typeof fn.name === 'string' ? fn.name : undefined;
+        args = typeof fn.arguments === 'string' ? fn.arguments : undefined;
+    }
+    else {
+        name = typeof tc.name === 'string' ? tc.name : undefined;
+        args = typeof tc.arguments === 'string' ? tc.arguments : undefined;
+    }
+    if (!name)
+        return undefined;
+    const target = extractCliToolTarget(args);
+    return target ? `${name} ${target}` : name;
+}
 function extractResumeHint(record) {
     if (record.role !== 'meta')
         return undefined;
@@ -166,6 +206,13 @@ export function runKimi(config) {
             error: 'Kimi CLI binary was not found on PATH or at ~/.kimi-code/bin/kimi.exe.',
         });
     }
+    if (config.signal?.aborted) {
+        return Promise.resolve({
+            ok: false,
+            text: '',
+            error: 'Kimi cancelled',
+        });
+    }
     return new Promise((resolve) => {
         let settled = false;
         const proc = spawn(paths.binaryPath, buildKimiArgs(config), {
@@ -180,6 +227,7 @@ export function runKimi(config) {
         let streamBuffer = '';
         const coalescer = config.onProgress ? createStreamCoalescer(config.onProgress) : undefined;
         const watchdog = config.onProgress ? createStallWatchdog(config.onProgress) : undefined;
+        let onAbort;
         const finish = (result) => {
             if (settled)
                 return;
@@ -188,8 +236,19 @@ export function runKimi(config) {
             coalescer?.flush();
             coalescer?.stop();
             watchdog?.stop();
+            config.signal?.removeEventListener('abort', onAbort);
             resolve(result);
         };
+        onAbort = () => {
+            killProcessTree(proc.pid);
+            finish({ ok: false, text: '', error: 'Kimi cancelled' });
+        };
+        config.signal?.addEventListener('abort', onAbort, { once: true });
+        // Cover the race where the signal is already aborted right after registration.
+        if (config.signal?.aborted) {
+            onAbort();
+            return;
+        }
         let timer = setTimeout(() => {
             timedOut = true;
             killProcessTree(proc.pid);
@@ -213,10 +272,23 @@ export function runKimi(config) {
                     continue;
                 try {
                     const record = JSON.parse(line);
-                    if (record.role === 'assistant') {
+                    if (record.type === 'plan') {
+                        const text = contentToText(record.content).trim();
+                        if (text)
+                            config.onProgress(makeEvent('plan', text));
+                    }
+                    else if (record.role === 'assistant') {
                         const text = contentToText(record.content);
                         if (text.trim())
                             coalescer?.add(text);
+                        const toolCalls = record.tool_calls;
+                        if (Array.isArray(toolCalls)) {
+                            for (const toolCall of toolCalls) {
+                                const toolText = formatCliToolCall(toolCall);
+                                if (toolText)
+                                    config.onProgress(makeEvent('tool_call', toolText));
+                            }
+                        }
                     }
                 }
                 catch {

package/dist/transports/acp.js

@@ -232,6 +232,8 @@ export class AcpClient extends EventEmitter {
     start() {
         if (this.proc)
             return;
+        if (this.closing)
+            throw new Error('ACP client is closing');
         const binary = resolveKimiPaths().binaryPath;
         if (!binary)
             throw new Error('Kimi CLI binary was not found on PATH or at ~/.kimi-code/bin/kimi.exe.');
@@ -310,10 +312,11 @@ export class AcpClient extends EventEmitter {
         return this.updates.join('').trim();
     }
     close() {
-        if (!this.proc || this.closing)
+        if (this.closing)
             return;
         this.closing = true;
-        killProcessTree(this.proc.pid);
+        if (this.proc)
+            killProcessTree(this.proc.pid);
     }
     handleMessages(chunk) {
         let messages;
@@ -665,7 +668,10 @@ export async function runAcpPrompt(options) {
         return { ok: true, text: text || '(empty ACP response from Kimi)', sessionId, metadata };
     }
     catch (error) {
-        return { ok: false, text: '', error: error instanceof Error ? error.message : String(error) };
+        const message = options.signal?.aborted
+            ? 'Kimi cancelled'
+            : error instanceof Error ? error.message : String(error);
+        return { ok: false, text: '', error: message };
     }
     finally {
         if (onNotification)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ladder-mcp",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "Windows-first MCP bridge for Kimi Code CLI v24",
   "license": "MIT",
   "type": "module",