@foxden-app/foxclaw 0.6.8 → 0.6.10

package/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 All notable FoxClaw changes are listed here. Each release note is bilingual so GitHub Releases and the npm package are useful to both Chinese and English readers.
 
+## 0.6.10 - 2026-08-23
+
+### 中文
+- 修复 Linux 重启后旧 `bridge.lock` 中的 PID 被无关进程复用时，FoxClaw 误判已有实例并陷入 systemd 重启失败的问题。新锁记录系统启动 ID 和进程启动标识，同时兼容清理上个系统启动遗留的纯 PID 锁。
+- 修复 `doctor` 在显式配置的 `CODEX_CLI_BIN` 或 `OPENCODE_CLI_BIN` 不存在时仍因 PATH 中有同名命令而误报 `[OK]` 的问题；显式路径现在必须真实存在且可执行。
+
+### English
+- Fixed FoxClaw mistaking an unrelated process for the existing bridge when Linux reuses a PID left in an old `bridge.lock` after reboot. New locks record the boot ID and process start identity while still cleaning legacy PID-only locks from a previous boot.
+- Fixed `doctor` reporting `[OK]` when an explicitly configured `CODEX_CLI_BIN` or `OPENCODE_CLI_BIN` is missing but a same-named command exists on PATH. Explicit paths must now exist and be executable.
+
+## 0.6.9 - 2026-08-15
+
+### 中文
+- 补齐 Codex CLI 0.147.0 会话日志的其他观察兼容：新的 `item_completed` / `UserMessage` 会继续把 CLI 侧补充输入镜像到 Telegram，保持原有 `codex-cli-user` 体验。
+- 识别新的 `custom_tool_call`、`function_call` 及其 output 记录，严格按 `call_id` 跨轮询分片配对，让长时间工具调用恢复“正在运行/已运行”状态；未知或孤立 output 保持静默，不猜测配对。`Reasoning`、`ContextCompaction`、`Extension` 等内部记录仍不会污染聊天。
+
+### English
+- Completed the remaining Codex CLI 0.147.0 session-log observation compatibility. New `item_completed` / `UserMessage` records continue mirroring CLI-side follow-up input to Telegram with the existing `codex-cli-user` experience.
+- Recognizes new `custom_tool_call`, `function_call`, and matching output records across polling chunks, pairing them strictly by `call_id` so long-running tools regain Running/Completed status. Unknown or orphan outputs stay silent, while internal `Reasoning`, `ContextCompaction`, and `Extension` records remain chat-invisible.
+
 ## 0.6.8 - 2026-08-15
 
 ### 中文

package/dist/controller/session_observer.d.ts

@@ -2,6 +2,7 @@ import { type TurnActivityEvent } from './activity.js';
 export interface SessionLogCursor {
     activeTurnId: string | null;
     nextMessageIndex: number;
+    pendingToolCalls?: SessionToolCall[];
 }
 export interface SessionLogBootstrap {
     cursor: SessionLogCursor;
@@ -17,6 +18,12 @@ export interface SplitJsonlChunk {
     lines: string[];
     remainder: string;
 }
+interface SessionToolCall {
+    callId: string;
+    kind: 'custom' | 'function';
+    name: string;
+}
 export declare function splitJsonlChunk(remainder: string, chunk: string): SplitJsonlChunk;
 export declare function bootstrapSessionLog(lines: string[]): SessionLogBootstrap;
 export declare function applySessionLog(lines: string[], cursor: SessionLogCursor): SessionLogDiff;
+export {};

package/dist/controller/session_observer.js

@@ -13,34 +13,30 @@ export function splitJsonlChunk(remainder, chunk) {
 }
 export function bootstrapSessionLog(lines) {
     const records = parseRecords(lines);
-    let activeTurnId = null;
-    let nextMessageIndex = 0;
+    let state = { activeTurnId: null, nextMessageIndex: 0 };
     let events = [];
     for (const record of records) {
-        const next = applySessionRecord(record, { activeTurnId, nextMessageIndex });
+        const next = applySessionRecord(record, state);
         if (next.startedTurnId) {
-            activeTurnId = next.startedTurnId;
-            nextMessageIndex = 0;
+            state = next.cursor;
             events = [];
             continue;
         }
-        if (!activeTurnId) {
+        if (!state.activeTurnId) {
             continue;
         }
         if (next.turnCompleted) {
-            activeTurnId = null;
-            nextMessageIndex = 0;
+            state = next.cursor;
             events = [];
             continue;
         }
         events.push(...next.events);
-        activeTurnId = next.cursor.activeTurnId;
-        nextMessageIndex = next.cursor.nextMessageIndex;
+        state = next.cursor;
     }
     return {
-        cursor: { activeTurnId, nextMessageIndex },
+        cursor: state,
         events,
-        startedTurnId: activeTurnId,
+        startedTurnId: state.activeTurnId,
     };
 }
 export function applySessionLog(lines, cursor) {
@@ -51,10 +47,7 @@ export function applySessionLog(lines, cursor) {
     for (const record of records) {
         const next = applySessionRecord(record, state);
         if (next.startedTurnId) {
-            state = {
-                activeTurnId: next.startedTurnId,
-                nextMessageIndex: 0,
-            };
+            state = next.cursor;
             startedTurnIds.push(next.startedTurnId);
             continue;
         }
@@ -114,6 +107,25 @@ function applySessionRecord(record, cursor) {
         }
         return createSessionTextEvents(activeTurnId, cursor, text, typeof payload.item.phase === 'string' ? payload.item.phase : null, false, false, typeof payload.item.id === 'string' ? payload.item.id : null);
     }
+    if (type === 'event_msg'
+        && payload?.type === 'item_completed'
+        && payload?.turn_id === activeTurnId
+        && normalizeSessionItemType(payload?.item) === 'usermessage') {
+        const text = extractSessionItemText(payload.item)?.trim() ?? '';
+        if (!text) {
+            return { cursor, events: [], startedTurnId: null, turnCompleted: false };
+        }
+        return {
+            cursor,
+            events: [{
+                    kind: 'user_message',
+                    turnId: activeTurnId,
+                    text,
+                }],
+            startedTurnId: null,
+            turnCompleted: false,
+        };
+    }
     if (type === 'response_item' && payload?.type === 'plan' && typeof payload.text === 'string') {
         return createSessionTextEvents(activeTurnId, cursor, payload.text, 'commentary', true, true);
     }
@@ -150,6 +162,18 @@ function applySessionRecord(record, cursor) {
             turnCompleted: false,
         };
     }
+    if (type === 'response_item' && payload?.type === 'custom_tool_call') {
+        return createSessionToolStart(activeTurnId, cursor, payload, 'custom');
+    }
+    if (type === 'response_item' && payload?.type === 'function_call') {
+        return createSessionToolStart(activeTurnId, cursor, payload, 'function');
+    }
+    if (type === 'response_item' && payload?.type === 'custom_tool_call_output') {
+        return createSessionToolEnd(activeTurnId, cursor, payload, 'custom');
+    }
+    if (type === 'response_item' && payload?.type === 'function_call_output') {
+        return createSessionToolEnd(activeTurnId, cursor, payload, 'function');
+    }
     if (type === 'event_msg' && payload?.type === 'exec_command_end' && payload?.turn_id === activeTurnId) {
         const exec = createExecEndEvent(payload);
         if (!exec) {
@@ -209,6 +233,7 @@ function createSessionTextEvents(activeTurnId, cursor, text, phase, forceComment
     const streamOutputKind = forceCommentary ? 'commentary' : classifyAgentOutput(phase, false);
     return {
         cursor: {
+            ...cursor,
             activeTurnId,
             nextMessageIndex: cursor.nextMessageIndex + 1,
         },
@@ -243,6 +268,62 @@ function createSessionTextEvents(activeTurnId, cursor, text, phase, forceComment
         turnCompleted: false,
     };
 }
+function createSessionToolStart(turnId, cursor, payload, kind) {
+    const callId = typeof payload?.call_id === 'string' ? payload.call_id : null;
+    const name = typeof payload?.name === 'string' ? payload.name.trim() : '';
+    if (!callId || !name) {
+        return { cursor, events: [], startedTurnId: null, turnCompleted: false };
+    }
+    const pendingToolCalls = [
+        ...(cursor.pendingToolCalls ?? []).filter(call => call.callId !== callId),
+        { callId, kind, name },
+    ];
+    const exec = createSessionToolEvent(turnId, callId, name);
+    return {
+        cursor: { ...cursor, pendingToolCalls },
+        events: [{
+                kind: 'tool_started',
+                turnId,
+                exec,
+                state: inferToolActivityState(exec),
+            }],
+        startedTurnId: null,
+        turnCompleted: false,
+    };
+}
+function createSessionToolEnd(turnId, cursor, payload, kind) {
+    const callId = typeof payload?.call_id === 'string' ? payload.call_id : null;
+    const pending = callId
+        ? (cursor.pendingToolCalls ?? []).find(call => call.callId === callId && call.kind === kind)
+        : null;
+    if (!pending) {
+        return { cursor, events: [], startedTurnId: null, turnCompleted: false };
+    }
+    const exec = createSessionToolEvent(turnId, pending.callId, pending.name);
+    return {
+        cursor: {
+            ...cursor,
+            pendingToolCalls: (cursor.pendingToolCalls ?? []).filter(call => call !== pending),
+        },
+        events: [{
+                kind: 'tool_completed',
+                turnId,
+                exec,
+                state: inferToolActivityState(exec),
+            }],
+        startedTurnId: null,
+        turnCompleted: false,
+    };
+}
+function createSessionToolEvent(turnId, callId, name) {
+    return {
+        callId,
+        turnId,
+        command: [`Tool ${name}`],
+        cwd: null,
+        parsedCmd: [],
+    };
+}
 function normalizeSessionItemType(item) {
     if (typeof item?.type !== 'string') {
         return null;

package/dist/lock.js

@@ -15,7 +15,10 @@ export function acquireProcessLock(lockPath) {
 function acquireProcessLockInternal(lockPath, allowStaleRetry) {
     try {
         const fd = fs.openSync(lockPath, 'wx');
-        fs.writeFileSync(fd, `${process.pid}\n`, 'utf8');
+        fs.writeFileSync(fd, `${JSON.stringify({
+            pid: process.pid,
+            processIdentity: readLinuxProcessIdentity(process.pid),
+        })}\n`, 'utf8');
         let released = false;
         return {
             release() {
@@ -42,26 +45,73 @@ function acquireProcessLockInternal(lockPath, allowStaleRetry) {
         if (!isAlreadyExistsError(error)) {
             throw error;
         }
-        const pid = readLockPid(lockPath);
-        if (allowStaleRetry && pid !== null && !isProcessAlive(pid)) {
+        const record = readLockRecord(lockPath);
+        if (allowStaleRetry && record.pid !== null && !isLockOwnerAlive(lockPath, record)) {
             fs.rmSync(lockPath, { force: true });
             return acquireProcessLockInternal(lockPath, false);
         }
-        throw new LockHeldError(lockPath, pid);
+        throw new LockHeldError(lockPath, record.pid);
     }
 }
-function readLockPid(lockPath) {
+function readLockRecord(lockPath) {
     try {
         const value = fs.readFileSync(lockPath, 'utf8').trim();
         if (!value) {
-            return null;
+            return { pid: null, processIdentity: null };
+        }
+        if (value.startsWith('{')) {
+            const parsed = JSON.parse(value);
+            return {
+                pid: typeof parsed.pid === 'number' && Number.isInteger(parsed.pid) ? parsed.pid : null,
+                processIdentity: typeof parsed.processIdentity === 'string' ? parsed.processIdentity : null,
+            };
         }
         const pid = Number.parseInt(value, 10);
-        return Number.isFinite(pid) ? pid : null;
+        return { pid: Number.isFinite(pid) ? pid : null, processIdentity: null };
     }
     catch {
+        return { pid: null, processIdentity: null };
+    }
+}
+function isLockOwnerAlive(lockPath, record) {
+    if (record.pid === null || !isProcessAlive(record.pid)) {
+        return false;
+    }
+    const currentIdentity = readLinuxProcessIdentity(record.pid);
+    if (record.processIdentity !== null && currentIdentity !== null) {
+        return record.processIdentity === currentIdentity;
+    }
+    return !wasLockCreatedBeforeCurrentBoot(lockPath);
+}
+function readLinuxProcessIdentity(pid) {
+    if (process.platform !== 'linux') {
         return null;
     }
+    try {
+        const bootId = fs.readFileSync('/proc/sys/kernel/random/boot_id', 'utf8').trim();
+        const stat = fs.readFileSync(`/proc/${pid}/stat`, 'utf8');
+        const commandEnd = stat.lastIndexOf(')');
+        const startTicks = commandEnd >= 0 ? stat.slice(commandEnd + 2).split(' ')[19] : undefined;
+        return bootId && startTicks ? `${bootId}:${startTicks}` : null;
+    }
+    catch {
+        return null;
+    }
+}
+function wasLockCreatedBeforeCurrentBoot(lockPath) {
+    if (process.platform !== 'linux') {
+        return false;
+    }
+    try {
+        const bootTimeSeconds = fs.readFileSync('/proc/stat', 'utf8').match(/^btime (\d+)$/m)?.[1];
+        if (!bootTimeSeconds) {
+            return false;
+        }
+        return fs.statSync(lockPath).mtimeMs < Number(bootTimeSeconds) * 1000;
+    }
+    catch {
+        return false;
+    }
 }
 function isProcessAlive(pid) {
     if (!Number.isFinite(pid) || pid <= 0) {

package/dist/main.js

@@ -1784,13 +1784,13 @@ function runDoctorChecks() {
     const configuredCodexBin = process.env.CODEX_CLI_BIN;
     const checks = [
         ['node >= 24', Number(process.versions.node.split('.')[0]) >= 24],
-        ['codex cli available', hasConfiguredCodexBin(configuredCodexBin) || hasCommand('codex')],
+        ['codex cli available', hasConfiguredCommand(configuredCodexBin, 'codex')],
         ['telegram bot token(s) configured', Boolean(process.env.TG_BOT_TOKENS?.trim() || process.env.TG_BOT_TOKEN?.trim())],
         ['telegram allowed user configured', Boolean(process.env.TG_ALLOWED_USER_ID)],
     ];
     if (process.env.OPENCODE_BOT_TOKEN?.trim()) {
         const configuredOpencodeBin = process.env.OPENCODE_CLI_BIN;
-        checks.push(['opencode cli available', hasConfiguredCodexBin(configuredOpencodeBin) || hasCommand('opencode')]);
+        checks.push(['opencode cli available', hasConfiguredCommand(configuredOpencodeBin, 'opencode')]);
         const codexTokens = [
             ...(process.env.TG_BOT_TOKENS ?? '').split(','),
             process.env.TG_BOT_TOKEN ?? '',
@@ -2337,9 +2337,9 @@ function resolveCommand(commandName) {
         return null;
     }
 }
-function hasConfiguredCodexBin(binPath) {
-    if (!binPath || !binPath.trim())
-        return false;
+function hasConfiguredCommand(binPath, fallbackCommand) {
+    if (!binPath?.trim())
+        return hasCommand(fallbackCommand);
     try {
         fs.accessSync(binPath, fs.constants.X_OK);
         return true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foxden-app/foxclaw",
-  "version": "0.6.8",
+  "version": "0.6.10",
   "description": "Foxden local execution claw for controlling Codex and OpenCode from trusted chat interfaces.",
   "type": "module",
   "main": "dist/main.js",