pikiloom 0.4.64 → 0.4.67

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pikiloom",
-  "version": "0.4.64",
+  "version": "0.4.67",
   "description": "Put the world's smartest AI agents in your pocket. Command local Claude & Gemini via IM. | 让最好用的 IM 变成你电脑上的顶级 Agent 控制台",
   "type": "module",
   "bin": {
@@ -25,11 +25,13 @@
   ],
   "author": "xiaotonng",
   "license": "MIT",
+  "packageManager": "npm@11.6.2",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/xiaotonng/pikiloom.git"
   },
   "scripts": {
+    "verify:toolchain": "node scripts/verify-toolchain.mjs",
     "dev": "bash scripts/dev.sh",
     "command": "set -ae && . ./.env && set +a && tsx src/cli/run.ts",
     "build:dashboard": "vite build --config dashboard/vite.config.ts",
@@ -45,9 +47,21 @@
   "engines": {
     "node": ">=20.0.0"
   },
+  "devEngines": {
+    "runtime": {
+      "name": "node",
+      "version": "22.23.1 || ^25.2.0",
+      "onFail": "error"
+    },
+    "packageManager": {
+      "name": "npm",
+      "version": "11.6.2",
+      "onFail": "error"
+    }
+  },
   "devDependencies": {
     "@tailwindcss/vite": "^4.2.1",
-    "@types/node": "^25.3.5",
+    "@types/node": "22.20.0",
     "@types/qrcode": "^1.5.6",
     "@types/react": "^19.2.14",
     "@types/react-dom": "^19.2.3",
@@ -61,7 +75,7 @@
     "remark-gfm": "^4.0.1",
     "tailwindcss": "^4.2.1",
     "tsx": "^4.21.0",
-    "typescript": "^5.9.3",
+    "typescript": "7.0.2",
     "vitest": "^4.0.18",
     "zustand": "^5.0.12"
   },

package/packages/kernel/dist/drivers/codex.d.ts

@@ -1,9 +1,12 @@
 import type { AgentDriver, AgentTurnInput, DriverContext, DriverEvent, DriverResult, TuiInput, TuiSpec, NativeSessionInfo } from '../contracts/driver.js';
+import type { UniversalToolCall } from '../protocol/index.js';
 export declare function codexToolSummary(item: any): {
     id: string;
     name: string;
     summary: string;
 } | null;
+/** Project one app-server item into the kernel's rich, expandable tool-call shape. */
+export declare function codexToolCall(item: any, fallbackStatus: UniversalToolCall['status']): UniversalToolCall | null;
 export interface CodexContentState {
     text: string;
     reasoning: string;

package/packages/kernel/dist/drivers/codex.js

@@ -34,6 +34,89 @@ const CODEX_TOOL_CALL_TYPES = new Set(['dynamicToolCall', 'mcpToolCall', 'collab
 // Field-less placeholder summaries — a completed item with only one of these never overrides
 // a more specific summary cached at item/started.
 const CODEX_GENERIC_TOOL_SUMMARIES = new Set(['Search web', 'Run shell command', 'Edit files', 'Use tool']);
+const CODEX_TOOL_INPUT_MAX = 4 * 1024;
+const CODEX_TOOL_RESULT_MAX = 12 * 1024;
+function codexToolText(value, max) {
+    if (value == null)
+        return null;
+    let text;
+    if (typeof value === 'string')
+        text = value;
+    else {
+        try {
+            text = JSON.stringify(value, null, 2);
+        }
+        catch {
+            text = String(value);
+        }
+    }
+    text = text.replace(/\r\n/g, '\n').trim();
+    if (!text)
+        return null;
+    return text.length <= max ? text : `${text.slice(0, max).trimEnd()}\n… (truncated)`;
+}
+function codexToolInput(item) {
+    switch (item?.type) {
+        case 'commandExecution': {
+            const command = Array.isArray(item.command) ? item.command.join(' ') : item.command;
+            if (!command)
+                return null;
+            const detail = { command };
+            if (typeof item.cwd === 'string' && item.cwd.trim())
+                detail.cwd = item.cwd;
+            return codexToolText(detail, CODEX_TOOL_INPUT_MAX);
+        }
+        case 'fileChange':
+        case 'patch':
+            return codexToolText(item.changes ?? item.patch ?? item.diff, CODEX_TOOL_INPUT_MAX);
+        case 'mcpToolCall':
+        case 'dynamicToolCall':
+            return codexToolText(item.arguments ?? item.input, CODEX_TOOL_INPUT_MAX);
+        case 'collabAgentToolCall':
+            return codexToolText({
+                prompt: item.prompt ?? undefined,
+                model: item.model ?? undefined,
+                reasoningEffort: item.reasoningEffort ?? item.reasoning_effort ?? undefined,
+                receiverThreadIds: item.receiverThreadIds ?? item.receiver_thread_ids ?? undefined,
+            }, CODEX_TOOL_INPUT_MAX);
+        case 'webSearch':
+            return codexToolText(item.action ?? item.query, CODEX_TOOL_INPUT_MAX);
+        default:
+            return null;
+    }
+}
+function codexToolResult(item) {
+    if (item?.type === 'commandExecution') {
+        const output = codexToolText(item.aggregatedOutput ?? item.aggregated_output, CODEX_TOOL_RESULT_MAX);
+        const exitCode = item.exitCode ?? item.exit_code;
+        if (output && typeof exitCode === 'number' && exitCode !== 0)
+            return `${output}\n\n(exit code ${exitCode})`;
+        if (output)
+            return output;
+        return typeof exitCode === 'number' && exitCode !== 0 ? `exit code ${exitCode}` : null;
+    }
+    if (item?.type === 'mcpToolCall') {
+        const error = item.error?.message ?? item.error;
+        if (error)
+            return codexToolText(error, CODEX_TOOL_RESULT_MAX);
+        return codexToolText(item.result, CODEX_TOOL_RESULT_MAX);
+    }
+    if (item?.type === 'dynamicToolCall') {
+        return codexToolText(item.contentItems ?? item.content_items, CODEX_TOOL_RESULT_MAX);
+    }
+    if (item?.type === 'collabAgentToolCall') {
+        return codexToolText(item.agentsStates ?? item.agents_states, CODEX_TOOL_RESULT_MAX);
+    }
+    return null;
+}
+function codexToolStatus(item, fallback) {
+    const raw = String(item?.status || '').toLowerCase();
+    if (raw === 'failed' || raw === 'declined' || item?.success === false || item?.error)
+        return 'failed';
+    if (raw === 'completed' || raw === 'done' || item?.success === true)
+        return 'done';
+    return fallback;
+}
 export function codexToolSummary(item) {
     const id = String(item?.id || '');
     if (!id)
@@ -66,6 +149,27 @@ export function codexToolSummary(item) {
     }
     return null;
 }
+/** Project one app-server item into the kernel's rich, expandable tool-call shape. */
+export function codexToolCall(item, fallbackStatus) {
+    const base = codexToolSummary(item);
+    if (!base)
+        return null;
+    return {
+        ...base,
+        input: codexToolInput(item),
+        result: codexToolResult(item),
+        status: codexToolStatus(item, fallbackStatus),
+    };
+}
+function appendCodexToolOutput(previous, delta) {
+    if (typeof delta !== 'string' || !delta)
+        return previous ?? null;
+    const next = `${previous ?? ''}${delta}`.replace(/\r\n/g, '\n');
+    if (next.length <= CODEX_TOOL_RESULT_MAX)
+        return next;
+    const marker = '… (earlier output truncated)\n';
+    return marker + next.slice(-(CODEX_TOOL_RESULT_MAX - marker.length));
+}
 // codex `item/tool/requestUserInput` params -> a normalized UniversalInteraction
 // (faithful to the legacy codex driver's toAgentInteraction shape).
 function codexUserInputToInteraction(params, promptId) {
@@ -153,7 +257,7 @@ export class CodexDriver {
         const srv = new StdioRpcClient({ command: this.bin, args, env: input.env, label: 'codex app-server' });
         const state = { text: '', reasoning: '', streamedReasoning: false, msgs: [], thinkParts: [], sessionId: input.sessionId ?? null, input: null, output: null, cached: null, contextUsed: null, contextWindow: null, status: null, error: null, turnId: null };
         const phases = new Map();
-        const toolSummaries = new Map();
+        const toolCalls = new Map();
         const deltaItems = new Set();
         let lastTextItemId = null;
         let steerRegistered = false;
@@ -218,13 +322,35 @@ export class CodexDriver {
                         const item = params?.item || {};
                         if (item.type === 'agentMessage' && item.id)
                             phases.set(item.id, item.phase || 'final_answer');
-                        const t = codexToolSummary(item);
-                        if (t && !toolSummaries.has(t.id)) {
-                            toolSummaries.set(t.id, t.summary);
-                            ctx.emit({ type: 'tool', call: { id: t.id, name: t.name, summary: t.summary, status: 'running' } });
+                        const call = codexToolCall(item, 'running');
+                        if (call && !toolCalls.has(call.id)) {
+                            toolCalls.set(call.id, call);
+                            ctx.emit({ type: 'tool', call });
                         }
                         break;
                     }
+                    case 'item/commandExecution/outputDelta':
+                    case 'item/fileChange/outputDelta': {
+                        const id = String(params?.itemId || '');
+                        const previous = toolCalls.get(id);
+                        if (!previous)
+                            break;
+                        const call = { ...previous, result: appendCodexToolOutput(previous.result, params?.delta) };
+                        toolCalls.set(id, call);
+                        ctx.emit({ type: 'tool', call });
+                        break;
+                    }
+                    case 'item/fileChange/patchUpdated': {
+                        const id = String(params?.itemId || '');
+                        const projected = codexToolCall({ type: 'fileChange', id, changes: params?.changes }, 'running');
+                        if (!projected)
+                            break;
+                        const previous = toolCalls.get(id);
+                        const call = previous ? { ...previous, ...projected, result: projected.result ?? previous.result } : projected;
+                        toolCalls.set(id, call);
+                        ctx.emit({ type: 'tool', call });
+                        break;
+                    }
                     case 'item/agentMessage/delta': {
                         if (!params?.delta)
                             break;
@@ -259,14 +385,26 @@ export class CodexDriver {
                             captureCodexAgentMessage(item, state, deltaItems, phases, ctx.emit);
                         else if (item.type === 'reasoning')
                             captureCodexReasoning(codexReasoningItemText(item), state, ctx.emit);
-                        const t = codexToolSummary(item);
-                        if (t) {
+                        const projected = codexToolCall(item, 'done');
+                        if (projected) {
                             // Prefer the completed item's summary when it is specific — webSearch carries its
                             // query only at completion (item/started may be query-less or absent entirely,
-                            // so no `toolSummaries.has` gate: a completed-only tool still gets its row).
-                            const summary = !CODEX_GENERIC_TOOL_SUMMARIES.has(t.summary) ? t.summary : (toolSummaries.get(t.id) || t.summary);
-                            toolSummaries.set(t.id, summary);
-                            ctx.emit({ type: 'tool', call: { id: t.id, name: t.name, summary, status: item.status === 'failed' ? 'failed' : 'done' } });
+                            // so a completed-only tool still gets its row).
+                            const previous = toolCalls.get(projected.id);
+                            const summary = !CODEX_GENERIC_TOOL_SUMMARIES.has(projected.summary)
+                                ? projected.summary
+                                : (previous?.summary || projected.summary);
+                            const call = {
+                                ...previous,
+                                ...projected,
+                                summary,
+                                input: projected.input ?? previous?.input ?? null,
+                                // Some app-server versions stream output deltas but omit aggregatedOutput on the
+                                // terminal item. Preserve the accumulated live result in that case.
+                                result: projected.result ?? previous?.result ?? null,
+                            };
+                            toolCalls.set(call.id, call);
+                            ctx.emit({ type: 'tool', call });
                         }
                         break;
                     }