@linkshell/host 0.4.0 → 0.4.1

package/dist/host/src/drivers/codex/driver.js

@@ -1,13 +1,44 @@
+import { statSync } from "node:fs";
 import { ABANDON, RpcError } from "@linkshell/wire";
 import { parseCodexLoginStatus, runStatusCommand } from "../auth.js";
-import { CodexAppServer, detectCodex } from "./app-server.js";
-import { APPROVAL_METHODS, QUESTION_METHODS, mapApprovalRequest, mapQuestionRequest, mapNotification, threadStateOf, threadToDiscovered, spawnedThreads, threadToHistory, toCodexInput, } from "./mapper.js";
+import { CodexAppServer, CodexSharedServer, detectCodex, sharedServerSocket } from "./app-server.js";
+import { APPROVAL_METHODS, QUESTION_METHODS, mapApprovalRequest, mapQuestionRequest, mapNotification, threadStateOf, threadToDiscovered, spawnedThreads, threadToHistory, toCodexInput, toolStart, turnUnderWay, } from "./mapper.js";
 import { nestHistory, nestUnder } from "../nesting.js";
 import { configOptions, effective, settingsFrom, turnOverrides } from "./settings.js";
 import { COMMANDS, INIT_PROMPT, commandOf } from "./commands.js";
+import { desktopBusSocket, interruptThroughDesktop } from "./desktop-ipc.js";
+/** Codex's refusal to load a thread that another process has loaded. */
+function heldElsewhere(error) {
+    return error instanceof Error && /already has an active writer/i.test(error.message);
+}
+function fileStamp(path) {
+    try {
+        const stat = statSync(path);
+        return `${stat.mtimeMs}:${stat.size}`;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** A request id from Codex's background server: both servers count theirs from the same numbers. */
+const sharedRequestId = (id) => `shared-${id}`;
+const HELD_NOTICE = {
+    title: "这个会话开在电脑上的另一个 Codex 里",
+    detail: "这里会跟着显示它的进展。从手机发的消息会排进 Codex 的队列：那边空闲时就开始，正在跑的一轮结束后接着跑。Codex 桌面 App 和 IDE 插件不和别的程序共用会话，所以排队的消息不能插进正在跑的一轮；用 linkshell codex 或终端里的 codex 打开的会话，两边可以同时操作。",
+};
+const HELD_SEND = "这个会话开在电脑上的另一个 Codex（桌面 App 或 IDE 插件）里，这条消息没能排进它的队列。在那边关掉这个会话后再发；用 linkshell codex 或终端里的 codex 打开的会话，两边可以同时操作。";
+const HELD_STOP = "这一轮跑在电脑上的另一个 Codex（桌面 App 或 IDE 插件）里，没能从手机停下它：请在那边停止。";
+const HELD_COMMAND = "这个会话开在电脑上的另一个 Codex 里：压缩上下文和审查要等那边关掉这个会话后才能从手机做。";
 /**
  * Codex, tier multi_client: LinkShell and the desktop TUI (`codex --remote`)
  * are both clients of one app-server, so every thread is live on both sides.
+ *
+ * Codex lets one process have a thread loaded at a time. A thread loaded in
+ * Codex's own background server (a plain `codex` in a terminal) is joined
+ * there, as one more client. A thread in a process that takes no other
+ * clients (the desktop app, an IDE extension) is read from disk as that
+ * process writes it; a message for it goes into Codex's own queue, which that
+ * process starts when it is idle; and its turn is stopped by asking the app.
  */
 export class CodexDriver {
     options;
@@ -48,9 +79,35 @@ export class CodexDriver {
     restartTimer;
     restartDelay;
     stopped = false;
+    shared;
+    /** Threads loaded in Codex's background server: announced by it, or joined there. */
+    inShared = new Set();
+    observed = new Map();
+    takingUp = new Map();
+    /** Messages in Codex's own queue for threads another process holds: it starts them when it is idle or its turn ends. */
+    waiting = new Map();
+    /** Notifications for a thread being joined, held until its history has been read. */
+    joining = new Map();
+    /** Threads a device has open. */
+    watching = new Set();
+    /** Threads another client of this host's app-server opened (`linkshell codex`): followed for as long as the host runs. */
+    kept = new Set();
+    /** Threads started here that have had no turn: nothing on disk yet to come back to. */
+    fresh = new Set();
+    releases = new Map();
+    /** What was last announced per thread (settings, commands): a thread joined again says it only if it changed. */
+    announced = new Map();
+    observeIntervalMs;
+    releaseDelayMs;
+    sharedSocketPath;
+    desktopBusPath;
     constructor(options) {
         this.options = options;
         this.restartDelay = options.restartDelayMs ?? 1000;
+        this.desktopBusPath = options.desktopBusPath === false ? undefined : (options.desktopBusPath ?? desktopBusSocket(options.env));
+        this.sharedSocketPath = options.sharedSocketPath === false ? undefined : (options.sharedSocketPath ?? sharedServerSocket(options.env));
+        this.observeIntervalMs = options.observeIntervalMs ?? 2000;
+        this.releaseDelayMs = options.releaseDelayMs ?? 30_000;
     }
     status() {
         return this.current;
@@ -77,21 +134,43 @@ export class CodexDriver {
         for (const timer of this.followRetries.values())
             clearTimeout(timer);
         this.followRetries.clear();
+        for (const timer of this.releases.values())
+            clearTimeout(timer);
+        this.releases.clear();
+        for (const threadId of [...this.observed.keys()])
+            this.stopObserving(threadId);
         for (const pending of this.approvals.values())
             pending.abandon();
         this.approvals.clear();
+        this.shared?.close();
+        this.shared = undefined;
         await this.server?.stop();
         this.server = undefined;
     }
     async listSessions(limit) {
         const result = await this.rpc("thread/list", { limit, archived: false });
-        return result.data.map(threadToDiscovered);
+        return result.data.map((thread) => {
+            const discovered = threadToDiscovered(thread);
+            // This host's app-server only knows the state of the threads loaded in it.
+            const state = this.stateElsewhere(thread.id);
+            return state ? { ...discovered, state } : discovered;
+        });
+    }
+    stateElsewhere(threadId) {
+        const watch = this.observed.get(threadId);
+        if (watch)
+            return watch.running ? "running" : "idle";
+        if (!this.inShared.has(threadId) || !this.attached.has(threadId))
+            return undefined;
+        if (this.hasApprovals(threadId))
+            return "waiting";
+        return this.stateOf(threadId).activeTurnId ? "running" : "idle";
     }
     /** Codex's own fork: a new thread with this one's turns, all or through `lastTurnId`, in `cwd`. */
     async fork(nativeId, options) {
         let lastTurnId;
         if (options.upTo) {
-            const { thread } = await this.rpc("thread/read", { threadId: nativeId, includeTurns: true });
+            const { thread } = await this.rpcFor(nativeId, "thread/read", { threadId: nativeId, includeTurns: true });
             const turns = thread.turns ?? [];
             const picked = options.upTo;
             const holding = turns.find((turn) => turn.items.some((item) => item.id === picked.itemId));
@@ -116,6 +195,7 @@ export class CodexDriver {
             model: options.model ?? null,
         }).then((result) => {
             this.startedHere.add(result.thread.id);
+            this.fresh.add(result.thread.id);
             this.cwds.set(result.thread.id, result.thread.cwd ?? options.cwd);
             this.settings.set(result.thread.id, settingsFrom(result));
             return result;
@@ -142,16 +222,9 @@ export class CodexDriver {
             void this.announceCommands(nativeId);
             return [];
         }
-        let thread;
+        let joined;
         try {
-            // On a running thread, thread/resume rejoins it; otherwise it loads it from disk.
-            const resumed = await this.rpc("thread/resume", { threadId: nativeId });
-            thread = resumed.thread;
-            this.settings.set(nativeId, settingsFrom(resumed));
-            if (thread.cwd)
-                this.cwds.set(nativeId, thread.cwd);
-            void this.announceConfig(nativeId);
-            void this.announceCommands(nativeId);
+            joined = await this.subscribe(nativeId);
         }
         catch (error) {
             this.attached.delete(nativeId);
@@ -160,12 +233,396 @@ export class CodexDriver {
                 // still be started on it; after that it can be joined.
                 throw RpcError.app("not_ready", "this Codex session has no messages yet");
             }
+            if (!heldElsewhere(error))
+                throw error;
+            // A Codex process that takes no other clients has it: what it writes can still be read.
+            return this.observe(nativeId);
+        }
+        this.stopObserving(nativeId);
+        const history = await this.withSubAgents(nativeId, joined.thread, threadToHistory(joined.thread));
+        this.goLive(nativeId, joined);
+        this.reportHeld(nativeId, false);
+        void this.announceConfig(nativeId);
+        void this.announceCommands(nativeId);
+        if (this.waiting.has(nativeId))
+            void this.syncWaiting(nativeId);
+        this.considerRelease(nativeId);
+        return history;
+    }
+    /**
+     * Subscribes to a thread where it can be driven: this host's app-server, or
+     * Codex's background server when the thread is loaded there. What the
+     * server sends from then on is held until `goLive`.
+     */
+    async subscribe(threadId) {
+        this.joining.set(threadId, []);
+        try {
+            // On a running thread, thread/resume rejoins it; otherwise it loads it from disk.
+            const resumed = await this.resume(threadId);
+            let thread = resumed.thread;
+            const running = thread.turns?.find((turn) => turn.status === "inProgress");
+            if (running) {
+                // The response numbers a running turn's messages itself (item-1,
+                // item-2…): imported like that, they would come a second time under
+                // their real ids. Read from disk they have the ids they keep, and
+                // only what is finished is there.
+                const read = await this.rpcFor(threadId, "thread/read", { threadId, includeTurns: true }).catch(async (error) => {
+                    await this.rpcFor(threadId, "thread/unsubscribe", { threadId }).catch(() => { });
+                    throw error;
+                });
+                thread = read.thread;
+            }
+            this.settings.set(threadId, settingsFrom(resumed));
+            if (thread.cwd)
+                this.cwds.set(threadId, thread.cwd);
+            return { thread, underWay: running?.items.filter((item) => item.status === "inProgress") ?? [] };
+        }
+        catch (error) {
+            this.joining.delete(threadId);
             throw error;
         }
+    }
+    /** thread/resume where the thread can be loaded: here, or in Codex's background server if it is loaded there. */
+    async resume(threadId) {
+        const places = this.inShared.has(threadId) ? ["shared", "own"] : ["own", "shared"];
+        let refused;
+        for (const home of places) {
+            if (home === "shared" && !(await this.connectShared()))
+                continue;
+            try {
+                const server = home === "shared" ? this.shared : this.server;
+                if (!server)
+                    throw RpcError.app("agent_unavailable", "Codex is not running");
+                const resumed = await server.request("thread/resume", { threadId });
+                if (home === "shared")
+                    this.inShared.add(threadId);
+                else
+                    this.inShared.delete(threadId);
+                return resumed;
+            }
+            catch (error) {
+                // Loaded in another process: the other place may be that process. Anything else is the answer.
+                if (refused === undefined && !heldElsewhere(error))
+                    throw error;
+                refused ??= error;
+            }
+        }
+        throw refused;
+    }
+    /** Says where the joined thread stands, then lets through what arrived while it was being read. */
+    goLive(threadId, { thread, underWay }) {
+        const state = this.stateOf(threadId);
         const active = thread.turns?.find((turn) => turn.status === "inProgress");
-        this.stateOf(nativeId).activeTurnId = active?.id;
-        this.host?.update(this.id, nativeId, { sessionUpdate: "ls_status", state: threadStateOf(thread.status) });
-        return this.withSubAgents(nativeId, thread, threadToHistory(thread));
+        state.activeTurnId = active?.id;
+        state.midTurn = active ? true : undefined;
+        state.begun = undefined;
+        // A turn already running: the session shows as working, and its end has a start to close.
+        if (active)
+            this.host?.update(this.id, threadId, { sessionUpdate: "ls_turn", state: "started", turnId: active.id });
+        this.host?.update(this.id, threadId, { sessionUpdate: "ls_status", state: threadStateOf(thread.status) });
+        const read = new Set((thread.turns ?? []).flatMap((turn) => turn.items.map((item) => item.id)));
+        for (const item of underWay) {
+            // A command still running: its card. (Its output so far was missed, so the whole of it comes when it finishes.)
+            const start = read.has(item.id) ? undefined : toolStart(item);
+            if (start)
+                this.host?.update(this.id, threadId, start);
+        }
+        const held = this.joining.get(threadId) ?? [];
+        this.joining.delete(threadId);
+        for (const { method, params, from } of held) {
+            const record = params;
+            const itemId = record?.itemId ?? record?.item?.id;
+            // Already in what was read: the item, or the start and end of turns it shows.
+            if (typeof itemId === "string" && read.has(itemId))
+                continue;
+            if (method === "turn/started" && record?.turn?.id === active?.id)
+                continue;
+            if (method === "turn/completed" && record?.turn?.id !== active?.id)
+                continue;
+            this.onNotification(method, params, from);
+        }
+    }
+    // ── a thread held by a Codex that can't be joined ──────────────────
+    /** Reads the thread from disk, and keeps reading while a device has it open. */
+    async observe(threadId) {
+        const { thread } = await this.rpc("thread/read", { threadId, includeTurns: true });
+        const history = await this.withSubAgents(threadId, thread, threadToHistory(thread));
+        this.stopObserving(threadId);
+        const timer = setInterval(() => void this.refresh(threadId), this.observeIntervalMs);
+        timer.unref?.();
+        const last = thread.turns?.at(-1);
+        const running = turnUnderWay(last);
+        // (No stamp yet: the file may have grown since it was read, so the first look reads it again.)
+        this.observed.set(threadId, {
+            path: thread.path ?? undefined,
+            seen: new Set(history.map((item) => item.itemId)),
+            running,
+            turnId: running ? last?.id : undefined,
+            timer,
+        });
+        if (thread.cwd)
+            this.cwds.set(threadId, thread.cwd);
+        this.host?.update(this.id, threadId, { sessionUpdate: "ls_status", state: running ? "running" : "idle" });
+        this.reportHeld(threadId, true);
+        // What was queued for it before this host last started is still waiting.
+        void this.syncWaiting(threadId);
+        this.considerRelease(threadId);
+        return history;
+    }
+    /** Reports what the other process has finished since the last look. An item still being written isn't on disk. */
+    async refresh(threadId) {
+        const watch = this.observed.get(threadId);
+        if (!watch || watch.reading)
+            return;
+        if (this.waiting.has(threadId))
+            void this.syncWaiting(threadId);
+        const stamp = watch.path ? fileStamp(watch.path) : undefined;
+        if (stamp !== undefined && stamp === watch.stamp)
+            return;
+        watch.reading = true;
+        try {
+            const { thread } = await this.rpc("thread/read", { threadId, includeTurns: true });
+            const history = await this.withSubAgents(threadId, thread, threadToHistory(thread));
+            // Joined, or let go, while it was being read.
+            if (this.observed.get(threadId) !== watch)
+                return;
+            watch.stamp = stamp;
+            watch.path = thread.path ?? undefined;
+            for (const item of history) {
+                if (watch.seen.has(item.itemId))
+                    continue;
+                watch.seen.add(item.itemId);
+                this.report(threadId, item);
+            }
+            const last = thread.turns?.at(-1);
+            const running = turnUnderWay(last);
+            watch.turnId = running ? last?.id : undefined;
+            if (running !== watch.running) {
+                watch.running = running;
+                this.host?.update(this.id, threadId, { sessionUpdate: "ls_status", state: running ? "running" : "idle" });
+            }
+        }
+        catch (error) {
+            // Gone, or unreadable: opening it again says what is wrong.
+            this.host?.log(`[codex] couldn't read ${threadId}: ${error instanceof Error ? error.message : String(error)}`);
+            if (this.observed.get(threadId) === watch) {
+                this.stopObserving(threadId);
+                this.host?.detached(this.id, threadId);
+            }
+        }
+        finally {
+            watch.reading = false;
+        }
+    }
+    report(threadId, item) {
+        item.updates.forEach((update, index) => this.host?.update(this.id, threadId, update, index === item.updates.length - 1 ? item.itemId : undefined));
+    }
+    stopObserving(threadId) {
+        const watch = this.observed.get(threadId);
+        if (!watch)
+            return;
+        clearInterval(watch.timer);
+        this.observed.delete(threadId);
+    }
+    /**
+     * Before writing to a thread that could only be read: joins it if whoever
+     * had it has let go, with what they wrote since the last look. Still held,
+     * it stays as it is.
+     */
+    takeUp(threadId) {
+        const watch = this.observed.get(threadId);
+        if (!watch)
+            return Promise.resolve();
+        let taking = this.takingUp.get(threadId);
+        if (!taking) {
+            taking = (async () => {
+                this.attached.add(threadId);
+                let joined;
+                try {
+                    joined = await this.subscribe(threadId);
+                }
+                catch (error) {
+                    this.attached.delete(threadId);
+                    if (heldElsewhere(error))
+                        return;
+                    throw error;
+                }
+                this.stopObserving(threadId);
+                for (const item of await this.withSubAgents(threadId, joined.thread, threadToHistory(joined.thread))) {
+                    if (!watch.seen.has(item.itemId))
+                        this.report(threadId, item);
+                }
+                this.goLive(threadId, joined);
+                this.reportHeld(threadId, false);
+                void this.announceConfig(threadId);
+                void this.announceCommands(threadId);
+                // What still waits in Codex's queue is started by this host's app-server now.
+                void this.syncWaiting(threadId);
+            })().finally(() => this.takingUp.delete(threadId));
+            this.takingUp.set(threadId, taking);
+        }
+        return taking;
+    }
+    /**
+     * Leaves a message in Codex's own queue for a thread another process holds.
+     * That process starts it when it is idle, or right after the turn it is running.
+     */
+    async enqueue(threadId, input, clientMessageId) {
+        try {
+            await this.rpc("thread/queue/add", { threadId, input, clientUserMessageId: clientMessageId });
+        }
+        catch (error) {
+            this.host?.log(`[codex] couldn't queue a message for ${threadId}: ${error instanceof Error ? error.message : String(error)}`);
+            throw this.refused(threadId, "这条消息没有发出去", HELD_SEND);
+        }
+        await this.syncWaiting(threadId);
+        return "queued";
+    }
+    /** What waits in Codex's queue for the thread, as the session's queue on the devices. */
+    async syncWaiting(threadId) {
+        const listed = await this.rpc("thread/queue/list", {
+            threadId,
+        }).catch(() => undefined);
+        if (!listed)
+            return;
+        this.setWaiting(threadId, listed.data.map((entry) => ({
+            clientMessageId: entry.clientUserMessageId,
+            submissionId: entry.id,
+            text: entry.input.map((part) => (part.type === "text" && typeof part.text === "string" ? part.text : "")).join("").trim(),
+            images: entry.input.filter((part) => part.type === "image" || part.type === "localImage").length,
+        })));
+    }
+    setWaiting(threadId, waiting) {
+        const before = this.waiting.get(threadId) ?? [];
+        if (JSON.stringify(before) === JSON.stringify(waiting))
+            return;
+        if (waiting.length > 0)
+            this.waiting.set(threadId, waiting);
+        else
+            this.waiting.delete(threadId);
+        this.host?.queue(this.id, threadId, waiting.map(({ clientMessageId, text, images }) => ({ clientMessageId, text, images })));
+    }
+    unqueue(nativeId, clientMessageId) {
+        const waiting = this.waiting.get(nativeId) ?? [];
+        const entry = waiting.find((candidate) => candidate.clientMessageId === clientMessageId);
+        if (!entry)
+            return false;
+        this.setWaiting(nativeId, waiting.filter((candidate) => candidate !== entry));
+        // (Already started over there: then it runs, and shows as any message does.)
+        void this.rpc("thread/queue/delete", { threadId: nativeId, queuedSubmissionId: entry.submissionId }).catch(() => { });
+        return true;
+    }
+    /** A queued message can't be put into the turn another Codex is running: that turn is stopped, and the queue goes on. */
+    async sendQueuedNow(nativeId) {
+        if (this.waiting.has(nativeId))
+            await this.stopElsewhere(nativeId);
+    }
+    /**
+     * Stops the turn a Codex that can't be joined is running. Only its own app
+     * can: it is asked over the bus its windows share.
+     */
+    async stopElsewhere(threadId) {
+        const watch = this.observed.get(threadId);
+        if (!watch?.running)
+            return;
+        try {
+            if (!this.desktopBusPath)
+                throw new Error("not asked");
+            await interruptThroughDesktop(this.desktopBusPath, threadId, watch.turnId);
+        }
+        catch (error) {
+            this.host?.log(`[codex] couldn't stop ${threadId} through the Codex desktop app: ${error instanceof Error ? error.message : String(error)}`);
+            throw RpcError.app("busy", HELD_STOP);
+        }
+        void this.refresh(threadId);
+    }
+    /**
+     * What a message for a thread held elsewhere is refused with. The apps show
+     * a failed message without its reason, so the reason goes into the session too.
+     */
+    refused(threadId, title, detail) {
+        this.host?.update(this.id, threadId, { sessionUpdate: "ls_notice", level: "warning", title, detail });
+        return RpcError.app("busy", detail);
+    }
+    /** Says, when it becomes so and when it is over, that the session is in a Codex this host can't join. */
+    reportHeld(threadId, held) {
+        const memory = this.host?.state(this.id, threadId);
+        if ((memory?.get("held") === "1") === held)
+            return;
+        memory?.set("held", held ? "1" : "");
+        this.host?.update(this.id, threadId, { sessionUpdate: "ls_driver", driver: held ? "desktop" : "none" });
+        if (held)
+            this.host?.update(this.id, threadId, { sessionUpdate: "ls_notice", level: "info", ...HELD_NOTICE });
+    }
+    // ── letting go ─────────────────────────────────────────────────────
+    /** Whether a device has the session open. */
+    watched(nativeId, open) {
+        if (open) {
+            this.watching.add(nativeId);
+            this.cancelRelease(nativeId);
+        }
+        else {
+            this.watching.delete(nativeId);
+            this.considerRelease(nativeId);
+        }
+    }
+    cancelRelease(threadId) {
+        clearTimeout(this.releases.get(threadId));
+        this.releases.delete(threadId);
+    }
+    /**
+     * A thread stays loaded, and closed to every other Codex program, for as
+     * long as this host is subscribed to it. One that no device has open and
+     * that isn't working is let go after a while, so the desktop app or a
+     * `codex` in a terminal can open it; opening it on a device joins it again.
+     */
+    considerRelease(threadId) {
+        this.cancelRelease(threadId);
+        if (this.watching.has(threadId) || this.kept.has(threadId) || this.fresh.has(threadId))
+            return;
+        if (!this.attached.has(threadId) && !this.observed.has(threadId))
+            return;
+        const timer = setTimeout(() => {
+            this.releases.delete(threadId);
+            void this.release(threadId);
+        }, this.releaseDelayMs);
+        timer.unref?.();
+        this.releases.set(threadId, timer);
+    }
+    async release(threadId) {
+        if (this.watching.has(threadId) || this.kept.has(threadId) || this.fresh.has(threadId))
+            return;
+        if (this.observed.has(threadId)) {
+            this.stopObserving(threadId);
+            this.host?.detached(this.id, threadId);
+            return;
+        }
+        // Working: its turn's end asks again.
+        const busy = () => !this.attached.has(threadId) || this.stateOf(threadId).activeTurnId !== undefined || this.hasApprovals(threadId);
+        if (busy())
+            return;
+        // A command the agent left running (a dev server, say) ends when its thread
+        // is unloaded: the thread stays, and is looked at again later. So does one
+        // in a Codex that can't say what it has running.
+        let background;
+        try {
+            background = (await this.rpcFor(threadId, "thread/backgroundTerminals/list", { threadId, limit: 1 })).data;
+        }
+        catch {
+            return;
+        }
+        if (background.length > 0)
+            return this.considerRelease(threadId);
+        if (busy() || this.watching.has(threadId) || this.kept.has(threadId))
+            return;
+        this.host?.detached(this.id, threadId);
+        await this.detach(threadId);
+    }
+    hasApprovals(threadId) {
+        for (const pending of this.approvals.values())
+            if (pending.threadId === threadId)
+                return true;
+        return false;
     }
     /** Nests each sub-agent's own history right after the call that spawned it. */
     async withSubAgents(threadId, thread, history) {
@@ -185,7 +642,7 @@ export class CodexDriver {
             return history;
         const nested = new Map();
         await Promise.all([...spawns].map(async ([callId, ids]) => {
-            const parts = await Promise.all(ids.map((child) => this.rpc("thread/read", { threadId: child, includeTurns: true })
+            const parts = await Promise.all(ids.map((child) => this.rpcFor(threadId, "thread/read", { threadId: child, includeTurns: true })
                 .then((result) => nestHistory(threadToHistory(result.thread), callId))
                 .catch(() => [])));
             nested.set(callId, parts.flat());
@@ -197,11 +654,14 @@ export class CodexDriver {
         });
     }
     async detach(nativeId) {
+        this.cancelRelease(nativeId);
+        this.stopObserving(nativeId);
         if (!this.attached.delete(nativeId))
             return;
-        await this.rpc("thread/unsubscribe", { threadId: nativeId }).catch(() => { });
+        await this.rpcFor(nativeId, "thread/unsubscribe", { threadId: nativeId }).catch(() => { });
     }
     async prompt(nativeId, content, clientMessageId) {
+        await this.takeUp(nativeId);
         const command = commandOf(content);
         if (command) {
             const ran = await this.runCommand(nativeId, command, clientMessageId);
@@ -217,14 +677,17 @@ export class CodexDriver {
     async runCommand(nativeId, command, clientMessageId) {
         const echo = () => this.host?.update(this.id, nativeId, { sessionUpdate: "user_message_chunk", messageId: `local-${clientMessageId}`, content: { type: "text", text: command.text } }, `command:${clientMessageId}`);
         if (command.name === "compact" || command.name === "review") {
+            // Not something a queue can carry: they run in the app-server that has the thread.
+            if (this.observed.has(nativeId))
+                throw this.refused(nativeId, command.name === "compact" ? "现在不能压缩上下文" : "现在不能开始审查", HELD_COMMAND);
             if (this.stateOf(nativeId).activeTurnId) {
                 throw RpcError.app("busy", command.name === "compact" ? "等这一轮结束后再压缩上下文" : "等这一轮结束后再开始审查");
             }
             if (command.name === "compact") {
-                await this.rpc("thread/compact/start", { threadId: nativeId });
+                await this.rpcFor(nativeId, "thread/compact/start", { threadId: nativeId });
             }
             else {
-                await this.rpc("review/start", {
+                await this.rpcFor(nativeId, "review/start", {
                     threadId: nativeId,
                     target: command.args ? { type: "custom", instructions: command.args } : { type: "uncommittedChanges" },
                     delivery: "inline",
@@ -249,10 +712,12 @@ export class CodexDriver {
     async send(nativeId, input, clientMessageId) {
         if (input.length === 0)
             throw RpcError.app("invalid_params", "nothing to send");
+        if (this.observed.has(nativeId))
+            return this.enqueue(nativeId, input, clientMessageId);
         const activeTurnId = this.stateOf(nativeId).activeTurnId;
         if (activeTurnId) {
             try {
-                await this.rpc("turn/steer", {
+                await this.rpcFor(nativeId, "turn/steer", {
                     threadId: nativeId,
                     expectedTurnId: activeTurnId,
                     clientUserMessageId: clientMessageId,
@@ -266,7 +731,7 @@ export class CodexDriver {
             }
         }
         const overrides = this.overrides.get(nativeId) ?? {};
-        await this.rpc("turn/start", {
+        await this.rpcFor(nativeId, "turn/start", {
             threadId: nativeId,
             clientUserMessageId: clientMessageId,
             input,
@@ -324,9 +789,16 @@ export class CodexDriver {
     async announceConfig(nativeId) {
         const models = await this.loadModels();
         const options = configOptions(this.settings.get(nativeId) ?? {}, this.overrides.get(nativeId) ?? {}, models);
-        if (options.length > 0)
+        if (options.length > 0 && this.isNews(`config:${nativeId}`, options))
             this.host?.update(this.id, nativeId, { sessionUpdate: "ls_config", options });
     }
+    isNews(key, value) {
+        const text = JSON.stringify(value);
+        if (this.announced.get(key) === text)
+            return false;
+        this.announced.set(key, text);
+        return true;
+    }
     loadSkills(cwd) {
         const key = cwd ?? "";
         let loading = this.skills.get(key);
@@ -346,33 +818,38 @@ export class CodexDriver {
     async announceCommands(nativeId) {
         const skills = await this.loadSkills(this.cwds.get(nativeId));
         const taken = new Set(COMMANDS.map((command) => command.name));
-        this.host?.update(this.id, nativeId, {
-            sessionUpdate: "available_commands_update",
-            availableCommands: [
-                ...COMMANDS,
-                ...skills
-                    .filter((skill) => !taken.has(skill.name))
-                    .map((skill) => ({
-                    name: skill.name,
-                    description: (skill.interface?.shortDescription ?? skill.shortDescription ?? skill.description ?? "").slice(0, 160),
-                })),
-            ],
-        });
+        const availableCommands = [
+            ...COMMANDS,
+            ...skills
+                .filter((skill) => !taken.has(skill.name))
+                .map((skill) => ({
+                name: skill.name,
+                description: (skill.interface?.shortDescription ?? skill.shortDescription ?? skill.description ?? "").slice(0, 160),
+            })),
+        ];
+        if (this.isNews(`commands:${nativeId}`, availableCommands))
+            this.host?.update(this.id, nativeId, { sessionUpdate: "available_commands_update", availableCommands });
     }
     async archive(nativeId, archived) {
-        await this.rpc(archived ? "thread/archive" : "thread/unarchive", { threadId: nativeId });
+        await this.rpcFor(nativeId, archived ? "thread/archive" : "thread/unarchive", { threadId: nativeId });
     }
     async rename(nativeId, title) {
-        await this.rpc("thread/name/set", { threadId: nativeId, name: title });
+        await this.rpcFor(nativeId, "thread/name/set", { threadId: nativeId, name: title });
     }
     async delete(nativeId) {
-        await this.rpc("thread/delete", { threadId: nativeId });
+        await this.rpcFor(nativeId, "thread/delete", { threadId: nativeId });
     }
     async cancel(nativeId) {
+        if (this.observed.has(nativeId)) {
+            // Stopping stops what's waiting too; the apps put queued text back in the composer.
+            for (const entry of this.waiting.get(nativeId) ?? [])
+                this.unqueue(nativeId, entry.clientMessageId);
+            return this.stopElsewhere(nativeId);
+        }
         const turnId = this.stateOf(nativeId).activeTurnId;
         if (!turnId)
             return;
-        await this.rpc("turn/interrupt", { threadId: nativeId, turnId });
+        await this.rpcFor(nativeId, "turn/interrupt", { threadId: nativeId, turnId });
     }
     async respondPermission(nativeId, requestId, optionId) {
         const pending = this.approvals.get(requestId);
@@ -394,9 +871,19 @@ export class CodexDriver {
         pending.answer(pending.request.answer(answers));
         this.host?.update(this.id, nativeId, { sessionUpdate: "ls_permission_resolved", requestId, optionId: "answered", answers });
     }
-    desktopLaunch(args, nativeId) {
-        // Multi-client: no lease to take, the TUI just joins the shared server.
-        const remote = ["--remote", `unix://${this.options.socketPath}`];
+    async desktopLaunch(args, nativeId) {
+        // Multi-client: no lease to take, the TUI just joins the server the thread is in.
+        let socketPath = this.options.socketPath;
+        if (nativeId) {
+            // Joined first, which finds where the thread is loaded: the TUI has to go to the same server.
+            await this.host?.follow(this.id, nativeId).catch(() => { });
+            if (this.attached.has(nativeId) && this.inShared.has(nativeId) && this.sharedSocketPath)
+                socketPath = this.sharedSocketPath;
+            // In this host's app-server it is followed from now on, like a thread the TUI starts.
+            else
+                this.kept.add(nativeId);
+        }
+        const remote = ["--remote", `unix://${socketPath}`];
         return {
             command: this.options.command ?? "codex",
             args: nativeId ? [...remote, "resume", nativeId, ...args] : [...remote, ...args],
@@ -410,8 +897,8 @@ export class CodexDriver {
             env: this.options.env,
             clientVersion: this.options.hostVersion,
             log: (message) => this.host?.log(message),
-            onNotification: (method, params) => this.onNotification(method, params),
-            onRequest: (method, params, id) => this.onServerRequest(method, params, id),
+            onNotification: (method, params) => this.onNotification(method, params, "own"),
+            onRequest: (method, params, id) => this.onServerRequest(method, params, id, "own"),
             onDown: (reason) => this.onDown(reason),
         });
         this.server = server;
@@ -433,8 +920,10 @@ export class CodexDriver {
     /** Follows every thread already live in the app-server (e.g. opened in the TUI). */
     async reattachLoaded() {
         const loaded = await this.rpc("thread/loaded/list", {}).catch(() => ({ data: [] }));
-        for (const threadId of loaded.data)
+        for (const threadId of loaded.data) {
+            this.kept.add(threadId);
             this.follow(threadId);
+        }
     }
     /**
      * Asks the host to follow a thread another client opened. A brand-new thread
@@ -469,16 +958,24 @@ export class CodexDriver {
         if (this.stopped)
             return;
         this.host?.log(`[codex] ${reason}`);
-        for (const pending of this.approvals.values())
-            pending.abandon();
-        this.approvals.clear();
-        for (const threadId of this.attached) {
+        this.abandonApprovals("own");
+        for (const threadId of [...this.attached]) {
+            // (What is joined in Codex's background server is still there.)
+            if (this.inShared.has(threadId))
+                continue;
+            this.attached.delete(threadId);
             this.threads.delete(threadId);
             this.host?.update(this.id, threadId, { sessionUpdate: "ls_status", state: "offline" });
             this.host?.detached(this.id, threadId);
         }
-        this.attached.clear();
+        // Read through the app-server that just went away.
+        for (const threadId of [...this.observed.keys()]) {
+            this.stopObserving(threadId);
+            this.host?.detached(this.id, threadId);
+        }
         this.startedHere.clear();
+        this.fresh.clear();
+        this.kept.clear();
         this.current = { installed: true, version: this.current.version, problem: "Codex app-server restarting" };
         this.scheduleRestart();
     }
@@ -503,7 +1000,7 @@ export class CodexDriver {
         }
         return state;
     }
-    onNotification(method, params) {
+    onNotification(method, params, from) {
         if (method === "thread/deleted") {
             // Deleted in the TUI or another client.
             const threadId = params?.threadId;
@@ -521,29 +1018,46 @@ export class CodexDriver {
                 return;
             }
             this.host?.sessionSeen(this.id, threadToDiscovered(thread));
+            if (from === "shared") {
+                // A plain `codex` opened it in Codex's background server. It is joined
+                // there when a device opens it: until then this host keeps nothing loaded.
+                this.inShared.add(thread.id);
+                return;
+            }
             // The broadcast can beat our own thread/start response; decide whether
             // the thread was opened elsewhere (the desktop TUI) once those settle.
             void Promise.allSettled([...this.startsInFlight]).then(() => {
-                if (!this.attached.has(thread.id) && !this.startedHere.has(thread.id))
-                    this.follow(thread.id);
+                if (this.attached.has(thread.id) || this.startedHere.has(thread.id))
+                    return;
+                this.kept.add(thread.id);
+                this.follow(thread.id);
             });
             return;
         }
+        const threadId = params?.threadId;
+        const held = typeof threadId === "string" ? this.joining.get(threadId) : undefined;
+        if (held) {
+            held.push({ method, params, from });
+            return;
+        }
         this.noteSpawns(params);
-        for (const mapped of mapNotification(method, params, (threadId) => this.stateOf(threadId))) {
-            if (mapped.update.sessionUpdate === "tool_call")
-                this.rememberTitle(mapped.update.toolCallId, mapped.update.title);
-            if (mapped.update.sessionUpdate === "ls_permission_resolved") {
-                const pending = this.approvals.get(mapped.update.requestId);
+        for (const mapped of mapNotification(method, params, (id) => this.stateOf(id))) {
+            const update = from === "shared" && mapped.update.sessionUpdate === "ls_permission_resolved"
+                ? { ...mapped.update, requestId: sharedRequestId(mapped.update.requestId) }
+                : mapped.update;
+            if (update.sessionUpdate === "tool_call")
+                this.rememberTitle(update.toolCallId, update.title);
+            if (update.sessionUpdate === "ls_permission_resolved") {
+                const pending = this.approvals.get(update.requestId);
                 if (pending) {
                     // Another client (the TUI) answered first.
-                    this.approvals.delete(mapped.update.requestId);
+                    this.approvals.delete(update.requestId);
                     pending.abandon();
                 }
             }
             const parent = this.children.get(mapped.threadId);
             if (parent) {
-                const nested = nestUnder(mapped.update, parent.toolCallId);
+                const nested = nestUnder(update, parent.toolCallId);
                 if (nested && this.attached.has(parent.threadId)) {
                     this.host?.update(this.id, parent.threadId, nested, mapped.itemId && `sub:${parent.toolCallId}:${mapped.itemId}`);
                 }
@@ -551,7 +1065,16 @@ export class CodexDriver {
             }
             if (!this.attached.has(mapped.threadId))
                 continue;
-            this.host?.update(this.id, mapped.threadId, mapped.update, mapped.itemId);
+            this.host?.update(this.id, mapped.threadId, update, mapped.itemId);
+            // A message that waited in Codex's queue has started.
+            if (update.sessionUpdate === "user_message_chunk" && this.waiting.has(mapped.threadId))
+                void this.syncWaiting(mapped.threadId);
+            if (update.sessionUpdate !== "ls_turn")
+                continue;
+            if (update.state === "started")
+                this.fresh.delete(mapped.threadId);
+            else
+                this.considerRelease(mapped.threadId);
         }
     }
     /** Remembers which spawnAgent call each new sub-agent thread belongs to. */
@@ -566,10 +1089,10 @@ export class CodexDriver {
         for (const child of spawnedThreads(record?.item))
             this.children.set(child, { threadId: root, toolCallId: callId });
     }
-    onServerRequest(method, params, id) {
+    onServerRequest(method, params, id, from) {
         if (!APPROVAL_METHODS.has(method) && !QUESTION_METHODS.has(method))
             return ABANDON;
-        const requestId = String(id);
+        const requestId = from === "shared" ? sharedRequestId(String(id)) : String(id);
         const mapped = QUESTION_METHODS.has(method) ? mapQuestionRequest(method, params, requestId) : mapApprovalRequest(method, params, requestId);
         // A sub-agent asking for permission asks in its parent session.
         const request = mapped && this.children.has(mapped.threadId) ? { ...mapped, threadId: this.children.get(mapped.threadId).threadId } : mapped;
@@ -600,5 +1123,48 @@ export class CodexDriver {
             return Promise.reject(RpcError.app("agent_unavailable", "Codex is not running"));
         return this.server.request(method, params);
     }
+    /** A request about a thread, to the server it is loaded in. */
+    rpcFor(threadId, method, params) {
+        return this.inShared.has(threadId) && this.shared ? this.shared.request(method, params) : this.rpc(method, params);
+    }
+    /** Connects to Codex's background server, if it is running. */
+    connectShared() {
+        if (!this.sharedSocketPath || this.stopped)
+            return Promise.resolve(false);
+        this.shared ??= new CodexSharedServer({
+            socketPath: this.sharedSocketPath,
+            clientVersion: this.options.hostVersion,
+            onNotification: (method, params) => this.onNotification(method, params, "shared"),
+            onRequest: (method, params, id) => this.onServerRequest(method, params, id, "shared"),
+            onDown: () => this.onSharedDown(),
+        });
+        return this.shared.connect();
+    }
+    /** Codex's background server went away (stopped, or restarted by its updater): the threads joined there are joined again wherever they are now. */
+    onSharedDown() {
+        if (this.stopped)
+            return;
+        this.host?.log("[codex] lost Codex's background server");
+        this.abandonApprovals("shared");
+        const joined = [...this.inShared].filter((threadId) => this.attached.delete(threadId));
+        this.inShared.clear();
+        for (const threadId of joined) {
+            const turnId = this.stateOf(threadId).activeTurnId;
+            this.threads.delete(threadId);
+            // Whether the turn goes on is told again when the thread is joined again.
+            if (turnId)
+                this.host?.update(this.id, threadId, { sessionUpdate: "ls_turn", state: "ended", turnId });
+            this.host?.detached(this.id, threadId);
+            this.follow(threadId);
+        }
+    }
+    abandonApprovals(from) {
+        for (const [requestId, pending] of this.approvals) {
+            if (requestId.startsWith(sharedRequestId("")) !== (from === "shared"))
+                continue;
+            this.approvals.delete(requestId);
+            pending.abandon();
+        }
+    }
 }
 //# sourceMappingURL=driver.js.map