lark-remote 0.1.6 → 0.1.7

package/dist/session/pi/sessions.js

@@ -4,8 +4,8 @@ import os from 'node:os';
 import { findJsonlLine, scanJsonlLines, readJsonlLinesFromOffset } from '../common/jsonl.js';
 import { extractContentBlocks } from '../common/content-blocks.js';
 import { UsageAccumulator } from '../common/usage-accumulator.js';
-import { truncate } from '../../card/card-shared.js';
 import { STALE_MS } from '../common/constants.js';
+import { capEvents, paginate } from '../common/pagination.js';
 function defaultPiDir() {
     return path.join(os.homedir(), '.pi', 'agent');
 }
@@ -24,7 +24,7 @@ const PI_LIST_TTL_MS = 5000;
 const PI_LIST_MAX_ENTRIES = 32;
 const piListCache = new Map();
 /** Pi-specific field-name mapping for content block extraction. */
-const PI_MAPPING = {
+export const PI_MAPPING = {
     toolUseType: 'toolCall',
     toolResultType: 'toolResult',
     toolInputField: 'arguments',
@@ -187,9 +187,10 @@ function piScalarScan(filePath) {
     return {
         tailOffset,
         usage: buildPiUsage(acc),
-        displayTitle: lastUserText
-            ? truncate(lastUserText, 200, { normalizeWhitespace: true })
-            : undefined,
+        // Whitespace-normalized single-line display title (no length truncation —
+        // the consumer truncates). Normalization collapses the skill-injection
+        // newlines so the title stays on one line.
+        displayTitle: lastUserText ? lastUserText.replace(/\s+/g, ' ').trim() : undefined,
     };
 }
 /**
@@ -273,19 +274,19 @@ function extractPiEventsFromTail(tailLines) {
  */
 export class PiSessionReader {
     piDir;
+    /** 会话目录（public：测试可重定向到 fixture 目录，替代 as any）。 */
     sessionsDir;
     constructor(opts = {}) {
         this.piDir = opts.piDir ?? defaultPiDir();
         this.sessionsDir = path.join(this.piDir, 'sessions');
     }
     listSessions(cwd, opts) {
-        const limit = opts?.limit ?? 20;
-        const offset = Math.max(0, opts?.offset ?? 0);
         // SCAN: filesystem is the source of truth for pi sessions.
         const scanned = this.listSessionsByScan(cwd);
+        const { items, total } = paginate(scanned, opts ?? {});
         return {
-            sessions: scanned.slice(offset, offset + limit),
-            total: scanned.length,
+            sessions: items,
+            total,
         };
     }
     getNewestSession(cwd) {
@@ -322,12 +323,7 @@ export class PiSessionReader {
         // Apply maxEvents cap: keep the LAST N events (most recent), matching
         // CodexSessionReader's slice(-maxEvents). maxEvents limits the catch-up
         // tail so auto-resume cards don't load the entire session.
-        // P2-7: maxEvents <= 0 returns [] (guards `slice(-0)` full-array trap).
-        const cappedEvents = opts?.maxEvents !== undefined
-            ? opts.maxEvents <= 0
-                ? []
-                : events.slice(-opts.maxEvents)
-            : events;
+        const cappedEvents = capEvents(events, opts?.maxEvents);
         return {
             events: cappedEvents,
             usage: scan.usage,
@@ -376,7 +372,7 @@ export class PiSessionReader {
                 const sessionId = stem.includes('_') ? stem.slice(stem.lastIndexOf('_') + 1) : stem;
                 sessions.push({
                     sessionId,
-                    summary: truncate(summarizePiSession(full), 60, { normalizeWhitespace: true }),
+                    summary: summarizePiSession(full),
                     mtime: st.mtimeMs,
                 });
             }

package/dist/session/session-store.d.ts

@@ -48,6 +48,16 @@ export declare class SessionStore {
     /** 用户意图移动了全部 agent 的 session 指针（/cd、/ws use 的 setCwd）。 */
     private bumpUserEpoch;
     constructor(persistPath?: string, defaultAgent?: AgentKind);
+    /** A fresh, empty session entry (default factory). */
+    private static emptyEntry;
+    /**
+     * Clone the user's entry, apply `mutate` to it, and store the result.
+     * Creates a fresh empty entry when the user has none. All the per-field
+     * setters (clearSessionId / setPreviousSessionId / setArrivalSessionId /
+     * setCwd / setSessionId / setSessionIdAndCwd / setSessionIdAndSessionCwd)
+     * use this to avoid each re-spelling the "clone entry, tweak one Map" dance.
+     */
+    private mutateEntry;
     get(userId: string): SessionEntry | undefined;
     set(userId: string, entry: SessionEntry): void;
     delete(userId: string): void;
@@ -79,7 +89,7 @@ export declare class SessionStore {
     getSessionCwd(userId: string, agent?: AgentKind): string | undefined;
     /** Set sessionId and sessionCwd for a specific agent, without touching cwd */
     setSessionIdAndSessionCwd(userId: string, agent: AgentKind, sessionId: string, sessionCwd: string): void;
-    /** Persisted format: only cwd per user (sessionId is process-scoped) */
+    /** Persisted format: cwd + sessions + previous/arrival session maps. */
     private load;
     private autoPersist;
 }

package/dist/session/session-store.js

@@ -53,6 +53,37 @@ export class SessionStore {
         if (persistPath)
             this.load();
     }
+    /** A fresh, empty session entry (default factory). */
+    static emptyEntry(cwd = '') {
+        return {
+            sessions: new Map(),
+            previousSessions: new Map(),
+            sessionCwds: new Map(),
+            arrivalSessions: new Map(),
+            cwd,
+        };
+    }
+    /**
+     * Clone the user's entry, apply `mutate` to it, and store the result.
+     * Creates a fresh empty entry when the user has none. All the per-field
+     * setters (clearSessionId / setPreviousSessionId / setArrivalSessionId /
+     * setCwd / setSessionId / setSessionIdAndCwd / setSessionIdAndSessionCwd)
+     * use this to avoid each re-spelling the "clone entry, tweak one Map" dance.
+     */
+    mutateEntry(userId, mutate) {
+        const current = this.sessions.get(userId);
+        const base = current
+            ? {
+                sessions: new Map(current.sessions),
+                previousSessions: new Map(current.previousSessions),
+                sessionCwds: new Map(current.sessionCwds),
+                arrivalSessions: new Map(current.arrivalSessions),
+                cwd: current.cwd,
+            }
+            : SessionStore.emptyEntry();
+        this.sessions.set(userId, mutate(base));
+        this.autoPersist();
+    }
     get(userId) {
         return this.sessions.get(userId);
     }
@@ -69,23 +100,13 @@ export class SessionStore {
         // 无条件 bump：空→空也必须可检测（事故场景正是 run 以 (none) 启动，
         // /new 后 store 仍为空，值比较会误判「没变」）。entry 不存在同样 bump。
         this.bumpSessionEpoch(userId, agent);
-        const entry = this.sessions.get(userId);
-        if (entry) {
-            const newSessions = new Map(entry.sessions);
-            newSessions.set(agent, '');
-            const newSessionCwds = new Map(entry.sessionCwds);
+        this.mutateEntry(userId, (entry) => {
+            entry.sessions.set(agent, '');
             if (opts?.clearSessionCwd) {
-                newSessionCwds.set(agent, '');
+                entry.sessionCwds.set(agent, '');
             }
-            this.sessions.set(userId, {
-                sessions: newSessions,
-                previousSessions: entry.previousSessions,
-                sessionCwds: newSessionCwds,
-                arrivalSessions: entry.arrivalSessions,
-                cwd: entry.cwd,
-            });
-        }
-        this.autoPersist();
+            return entry;
+        });
     }
     /** Get previous sessionId for a specific agent (stored when switching away) */
     getPreviousSessionId(userId, agent) {
@@ -99,46 +120,17 @@ export class SessionStore {
     }
     /** Set previous sessionId for a specific agent (for potential restore when switching back) */
     setPreviousSessionId(userId, agent, sessionId) {
-        const entry = this.sessions.get(userId);
-        if (entry) {
-            const newPrevious = new Map(entry.previousSessions);
-            newPrevious.set(agent, sessionId);
-            this.sessions.set(userId, {
-                sessions: entry.sessions,
-                previousSessions: newPrevious,
-                sessionCwds: entry.sessionCwds,
-                arrivalSessions: entry.arrivalSessions,
-                cwd: entry.cwd,
-            });
-        }
-        else {
-            const newPrevious = new Map();
-            newPrevious.set(agent, sessionId);
-            this.sessions.set(userId, {
-                sessions: new Map(),
-                previousSessions: newPrevious,
-                sessionCwds: new Map(),
-                arrivalSessions: new Map(),
-                cwd: '',
-            });
-        }
-        this.autoPersist();
+        this.mutateEntry(userId, (entry) => {
+            entry.previousSessions.set(agent, sessionId);
+            return entry;
+        });
     }
     /** Clear previous sessionId for a specific agent */
     clearPreviousSessionId(userId, agent) {
-        const entry = this.sessions.get(userId);
-        if (entry) {
-            const newPrevious = new Map(entry.previousSessions);
-            newPrevious.delete(agent);
-            this.sessions.set(userId, {
-                sessions: entry.sessions,
-                previousSessions: newPrevious,
-                sessionCwds: entry.sessionCwds,
-                arrivalSessions: entry.arrivalSessions,
-                cwd: entry.cwd,
-            });
-        }
-        this.autoPersist();
+        this.mutateEntry(userId, (entry) => {
+            entry.previousSessions.delete(agent);
+            return entry;
+        });
     }
     /** Get the arrival baseline sessionId for a specific agent ('' and missing → undefined) */
     getArrivalSessionId(userId, agent) {
@@ -152,60 +144,26 @@ export class SessionStore {
     }
     /** Set the arrival baseline for a specific agent ('' explicitly clears the arrival baseline) */
     setArrivalSessionId(userId, agent, sessionId) {
-        const entry = this.sessions.get(userId);
-        if (entry) {
-            const newArrival = new Map(entry.arrivalSessions);
-            newArrival.set(agent, sessionId);
-            this.sessions.set(userId, {
-                sessions: entry.sessions,
-                previousSessions: entry.previousSessions,
-                sessionCwds: entry.sessionCwds,
-                arrivalSessions: newArrival,
-                cwd: entry.cwd,
-            });
-        }
-        else {
-            const newArrival = new Map();
-            newArrival.set(agent, sessionId);
-            this.sessions.set(userId, {
-                sessions: new Map(),
-                previousSessions: new Map(),
-                sessionCwds: new Map(),
-                arrivalSessions: newArrival,
-                cwd: '',
-            });
-        }
-        this.autoPersist();
+        this.mutateEntry(userId, (entry) => {
+            entry.arrivalSessions.set(agent, sessionId);
+            return entry;
+        });
     }
     /** Set cwd for a user, clearing all sessionIds (§9.1) */
     setCwd(userId, cwd) {
         // §9.1 setCwd 清全部 agent 的 sessionId → user 级 bump，覆盖 sessions
         // map 里还没有 key 的 agent（run 刚启动、首个 init 未写回时 /cd 的边界）。
         this.bumpUserEpoch(userId);
-        const entry = this.sessions.get(userId);
-        if (entry) {
-            const newSessions = new Map(entry.sessions);
-            for (const key of newSessions.keys()) {
-                newSessions.set(key, '');
+        this.mutateEntry(userId, (entry) => {
+            for (const key of entry.sessions.keys()) {
+                entry.sessions.set(key, '');
             }
-            this.sessions.set(userId, {
-                sessions: newSessions,
-                previousSessions: new Map(),
-                sessionCwds: new Map(),
-                arrivalSessions: new Map(),
-                cwd,
-            });
-        }
-        else {
-            this.sessions.set(userId, {
-                sessions: new Map(),
-                previousSessions: new Map(),
-                sessionCwds: new Map(),
-                arrivalSessions: new Map(),
-                cwd,
-            });
-        }
-        this.autoPersist();
+            entry.previousSessions = new Map();
+            entry.sessionCwds = new Map();
+            entry.arrivalSessions = new Map();
+            entry.cwd = cwd;
+            return entry;
+        });
     }
     /** Get cwd for a user, or undefined if no session */
     getCwd(userId) {
@@ -224,61 +182,23 @@ export class SessionStore {
     /** Set sessionId for a specific agent, optionally with cwd */
     setSessionId(userId, agent, sessionId, cwd) {
         this.bumpSessionEpoch(userId, agent);
-        const entry = this.sessions.get(userId);
-        if (entry) {
-            const newSessions = new Map(entry.sessions);
-            newSessions.set(agent, sessionId);
-            this.sessions.set(userId, {
-                sessions: newSessions,
-                previousSessions: entry.previousSessions,
-                sessionCwds: entry.sessionCwds,
-                arrivalSessions: entry.arrivalSessions,
-                cwd: cwd ?? entry.cwd,
-            });
-        }
-        else {
-            const newSessions = new Map();
-            newSessions.set(agent, sessionId);
-            this.sessions.set(userId, {
-                sessions: newSessions,
-                previousSessions: new Map(),
-                sessionCwds: new Map(),
-                arrivalSessions: new Map(),
-                cwd: cwd ?? '',
-            });
-        }
-        this.autoPersist();
+        this.mutateEntry(userId, (entry) => {
+            entry.sessions.set(agent, sessionId);
+            if (cwd !== undefined)
+                entry.cwd = cwd;
+            return entry;
+        });
     }
     /** Set sessionId for a specific agent and cwd together */
     setSessionIdAndCwd(userId, agent, sessionId, cwd, sessionCwd) {
-        const entry = this.sessions.get(userId);
-        if (entry) {
-            const newSessions = new Map(entry.sessions);
-            newSessions.set(agent, sessionId);
-            const newSessionCwds = new Map(entry.sessionCwds);
+        this.mutateEntry(userId, (entry) => {
+            entry.sessions.set(agent, sessionId);
             if (sessionCwd !== undefined) {
-                newSessionCwds.set(agent, sessionCwd);
+                entry.sessionCwds.set(agent, sessionCwd);
             }
-            this.sessions.set(userId, {
-                sessions: newSessions,
-                previousSessions: entry.previousSessions,
-                sessionCwds: newSessionCwds,
-                arrivalSessions: entry.arrivalSessions,
-                cwd,
-            });
-        }
-        else {
-            const newSessions = new Map();
-            newSessions.set(agent, sessionId);
-            this.sessions.set(userId, {
-                sessions: newSessions,
-                previousSessions: new Map(),
-                sessionCwds: new Map(),
-                arrivalSessions: new Map(),
-                cwd,
-            });
-        }
-        this.autoPersist();
+            entry.cwd = cwd;
+            return entry;
+        });
     }
     /** Get sessionCwd for a specific agent, or undefined if not set */
     getSessionCwd(userId, agent = 'claude') {
@@ -292,37 +212,14 @@ export class SessionStore {
     }
     /** Set sessionId and sessionCwd for a specific agent, without touching cwd */
     setSessionIdAndSessionCwd(userId, agent, sessionId, sessionCwd) {
-        const entry = this.sessions.get(userId);
-        if (entry) {
-            const newSessions = new Map(entry.sessions);
-            newSessions.set(agent, sessionId);
-            const newSessionCwds = new Map(entry.sessionCwds);
-            newSessionCwds.set(agent, sessionCwd);
-            this.sessions.set(userId, {
-                sessions: newSessions,
-                previousSessions: entry.previousSessions,
-                sessionCwds: newSessionCwds,
-                arrivalSessions: entry.arrivalSessions,
-                cwd: entry.cwd,
-            });
-        }
-        else {
-            const newSessions = new Map();
-            newSessions.set(agent, sessionId);
-            const newSessionCwds = new Map();
-            newSessionCwds.set(agent, sessionCwd);
-            this.sessions.set(userId, {
-                sessions: newSessions,
-                previousSessions: new Map(),
-                sessionCwds: newSessionCwds,
-                arrivalSessions: new Map(),
-                cwd: '',
-            });
-        }
-        this.autoPersist();
+        this.mutateEntry(userId, (entry) => {
+            entry.sessions.set(agent, sessionId);
+            entry.sessionCwds.set(agent, sessionCwd);
+            return entry;
+        });
     }
     // -- Persistence helpers --
-    /** Persisted format: only cwd per user (sessionId is process-scoped) */
+    /** Persisted format: cwd + sessions + previous/arrival session maps. */
     load() {
         if (!this.persistPath)
             return;

package/dist/update/index.d.ts

@@ -5,6 +5,6 @@
  * package installation (detect package manager + global install),
  * and the combined workflow for the /update command and --update CLI flag.
  */
-export { isNewer, checkLatestVersion, type VersionCheckResult, type UpdateCache, CACHE_TTL_MS, } from './version-check.js';
-export { detectPackageManager, runInstallLatest, type PackageManager, type InstallResult, } from './install.js';
+export { isNewer, checkLatestVersion, type VersionCheckResult, type UpdateCache, } from './version-check.js';
+export { runInstallLatest, type PackageManager, type InstallResult } from './install.js';
 export { formatUpdateHint } from './startup-hint.js';

package/dist/update/index.js

@@ -5,7 +5,7 @@
  * package installation (detect package manager + global install),
  * and the combined workflow for the /update command and --update CLI flag.
  */
-export { isNewer, checkLatestVersion, CACHE_TTL_MS, } from './version-check.js';
-export { detectPackageManager, runInstallLatest, } from './install.js';
+export { isNewer, checkLatestVersion, } from './version-check.js';
+export { runInstallLatest } from './install.js';
 export { formatUpdateHint } from './startup-hint.js';
 //# sourceMappingURL=index.js.map

package/dist/update/install.d.ts

@@ -8,14 +8,32 @@ export interface InstallResult {
 /** Type signature matching execFile's callback style. */
 type ExecFileCallback = (error: Error | null, stdout: string | Buffer, stderr: string | Buffer) => void;
 type ExecFileFn = (file: string, args: readonly string[], options: object, callback: ExecFileCallback) => void;
+/**
+ * Infer the installing package manager from the real path of the running
+ * script (e.g. `.../node_modules/lark-remote/dist/index.js`).
+ *
+ * Layout markers (check order matters — bun/pnpm paths also contain
+ * `/node_modules/lark-remote/`):
+ * - bun:  `~/.bun/install/global/node_modules/lark-remote/...`
+ * - pnpm: `<global>/node_modules/.pnpm/lark-remote@<ver>/node_modules/lark-remote/...`
+ * - npm:  `<prefix>/lib/node_modules/lark-remote/...` (POSIX) or
+ *         `<prefix>/node_modules/lark-remote/...` (Windows)
+ *
+ * Returns null when the path has no marker (e.g. running from a source
+ * checkout in dev mode).
+ */
+export declare function inferPackageManagerFromPath(scriptPath: string): PackageManager | null;
 /**
  * Detect which package manager to use for global install.
  *
  * Priority:
  * 1. Environment variable override (LARK_REMOTE_MANAGED_BY)
- * 2. `which` availability: npm → bun → pnpm
+ * 2. Install location of the running script (upgrades must target the same
+ *    copy that is actually running — a different PM would install a second
+ *    copy and leave the running one stale)
+ * 3. `which` availability: npm → bun → pnpm
  */
-export declare function detectPackageManager(): PackageManager | null;
+export declare function detectPackageManager(scriptPath?: string): PackageManager | null;
 /**
  * Run the global install command to upgrade lark-remote to the latest version.
  *

package/dist/update/install.js

@@ -1,18 +1,60 @@
 import { execFile, execFileSync } from 'node:child_process';
+import fs from 'node:fs';
 import { getLogger } from '../logger/index.js';
+/**
+ * Infer the installing package manager from the real path of the running
+ * script (e.g. `.../node_modules/lark-remote/dist/index.js`).
+ *
+ * Layout markers (check order matters — bun/pnpm paths also contain
+ * `/node_modules/lark-remote/`):
+ * - bun:  `~/.bun/install/global/node_modules/lark-remote/...`
+ * - pnpm: `<global>/node_modules/.pnpm/lark-remote@<ver>/node_modules/lark-remote/...`
+ * - npm:  `<prefix>/lib/node_modules/lark-remote/...` (POSIX) or
+ *         `<prefix>/node_modules/lark-remote/...` (Windows)
+ *
+ * Returns null when the path has no marker (e.g. running from a source
+ * checkout in dev mode).
+ */
+export function inferPackageManagerFromPath(scriptPath) {
+    const p = scriptPath.replace(/\\/g, '/');
+    if (p.includes('/.bun/install/global/'))
+        return 'bun';
+    if (p.includes('/.pnpm/lark-remote@'))
+        return 'pnpm';
+    if (p.includes('/node_modules/lark-remote/'))
+        return 'npm';
+    return null;
+}
 /**
  * Detect which package manager to use for global install.
  *
  * Priority:
  * 1. Environment variable override (LARK_REMOTE_MANAGED_BY)
- * 2. `which` availability: npm → bun → pnpm
+ * 2. Install location of the running script (upgrades must target the same
+ *    copy that is actually running — a different PM would install a second
+ *    copy and leave the running one stale)
+ * 3. `which` availability: npm → bun → pnpm
  */
-export function detectPackageManager() {
+export function detectPackageManager(scriptPath) {
     // 1. Env override (highest priority)
     const env = process.env.LARK_REMOTE_MANAGED_BY;
     if (env === 'npm' || env === 'bun' || env === 'pnpm')
         return env;
-    // 2. which availability detection
+    // 2. Infer from where this process was loaded from
+    const raw = scriptPath ?? process.argv[1];
+    if (raw) {
+        let resolved = raw;
+        try {
+            resolved = fs.realpathSync(raw);
+        }
+        catch {
+            // Keep raw path (e.g. synthetic path in tests)
+        }
+        const inferred = inferPackageManagerFromPath(resolved);
+        if (inferred)
+            return inferred;
+    }
+    // 3. which availability fallback
     const candidates = ['npm', 'bun', 'pnpm'];
     for (const cmd of candidates) {
         try {
@@ -73,10 +115,12 @@ export function runInstallLatest(opts) {
                 logger.error(`[update] install failed: ${msg}`);
                 // Detect common errors and give actionable advice
                 if (msg.includes('EACCES') || msg.includes('permission')) {
-                    resolve({
-                        success: false,
-                        error: `权限不足，尝试 sudo ${cmd} ${args.join(' ')}`,
-                    });
+                    // bun/pnpm install into the user dir — sudo is wrong advice there
+                    // (it would install into root's global dir instead).
+                    const hint = pm === 'npm'
+                        ? `权限不足，尝试 sudo ${cmd} ${args.join(' ')}`
+                        : `权限不足，请检查 ${cmd} 全局安装目录的写权限`;
+                    resolve({ success: false, error: hint });
                     return;
                 }
                 resolve({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lark-remote",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "Feishu (Lark) private-chat bridge to local coding agents — Claude Code / Codex / opencode / pi / kimi, with live-streaming CardKit 2.0 cards",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/runner/codex/app-server/connection-manager.d.ts

@@ -1,56 +0,0 @@
-/**
- * ConnectionManager: manages Codex App Server connections per workspace.
- *
- * Each workspace gets its own connection (transport + client). Connections are
- * created on demand via `acquire()`, cached for reuse, and released after an
- * idle timeout (30 minutes default).
- */
-import { CodexAppServerClient } from './client.js';
-export interface ConnectionManagerOptions {
-    /** Path to the codex binary. */
-    binary: string;
-    /** Args to spawn the app server with. Defaults to `['app-server', '--stdio']`. */
-    args?: string[];
-    /** Environment variables to pass to the binary. */
-    env?: Record<string, string | undefined>;
-    /** Request timeout in milliseconds. */
-    requestTimeoutMs?: number;
-    /** Idle TTL in milliseconds. */
-    idleTtlMs?: number;
-}
-export declare class ConnectionManager {
-    private slots;
-    private readonly binary;
-    private readonly args;
-    private readonly env;
-    private readonly requestTimeoutMs;
-    private readonly idleTtlMs;
-    /** Callback when a connection is lost — cleared from slot map. */
-    onConnectionLost?: (workspace: string) => void;
-    constructor(opts: ConnectionManagerOptions);
-    /**
-     * Acquire a connection for the given workspace.
-     * Creates a new connection if one does not exist or the previous one was lost.
-     * Serializes creation so concurrent calls share the same connection.
-     */
-    acquire(workspace: string): Promise<CodexAppServerClient>;
-    /**
-     * Release (dispose) a connection for the given workspace.
-     */
-    release(workspace: string): Promise<void>;
-    /**
-     * Dispose all connections.
-     */
-    disposeAll(): Promise<void>;
-    /**
-     * Notify that the workspace is active — disarm the idle timer.
-     */
-    notifyActivity(workspace: string): void;
-    /**
-     * Notify that the workspace is idle — arm the idle timer.
-     */
-    notifyIdle(workspace: string): void;
-    private createClient;
-    private clearIdleTimer;
-    private disposeSlot;
-}

package/dist/runner/codex/argv.d.ts

@@ -1,33 +0,0 @@
-/**
- * Builds `codex exec` command-line arguments.
- *
- * Key design decisions:
- * - `approval_policy="never"` eliminates the approval handshake (root cause ①).
- * - Prompt goes via stdin (`-` flag) to avoid argv escaping issues.
- * - `--skip-git-repo-check`: lark-remote's cwd may not be a git repo.
- * - User's `~/.codex/config.toml` and project rules are preserved
- *   (no `--ignore-user-config` / `--ignore-rules`).
- */
-interface BuildCodexExecArgsInput {
-    /** Working directory for the codex process. */
-    cwd: string;
-    /** Model override (maps to `-m`). Omitted uses codex config.toml default. */
-    model?: string;
-    /** Model provider override (maps to `-c model_provider="xxx"`).
-     *  Omitted uses codex config.toml default. */
-    modelProvider?: string;
-    /** Thread ID for session resumption (maps to `exec resume --json <threadId> -`). */
-    threadId?: string;
-    /** Reasoning effort level (maps to `-c model_reasoning_effort="xxx"`). */
-    reasoningEffort?: string;
-}
-/**
- * Construct the argv array for `codex exec --json`.
- *
- * New session:
- *   `codex exec --json --sandbox danger-full-access -c approval_policy="never" ... -`
- * Resume session:
- *   `codex exec --sandbox danger-full-access ... resume --json <threadId> -`
- */
-export declare function buildCodexExecArgs(input: BuildCodexExecArgsInput): string[];
-export {};