lark-remote 0.1.4 → 0.1.6

package/dist/card/run-state.js

@@ -32,8 +32,204 @@ export function reduceRunState(state, event) {
         return reducePlanEvent(state, event);
     if (event.type === 'file_change')
         return reduceFileChangeEvent(state, event);
+    if (event.type === 'turn_started')
+        return reduceTurnStartedEvent(state, event);
+    if (event.type === 'turn_diff')
+        return reduceTurnDiffEvent(state, event);
+    if (event.type === 'approval_requested') {
+        const approvals = state.approvals ?? [];
+        const next = { view: event.view, expired: false };
+        const idx = approvals.findIndex((a) => a.view.requestId === event.requestId);
+        if (idx >= 0) {
+            // 同一 requestId 重复到达：原地替换，保持槽位顺序。
+            return {
+                ...state,
+                approvals: approvals.map((a, i) => (i === idx ? next : a)),
+            };
+        }
+        return { ...state, approvals: [...approvals, next] };
+    }
+    if (event.type === 'approval_resolved') {
+        return {
+            ...state,
+            approvals: (state.approvals ?? []).filter((a) => a.view.requestId !== event.requestId),
+        };
+    }
+    if (event.type === 'approval_view_updated') {
+        return {
+            ...state,
+            approvals: (state.approvals ?? []).map((a) => a.view.requestId === event.requestId ? { ...a, view: event.view } : a),
+        };
+    }
+    if (event.type === 'approval_expired') {
+        return {
+            ...state,
+            approvals: (state.approvals ?? []).map((a) => a.view.requestId === event.requestId ? { ...a, expired: true } : a),
+        };
+    }
     return state;
 }
+/** Handle app-server turn_started — records the operation kind (turn vs compact). */
+function reduceTurnStartedEvent(state, event) {
+    if (event.type !== 'turn_started')
+        return state;
+    return {
+        ...state,
+        operationKind: event.operationKind,
+        footer: state.footer ?? 'thinking',
+    };
+}
+/**
+ * Handle app-server turn_diff events. The translator emits FULL per-item
+ * snapshots (accumulated text/reasoning/tool output/plan, current file-change
+ * set). Each snapshot is scoped to a thread item (event.itemId); the block is
+ * replaced in place to avoid duplication, and a NEW block is appended on the
+ * item's first sight — so interleaved items keep their real chronology and
+ * the active streaming content sits at the bottom, like the exec path.
+ */
+function reduceTurnDiffEvent(state, event) {
+    if (event.type !== 'turn_diff')
+        return state;
+    let next = state;
+    const ts = event.timestamp;
+    const complete = event.complete === true;
+    if (event.text !== undefined) {
+        const blocks = markThinkingInactive(next.blocks);
+        next = {
+            ...next,
+            blocks: keepLatestBlocks(upsertSnapshotBlock(blocks, (b) => b.kind === 'text' && b.itemId === event.itemId, () => ({
+                kind: 'text',
+                itemId: event.itemId,
+                content: keepLatest(event.text, MAX_TEXT_CHARS),
+                timestamp: ts,
+                ...(complete ? { completedAt: ts } : {}),
+            }), (existing) => {
+                const textBlock = existing;
+                return {
+                    ...textBlock,
+                    content: keepLatest(event.text, MAX_TEXT_CHARS),
+                    ...(complete ? { completedAt: ts } : {}),
+                };
+            }, !complete)),
+            footer: 'streaming',
+        };
+    }
+    if (event.reasoning !== undefined) {
+        next = {
+            ...next,
+            blocks: keepLatestBlocks(upsertSnapshotBlock(next.blocks, (b) => b.kind === 'thinking' && b.itemId === event.itemId, () => ({
+                kind: 'thinking',
+                itemId: event.itemId,
+                content: keepLatest(event.reasoning, MAX_REASONING_CHARS),
+                active: !complete,
+                timestamp: ts,
+                ...(complete ? { completedAt: ts } : {}),
+            }), (existing) => {
+                const thinkingBlock = existing;
+                return {
+                    ...thinkingBlock,
+                    content: keepLatest(event.reasoning, MAX_REASONING_CHARS),
+                    active: !complete,
+                    ...(complete ? { completedAt: ts } : {}),
+                };
+            }, !complete)),
+            footer: 'thinking',
+        };
+    }
+    if (event.toolOutput !== undefined) {
+        next = {
+            ...next,
+            blocks: keepLatestBlocks(upsertSnapshotBlock(next.blocks, (b) => b.kind === 'tool' && b.tool.id === event.itemId, () => ({
+                kind: 'tool',
+                tool: {
+                    id: event.itemId,
+                    name: 'command',
+                    input: '',
+                    output: keepLatest(event.toolOutput, MAX_TOOL_DETAIL_CHARS),
+                    status: complete ? (event.toolStatus ?? 'ok') : 'running',
+                    startedAt: ts,
+                    ...(complete ? { completedAt: ts } : {}),
+                },
+            }), (existing) => ({
+                kind: 'tool',
+                tool: {
+                    ...existing.tool,
+                    output: keepLatest(event.toolOutput, MAX_TOOL_DETAIL_CHARS),
+                    status: complete
+                        ? (event.toolStatus ?? 'ok')
+                        : existing.tool.status,
+                    ...(complete ? { completedAt: ts } : {}),
+                },
+            }), !complete)),
+            footer: 'tool_running',
+        };
+    }
+    if (event.plan !== undefined) {
+        const newPlan = keepLatest(event.plan, MAX_REASONING_CHARS * 2);
+        next = {
+            ...next,
+            plan: newPlan,
+            blocks: keepLatestBlocks(upsertSnapshotBlock(next.blocks, (b) => b.kind === 'plan' && b.itemId === event.itemId, () => ({
+                kind: 'plan',
+                itemId: event.itemId,
+                content: newPlan,
+                active: !complete,
+                timestamp: ts,
+                ...(complete ? { completedAt: ts } : {}),
+            }), (existing) => {
+                const planBlock = existing;
+                return {
+                    ...planBlock,
+                    content: newPlan,
+                    active: !complete,
+                    ...(complete ? { completedAt: ts } : {}),
+                };
+            }, !complete)),
+        };
+    }
+    if (event.fileChanges !== undefined) {
+        let blocks = next.blocks;
+        for (const fc of event.fileChanges) {
+            const fileBlock = {
+                kind: 'file_change',
+                itemId: event.itemId,
+                path: fc.path,
+                operation: fc.kind === 'add' ? 'create' : fc.kind === 'delete' ? 'delete' : 'edit',
+                diff: fc.diff,
+                timestamp: ts,
+                ...(complete ? { completedAt: ts } : {}),
+            };
+            // 同一 item 的同一路径原地替换（权威 diff 校正），新路径/新 item 追加。
+            blocks = upsertSnapshotBlock(blocks, (b) => b.kind === 'file_change' && b.itemId === event.itemId && b.path === fc.path, () => fileBlock, () => fileBlock, !complete);
+        }
+        next = { ...next, blocks: keepLatestBlocks(blocks) };
+    }
+    return next;
+}
+/**
+ * Replace the last block matching `predicate` with `make`; if none matches,
+ * append a block built by `fallback`. Snapshot semantics for app-server
+ * turn_diff streams.
+ *
+ * `moveToEndWhenNotLast`: 当命中块不在数组末尾且为流式更新（complete=false）
+ * 时，把更新后的块移到末尾。正常协议下 item 串行、流式块总是最后一个，
+ * 此分支不触发；若真实 server 在同一个 item 上跨其他 item 续流 delta（违反
+ * item 生命周期），流式内容仍会出现在卡片底部，而不是钉在旧位置。
+ */
+function upsertSnapshotBlock(blocks, predicate, fallback, update, moveToEndWhenNotLast = false) {
+    for (let i = blocks.length - 1; i >= 0; i--) {
+        if (predicate(blocks[i])) {
+            const copy = blocks.slice();
+            copy[i] = update ? update(blocks[i]) : fallback();
+            if (moveToEndWhenNotLast && i < copy.length - 1) {
+                const [moved] = copy.splice(i, 1);
+                copy.push(moved);
+            }
+            return copy;
+        }
+    }
+    return [...blocks, fallback()];
+}
 /** Handle system init and compact_boundary events. */
 function reduceSystemEvent(state, event) {
     if (event.type !== 'system')
@@ -61,11 +257,23 @@ function reduceSystemEvent(state, event) {
 function reduceResultEvent(state, event) {
     if (event.type !== 'result')
         return state;
+    // Pre-init result guard: Claude CLI --resume emits a historical result (from
+    // the previous turn) before sending system.init for the new run. Without this
+    // guard, that stale result would prematurely transition to 'finalizing',
+    // freezing the card at "⏳ 等待进程退出" for the entire run duration.
+    // sessionId is set by system.init; undefined means init hasn't arrived yet.
+    if (state.sessionId === undefined)
+        return state;
     const resultEvent = event;
     const incomingSubtype = event.subtype;
     const incomingErrorMsg = incomingSubtype === 'error' ? (resultEvent.errorMessage ?? 'Agent 返回错误结果') : undefined;
-    // 合并 subtype：error 优先（任一为 error 即 error）
-    const mergedSubtype = state.resultSubtype === 'error' || incomingSubtype === 'error' ? 'error' : 'success';
+    // 合并 subtype：error 优先，其次 interrupted（任一为 error 即 error；
+    // 否则任一为 interrupted 即 interrupted；interrupted 不得并入 success）。
+    const mergedSubtype = state.resultSubtype === 'error' || incomingSubtype === 'error'
+        ? 'error'
+        : state.resultSubtype === 'interrupted' || incomingSubtype === 'interrupted'
+            ? 'interrupted'
+            : 'success';
     // 合并 errorMsg：首个非 undefined 胜出（existing ?? incoming）
     const mergedErrorMsg = state.errorMsg ?? incomingErrorMsg;
     return {

package/dist/config/dir.d.ts

@@ -4,6 +4,7 @@ interface CliArgs {
     dev?: boolean;
     help?: boolean;
     version?: boolean;
+    update?: boolean;
 }
 export declare function resolveConfigDir(configDirArg: string | undefined): string;
 export declare function getConfigDir(): string;

package/dist/config/dir.js

@@ -52,6 +52,9 @@ export function parseCliArgs(args = process.argv.slice(2)) {
         else if (arg === '--dev') {
             result.dev = true;
         }
+        else if (arg === '--update') {
+            result.update = true;
+        }
     }
     return result;
 }
@@ -77,6 +80,7 @@ export function printHelp() {
         '  --config-dir <path>   自定义配置目录（默认 ~/.lark-remote，可用于同机多实例）',
         '  --settings <path>     指定 Claude 配置文件路径',
         '  --dev                 开发模式：标记从源码 bun src/index.ts 启动（看门狗据此选择拉起方式）',
+        '  --update              升级到最新版本后退出（用于 cron/脚本自动化升级）',
         '  -h, --help            显示本帮助信息',
         '  -v, --version         显示版本号',
     ];

package/dist/config/index.d.ts

@@ -10,6 +10,8 @@ export declare const PI_THINKING_LEVELS: readonly ["off", "minimal", "low", "med
  * instead of re-literalizing `5000` (Clean Code P3-1, G25).
  */
 export declare const DEFAULT_STOP_GRACE_MS: 5000;
+/** Codex app-server turn idle timeout default (minutes). */
+export declare const DEFAULT_TURN_IDLE_TIMEOUT_MINUTES: 10;
 /** 模型 ID → alias 映射。 */
 export declare const MODEL_ID_TO_ALIAS: Record<string, string>;
 /** alias → model ID 反向映射。 */
@@ -31,6 +33,26 @@ export declare const CodexConfigSchema: z.ZodObject<{
     modelProvider: z.ZodOptional<z.ZodString>;
     reasoningEffort: z.ZodOptional<z.ZodString>;
     stopGraceMs: z.ZodDefault<z.ZodNumber>;
+    serviceMode: z.ZodOptional<z.ZodEnum<{
+        exec: "exec";
+        "app-server": "app-server";
+    }>>;
+    approvalPolicy: z.ZodOptional<z.ZodEnum<{
+        untrusted: "untrusted";
+        "on-request": "on-request";
+        never: "never";
+    }>>;
+    sandbox: z.ZodOptional<z.ZodEnum<{
+        "danger-full-access": "danger-full-access";
+        "read-only": "read-only";
+        "workspace-write": "workspace-write";
+    }>>;
+    appServer: z.ZodOptional<z.ZodObject<{
+        binary: z.ZodDefault<z.ZodString>;
+        requestTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        idleTtlMs: z.ZodDefault<z.ZodNumber>;
+        turnIdleTimeoutMinutes: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 /** OpenCode-specific configuration (run mode: opencode run --format json --auto). */
 declare const OpencodeConfigSchema: z.ZodObject<{
@@ -82,6 +104,26 @@ export declare const AppConfigSchema: z.ZodObject<{
             modelProvider: z.ZodOptional<z.ZodString>;
             reasoningEffort: z.ZodOptional<z.ZodString>;
             stopGraceMs: z.ZodDefault<z.ZodNumber>;
+            serviceMode: z.ZodOptional<z.ZodEnum<{
+                exec: "exec";
+                "app-server": "app-server";
+            }>>;
+            approvalPolicy: z.ZodOptional<z.ZodEnum<{
+                untrusted: "untrusted";
+                "on-request": "on-request";
+                never: "never";
+            }>>;
+            sandbox: z.ZodOptional<z.ZodEnum<{
+                "danger-full-access": "danger-full-access";
+                "read-only": "read-only";
+                "workspace-write": "workspace-write";
+            }>>;
+            appServer: z.ZodOptional<z.ZodObject<{
+                binary: z.ZodDefault<z.ZodString>;
+                requestTimeoutMs: z.ZodDefault<z.ZodNumber>;
+                idleTtlMs: z.ZodDefault<z.ZodNumber>;
+                turnIdleTimeoutMinutes: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
         }, z.core.$strip>>;
         opencode: z.ZodOptional<z.ZodObject<{
             providerID: z.ZodDefault<z.ZodString>;
@@ -151,6 +193,7 @@ export declare const AppConfigSchema: z.ZodObject<{
         pi: "pi";
         kimi: "kimi";
     }>>;
+    checkUpdateOnStartup: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>;
 export type AppConfig = z.infer<typeof AppConfigSchema>;
 export declare function loadConfig(configPath: string): AppConfig;

package/dist/config/index.js

@@ -16,6 +16,7 @@ const DEFAULTS = {
     CLAUDE_MODEL: 'claude-opus-4-8',
     STOP_GRACE_MS: 5000,
     IDLE_WATCHDOG_MINUTES: 15,
+    TURN_IDLE_TIMEOUT_MINUTES: 10,
 };
 /**
  * Default SIGTERM→SIGKILL grace period (ms). Exported so runners (SpawningRunner)
@@ -23,6 +24,8 @@ const DEFAULTS = {
  * instead of re-literalizing `5000` (Clean Code P3-1, G25).
  */
 export const DEFAULT_STOP_GRACE_MS = DEFAULTS.STOP_GRACE_MS;
+/** Codex app-server turn idle timeout default (minutes). */
+export const DEFAULT_TURN_IDLE_TIMEOUT_MINUTES = DEFAULTS.TURN_IDLE_TIMEOUT_MINUTES;
 /** 模型 ID → alias 映射。 */
 export const MODEL_ID_TO_ALIAS = {
     'claude-opus-4-8': 'opus',
@@ -47,13 +50,24 @@ const ClaudeConfigSchema = z.object({
     // permissionMode 硬编码为 bypassPermissions（runner 内部），不通过 config 配置
     stopGraceMs: z.number().int().min(0).default(DEFAULTS.STOP_GRACE_MS),
 });
+/** Codex app-server connection configuration. */
+const CodexAppServerConfigSchema = z.object({
+    /** Path to the codex binary for app-server mode. */
+    binary: z.string().default('codex'),
+    /** Request timeout in milliseconds. */
+    requestTimeoutMs: z.number().int().min(0).default(60000),
+    /** Idle TTL for connection pool in milliseconds. */
+    idleTtlMs: z.number().int().min(0).default(1800000),
+    /** Turn idle timeout in minutes: no app-server output for this long triggers
+     *  turn/interrupt and fails the run. 0 disables the timeout. */
+    turnIdleTimeoutMinutes: z.number().int().min(0).default(DEFAULT_TURN_IDLE_TIMEOUT_MINUTES),
+});
 /** Codex-specific configuration. */
 export const CodexConfigSchema = z.object({
     /** model to use. Undefined → codex reads from its config.toml. */
     model: z.string().optional(),
     /** model provider, e.g. 'volcengine-coding-plan'. Undefined → codex reads from its config.toml. */
     modelProvider: z.string().optional(),
-    // approvalPolicy 和 sandboxPolicy 在 runner 内硬编码（exec 模式使用 approval_policy=never）
     /**
      * Reasoning effort level。codex 标准档位 minimal/low/medium/high/xhigh/max/ultra
      * 之外还接受 none 与模型自定义值（ReasoningEffort::Custom），目录声明什么就存什么
@@ -63,6 +77,14 @@ export const CodexConfigSchema = z.object({
     reasoningEffort: z.string().min(1).optional(),
     /** Stop grace period in milliseconds. */
     stopGraceMs: z.number().int().min(0).default(5000),
+    /** Service mode: 'exec' (spawn-per-message) or 'app-server' (persistent connection). */
+    serviceMode: z.enum(['exec', 'app-server']).optional(),
+    /** Approval policy (Codex 官方 AskForApproval 标准值). 仅 app-server 模式有效（exec 固定 approval_policy="never"）。 */
+    approvalPolicy: z.enum(['untrusted', 'on-request', 'never']).optional(),
+    /** Sandbox mode (Codex 官方 SandboxMode 标准值). 仅 app-server 模式有效（exec 固定 --sandbox danger-full-access）。 */
+    sandbox: z.enum(['read-only', 'workspace-write', 'danger-full-access']).optional(),
+    /** App-server connection configuration. */
+    appServer: CodexAppServerConfigSchema.optional(),
 });
 /** OpenCode-specific configuration (run mode: opencode run --format json --auto). */
 const OpencodeConfigSchema = z.object({
@@ -153,6 +175,8 @@ export const AppConfigSchema = z.object({
     logging: LoggingConfigSchema.default(LoggingConfigSchema.parse({})),
     /** Default agent for new runs. */
     defaultAgent: z.enum(['claude', 'codex', 'opencode', 'pi', 'kimi']).default('claude'),
+    /** Check for updates on bridge startup (default: false). */
+    checkUpdateOnStartup: z.boolean().default(false),
 });
 const TEMPLATE = `feishu:
   appId: ""

package/dist/connector/index.d.ts

@@ -68,6 +68,11 @@ export declare class FeishuConnector {
     /** Format error for logging without causing circular serialization */
     private formatError;
     addReaction(messageId: string, emoji: string): Promise<void>;
+    /**
+     * Remove a reaction by emoji (e.g. retract the Typing indicator).
+     * The SDK resolves the reaction id internally; missing reaction is a no-op.
+     */
+    removeReactionByEmoji(messageId: string, emoji: string): Promise<void>;
     /**
      * Upload a file to Feishu and send it to the specified chat.
      * Uses the im/v1/files upload API.

package/dist/connector/index.js

@@ -3,7 +3,20 @@ import { getLogger } from '../logger/index.js';
 import { MAX_FILE_UPLOAD_SIZE } from './file-limits.js';
 import axios from 'axios';
 import fs from 'node:fs';
+import https from 'node:https';
 import FormData from 'form-data';
+/**
+ * Dedicated https.Agent with keepAlive disabled for sendFile's three axios
+ * calls (token, upload, send). Bun's Node.js http compat layer has a bug
+ * where it reuses keep-alive sockets that the server has already RST'd —
+ * the write goes into a dead socket and the caller gets ECONNRESET after
+ * ~30s. Node.js proper does not exhibit this because it checks socket
+ * health before reuse. Disabling keep-alive forces a fresh TCP+TLS
+ * handshake per request, eliminating the stale-socket path at the cost of
+ * one extra round-trip per file send (acceptable for an infrequent
+ * operation).
+ */
+const noKeepAliveAgent = new https.Agent({ keepAlive: false });
 /**
  * dedup 缓存 TTL（毫秒）。控制飞书事件去重窗口，全局作用于 message + cardAction。
  *
@@ -251,6 +264,18 @@ export class FeishuConnector {
             getLogger().error('[feishu] addReaction failed:', this.formatError(err));
         }
     }
+    /**
+     * Remove a reaction by emoji (e.g. retract the Typing indicator).
+     * The SDK resolves the reaction id internally; missing reaction is a no-op.
+     */
+    async removeReactionByEmoji(messageId, emoji) {
+        try {
+            await this.channel.removeReactionByEmoji(messageId, emoji);
+        }
+        catch (err) {
+            getLogger().error('[feishu] removeReactionByEmoji failed:', this.formatError(err));
+        }
+    }
     /**
      * Upload a file to Feishu and send it to the specified chat.
      * Uses the im/v1/files upload API.
@@ -288,18 +313,22 @@ export class FeishuConnector {
             form.append('file_name', fileName);
             form.append('file_type', 'stream');
             // P2-18: timeout on the upload (large file, slow link) — 120s.
+            // httpsAgent: noKeepAlive — prevents Bun from reusing a server-RST'd
+            // keep-alive socket (ECONNRESET after ~30s; see noKeepAliveAgent docs).
             const uploadResp = await axios.post('https://open.feishu.cn/open-apis/im/v1/files', form, {
                 headers: {
                     ...form.getHeaders(),
                     Authorization: `Bearer ${accessToken}`,
                 },
                 timeout: 120000,
+                httpsAgent: noKeepAliveAgent,
             });
             if (uploadResp.data.code !== 0) {
                 throw new Error(`File upload failed: ${uploadResp.data.msg}`);
             }
             const fileKey = uploadResp.data.data.file_key;
             // Send file message. P2-18: timeout 30s.
+            // httpsAgent: noKeepAlive — same Bun keep-alive fix as upload above.
             const sendResp = await axios.post('https://open.feishu.cn/open-apis/im/v1/messages', {
                 receive_id: chatId,
                 msg_type: 'file',
@@ -311,6 +340,7 @@ export class FeishuConnector {
                 },
                 params: { receive_id_type: 'chat_id' },
                 timeout: 30000,
+                httpsAgent: noKeepAliveAgent,
             });
             if (sendResp.data.code !== 0) {
                 throw new Error(`File message failed: ${sendResp.data.msg}`);
@@ -347,12 +377,14 @@ export class FeishuConnector {
             return this.cachedToken;
         }
         // P2-18: timeout 30s on the token request.
+        // httpsAgent: noKeepAlive — same Bun keep-alive fix as upload above.
         const tokenResp = await axios.post('https://open.feishu.cn/open-apis/auth/v3/tenant_access_token/internal', {
             app_id: this.appId,
             app_secret: this.appSecret,
         }, {
             headers: { 'Content-Type': 'application/json; charset=utf-8' },
             timeout: 30000,
+            httpsAgent: noKeepAliveAgent,
         });
         if (tokenResp.data.code !== 0) {
             throw new Error(`Failed to get tenant_access_token: ${tokenResp.data.msg ?? 'unknown error'}`);