lark-remote 0.1.5 → 0.1.6

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

@@ -0,0 +1,56 @@
+/**
+ * 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/app-server/connection-manager.js

@@ -0,0 +1,170 @@
+/**
+ * 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 { JsonlRpcTransport } from './transport.js';
+import { CodexAppServerClient } from './client.js';
+import { getLogger } from '../../../logger/index.js';
+const DEFAULT_IDLE_TTL_MS = 30 * 60 * 1000; // 30 minutes
+const DEFAULT_REQUEST_TIMEOUT_MS = 60_000; // 60 seconds
+export class ConnectionManager {
+    slots = new Map();
+    binary;
+    args;
+    env;
+    requestTimeoutMs;
+    idleTtlMs;
+    /** Callback when a connection is lost — cleared from slot map. */
+    onConnectionLost;
+    constructor(opts) {
+        this.binary = opts.binary;
+        this.args = opts.args ?? ['app-server', '--stdio'];
+        this.env = opts.env ?? {};
+        this.requestTimeoutMs = opts.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+        this.idleTtlMs = opts.idleTtlMs ?? DEFAULT_IDLE_TTL_MS;
+    }
+    /**
+     * 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.
+     */
+    async acquire(workspace) {
+        const existing = this.slots.get(workspace);
+        if (existing) {
+            // If a create is in flight, wait for it
+            if (existing.createPromise) {
+                return existing.createPromise;
+            }
+            // If the client is ready and its transport is alive, return it
+            if (existing.client.ready && existing.client.healthy) {
+                return existing.client;
+            }
+            // Client is disposed, dead (e.g. app-server process killed externally),
+            // or not ready — replace it so the next run respawns the process.
+            this.disposeSlot(workspace);
+        }
+        const createPromise = this.createClient(workspace);
+        this.slots.set(workspace, {
+            client: null, // placeholder
+            idleTimer: null,
+            createPromise: createPromise,
+        });
+        try {
+            const client = await createPromise;
+            // P2-2 竞态：创建期间 release()/disposeAll() 已把 slot 删掉（并可能已
+            // dispose 连接）。此时不能再把新连接塞回 slot——否则会复活一个无人管理、
+            // 无 idle timer 的连接泄漏。归还给调用者继续使用，但不再缓存。
+            const slotAfterCreate = this.slots.get(workspace);
+            if (!slotAfterCreate || slotAfterCreate.createPromise !== createPromise) {
+                return client;
+            }
+            this.slots.set(workspace, {
+                client,
+                idleTimer: null,
+                createPromise: null,
+            });
+            return client;
+        }
+        catch (err) {
+            // 只删除自己的槽位：并发 release + 重新 acquire 后 slot 可能已被新的
+            // createPromise 占据，误删会破坏新连接。
+            const current = this.slots.get(workspace);
+            if (current && current.createPromise === createPromise) {
+                this.slots.delete(workspace);
+            }
+            throw err;
+        }
+    }
+    /**
+     * Release (dispose) a connection for the given workspace.
+     */
+    async release(workspace) {
+        this.disposeSlot(workspace);
+    }
+    /**
+     * Dispose all connections.
+     */
+    async disposeAll() {
+        const workspaces = [...this.slots.keys()];
+        await Promise.all(workspaces.map((w) => this.disposeSlot(w)));
+    }
+    /**
+     * Notify that the workspace is active — disarm the idle timer.
+     */
+    notifyActivity(workspace) {
+        const slot = this.slots.get(workspace);
+        if (slot) {
+            this.clearIdleTimer(slot);
+        }
+    }
+    /**
+     * Notify that the workspace is idle — arm the idle timer.
+     */
+    notifyIdle(workspace) {
+        const slot = this.slots.get(workspace);
+        if (slot) {
+            this.clearIdleTimer(slot);
+            slot.idleTimer = setTimeout(() => {
+                getLogger().info(`[codex-connection-manager] idle timeout for workspace=${workspace}, releasing connection`);
+                this.disposeSlot(workspace);
+            }, this.idleTtlMs);
+        }
+    }
+    // =========================================================================
+    // Internal
+    // =========================================================================
+    async createClient(workspace) {
+        const transport = new JsonlRpcTransport({
+            binary: this.binary,
+            args: this.args,
+            cwd: workspace,
+            env: this.env,
+        });
+        let client = null;
+        const hooks = {
+            onNotification: (_method, _params) => {
+                // Notifications are handled by the runner via translator
+            },
+            onServerRequest: (_id, _method, _params) => {
+                // Server requests are handled by the runner via translator
+            },
+            onClose: () => {
+                getLogger().info(`[codex-connection-manager] connection closed workspace=${workspace}`);
+                // 只清理自己创建的 slot：并发 release + 重新 acquire 后 slot 可能已被
+                // 新连接占据，误删会破坏新连接。
+                if (this.slots.get(workspace)?.client === client) {
+                    this.slots.delete(workspace);
+                    this.onConnectionLost?.(workspace);
+                }
+            },
+        };
+        client = new CodexAppServerClient(transport, hooks, this.requestTimeoutMs);
+        await client.connect();
+        return client;
+    }
+    clearIdleTimer(slot) {
+        if (slot.idleTimer !== null) {
+            clearTimeout(slot.idleTimer);
+            slot.idleTimer = null;
+        }
+    }
+    async disposeSlot(workspace) {
+        const slot = this.slots.get(workspace);
+        if (!slot)
+            return;
+        this.slots.delete(workspace);
+        this.clearIdleTimer(slot);
+        if (slot.client) {
+            try {
+                await slot.client.dispose();
+            }
+            catch (err) {
+                getLogger().warn(`[codex-connection-manager] dispose error workspace=${workspace}: ${err}`);
+            }
+        }
+    }
+}
+//# sourceMappingURL=connection-manager.js.map