@zetaloop/chappie 1.0.0 → 1.1.0

package/dist/{codex-RI2XL4HV.js → codex-XVRO56TR.js}

@@ -3,25 +3,27 @@ import {
   ProviderOutput,
   Session,
   createMessage
-} from "./chunk-5CKVVDZ2.js";
+} from "./chunk-G4LG7HH2.js";
 import {
   definitions,
   localTools
-} from "./chunk-DM523QRR.js";
+} from "./chunk-3MLW5U2C.js";
 import "./chunk-EIPDEA3I.js";
 import {
   package_default
-} from "./chunk-DN7OHZK6.js";
+} from "./chunk-DDBZIUBF.js";
 import {
   historyPage,
   historyResult,
   readConfig,
   src_default
-} from "./chunk-GWYP7B66.js";
+} from "./chunk-ASDHNBR2.js";
 import {
+  __callDispose,
   __commonJS,
   __require,
-  __toESM
+  __toESM,
+  __using
 } from "./chunk-UOFCCHBS.js";
 
 // node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js
@@ -4197,10 +4199,12 @@ import {
   createServer
 } from "node:http";
 import { homedir, hostname } from "node:os";
-import { join } from "node:path";
+import { join as join2 } from "node:path";
 
 // src/appserver.ts
 var import_cross_spawn = __toESM(require_cross_spawn(), 1);
+import { addAbortListener } from "node:events";
+import { createInterface } from "node:readline";
 import { Duplex, Readable, Writable } from "node:stream";
 
 // node_modules/.pnpm/ws@8.21.3/node_modules/ws/wrapper.mjs
@@ -4215,7 +4219,7 @@ var import_websocket_server = __toESM(require_websocket_server(), 1);
 var wrapper_default = import_websocket.default;
 
 // src/appserver.ts
-var AppServer = class {
+var AppServer = class _AppServer {
   #pending = /* @__PURE__ */ new Map();
   #receive;
   #stopped = Promise.withResolvers();
@@ -4225,6 +4229,35 @@ var AppServer = class {
   constructor(receive) {
     this.#receive = receive;
   }
+  static async query(method, params = {}, signal) {
+    signal?.throwIfAborted();
+    const child = (0, import_cross_spawn.spawn)("codex", ["app-server"], {
+      stdio: ["pipe", "pipe", "inherit"],
+      signal
+    });
+    const rpc = new _AppServer(() => {
+    });
+    const reader = createInterface({ input: child.stdout });
+    reader.on("line", (line) => rpc.#message(line));
+    reader.on("error", (error) => rpc.#ended(error));
+    child.on("error", (error) => rpc.#ended(error));
+    child.stdin.on("error", (error) => rpc.#ended(error));
+    child.once(
+      "exit",
+      () => rpc.#ended(new Error("Codex query process exited"))
+    );
+    rpc.#send = (message) => {
+      child.stdin.write(`${JSON.stringify(message)}
+`);
+    };
+    try {
+      await rpc.#initialize();
+      return await rpc.request(method, params);
+    } finally {
+      reader.close();
+      if (!child.killed) child.kill();
+    }
+  }
   get closed() {
     return this.#stopped.promise;
   }
@@ -4271,27 +4304,42 @@ var AppServer = class {
       socket.terminate();
       stream?.destroy();
     };
-    await ready.promise;
-    this.#send = (message) => socket.send(JSON.stringify(message));
+    try {
+      await ready.promise;
+      this.#send = (message) => socket.send(JSON.stringify(message));
+      await this.#initialize();
+    } catch (error) {
+      this.close();
+      throw error;
+    }
+  }
+  async #initialize() {
     await this.request("initialize", {
       clientInfo: { name: "chappie", version: package_default.version },
       capabilities: { experimentalApi: true }
     });
     this.#send?.({ method: "initialized" });
   }
-  request(method, params = {}) {
-    if (!this.#send)
-      return Promise.reject(new Error("Codex app-server is not connected"));
-    const id = this.#nextId++;
-    const completion = Promise.withResolvers();
-    this.#pending.set(id, completion);
+  async request(method, params = {}, signal) {
+    var _stack = [];
     try {
-      this.#send({ id, method, params });
-    } catch (error) {
-      this.#pending.delete(id);
-      completion.reject(error);
+      signal?.throwIfAborted();
+      if (!this.#send) throw new Error("Codex app-server is not connected");
+      const id = this.#nextId++;
+      const completion = Promise.withResolvers();
+      this.#pending.set(id, completion);
+      const _listener = __using(_stack, signal ? addAbortListener(signal, () => completion.reject(signal.reason)) : void 0);
+      try {
+        this.#send({ id, method, params });
+        return await completion.promise;
+      } finally {
+        this.#pending.delete(id);
+      }
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      __callDispose(_stack, _error, _hasError);
     }
-    return completion.promise;
   }
   close() {
     this.#close?.();
@@ -4313,7 +4361,6 @@ var AppServer = class {
     if (typeof message.id !== "number") return;
     const pending = this.#pending.get(message.id);
     if (!pending) return;
-    this.#pending.delete(message.id);
     if (message.error) pending.reject(new Error(message.error.message));
     else pending.resolve(message.result);
   }
@@ -4325,8 +4372,194 @@ var AppServer = class {
   }
 };
 
-// src/responses.ts
+// src/desktop.ts
 import { randomUUID } from "node:crypto";
+import { once } from "node:events";
+import { connect } from "node:net";
+import { join } from "node:path";
+var Desktop = class {
+  #receive;
+  #stopped = Promise.withResolvers();
+  #pending = /* @__PURE__ */ new Map();
+  #snapshots = /* @__PURE__ */ new Map();
+  #socket;
+  #length = 0;
+  #clientId = "initializing-client";
+  constructor(receive) {
+    this.#receive = receive;
+  }
+  get closed() {
+    return this.#stopped.promise;
+  }
+  async connect(home) {
+    const socket = connect(
+      process.platform === "win32" ? "\\\\.\\pipe\\codex-ipc" : join(home, "ipc", "ipc.sock")
+    );
+    this.#socket = socket;
+    socket.on("error", (error) => this.#ended(error));
+    socket.once(
+      "close",
+      () => this.#ended(new Error("Codex desktop connection closed"))
+    );
+    socket.on("readable", () => {
+      try {
+        for (; ; ) {
+          if (this.#length === 0) {
+            const header = socket.read(4);
+            if (!header) break;
+            this.#length = header.readUInt32LE();
+            if (this.#length === 0 || this.#length > 268435456)
+              throw new Error(
+                `Invalid Codex desktop frame length: ${this.#length}`
+              );
+          }
+          const body = socket.read(this.#length);
+          if (!body) break;
+          this.#length = 0;
+          this.#message(JSON.parse(body.toString("utf8")));
+        }
+      } catch (error) {
+        socket.destroy(
+          error instanceof Error ? error : new Error(String(error))
+        );
+      }
+    });
+    await once(socket, "connect");
+    const response = await this.request(
+      "initialize",
+      { clientType: "chappie" },
+      0
+    );
+    this.#clientId = response.result.clientId;
+  }
+  async request(method, params, version, owner, timeoutMs) {
+    const requestId = randomUUID();
+    const pending = Promise.withResolvers();
+    this.#pending.set(requestId, pending);
+    try {
+      this.#send({
+        type: "request",
+        requestId,
+        sourceClientId: this.#clientId,
+        method,
+        params,
+        version,
+        timeoutMs,
+        ...owner ? { targetClientId: owner } : {}
+      });
+      const message = await pending.promise;
+      return {
+        result: message.result,
+        handledByClientId: message.handledByClientId
+      };
+    } finally {
+      this.#pending.delete(requestId);
+    }
+  }
+  async owner(threadId, clientId) {
+    try {
+      const result = await this.request(
+        "thread-owner-discovery",
+        { hostId: "local", conversationId: threadId },
+        1,
+        clientId
+      );
+      return result.handledByClientId;
+    } catch (error) {
+      if (error.code === "no-client-found")
+        return void 0;
+      throw error;
+    }
+  }
+  follow(threadId, clientId) {
+    this.#send({
+      type: "broadcast",
+      method: "thread-stream-following-changed",
+      sourceClientId: this.#clientId,
+      ...clientId ? { targetClientIds: [clientId] } : {},
+      version: 1,
+      params: { hostId: "local", conversationId: threadId, following: true }
+    });
+  }
+  async snapshot(threadId, owner) {
+    const pending = { owner, ...Promise.withResolvers() };
+    const requests = this.#snapshots.get(threadId) ?? /* @__PURE__ */ new Set();
+    this.#snapshots.set(threadId, requests);
+    requests.add(pending);
+    const timer = setTimeout(
+      () => pending.reject(new Error("Codex desktop snapshot timed out")),
+      1e4
+    );
+    try {
+      this.follow(threadId);
+      return await pending.promise;
+    } finally {
+      clearTimeout(timer);
+      requests.delete(pending);
+      if (requests.size === 0) this.#snapshots.delete(threadId);
+    }
+  }
+  close() {
+    this.#socket?.destroy();
+    this.#ended(new Error("Codex desktop connection closed"));
+  }
+  #send(message) {
+    if (!this.#socket?.writable)
+      throw new Error("Codex desktop is not connected");
+    const body = Buffer.from(JSON.stringify(message));
+    const size = Buffer.alloc(4);
+    size.writeUInt32LE(body.length);
+    this.#socket.write(Buffer.concat([size, body]));
+  }
+  #message(message) {
+    if (message.type === "client-discovery-request") {
+      this.#send({
+        type: "client-discovery-response",
+        requestId: message.requestId,
+        response: { canHandle: false }
+      });
+      return;
+    }
+    if (message.type === "response" && message.requestId) {
+      const pending = this.#pending.get(message.requestId);
+      if (message.resultType === "error")
+        pending?.reject(
+          Object.assign(new Error(message.error), { code: message.error })
+        );
+      else pending?.resolve(message);
+      return;
+    }
+    const params = message.params;
+    if (message.method === "thread-stream-state-changed" && params) {
+      const change = params.change;
+      if (change.type === "snapshot" && typeof params.conversationId === "string") {
+        for (const pending of this.#snapshots.get(params.conversationId) ?? [])
+          if (pending.owner === message.sourceClientId)
+            pending.resolve(change.conversationState);
+      }
+    }
+    if (message.method === "client-status-changed" && params?.status === "disconnected") {
+      for (const requests of this.#snapshots.values())
+        for (const pending of requests)
+          if (pending.owner === params.clientId)
+            pending.reject(
+              new Error("Codex desktop session owner disconnected")
+            );
+    }
+    this.#receive(message);
+  }
+  #ended(error) {
+    for (const pending of this.#pending.values()) pending.reject(error);
+    this.#pending.clear();
+    for (const requests of this.#snapshots.values())
+      for (const pending of requests) pending.reject(error);
+    this.#snapshots.clear();
+    this.#stopped.resolve();
+  }
+};
+
+// src/responses.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
 function responseTools(tools, namespace) {
   return tools.flatMap((tool) => {
     if (tool.type === "namespace" && tool.name)
@@ -4398,7 +4631,7 @@ var ResponsesOutput = class extends ProviderOutput {
       "pending"
     );
     const items = [];
-    const id = `resp_${randomUUID()}`;
+    const id = `resp_${randomUUID2()}`;
     const created = Math.floor(Date.now() / 1e3);
     let sequence = 0;
     let heartbeat;
@@ -4438,7 +4671,7 @@ data: ${JSON.stringify({ type, sequence_number: sequence++, ...fields })}
           break;
         case "text_start": {
           const item = {
-            id: `msg_${randomUUID()}`,
+            id: `msg_${randomUUID2()}`,
             type: "message",
             role: "assistant",
             status: "in_progress",
@@ -4500,7 +4733,7 @@ data: ${JSON.stringify({ type, sequence_number: sequence++, ...fields })}
           if (!tool) throw new Error(`Unknown Codex tool: ${call.name}`);
           const { custom, ...wire } = tool.wire;
           const item = {
-            id: `${custom ? "ctc" : "fc"}_${randomUUID()}`,
+            id: `${custom ? "ctc" : "fc"}_${randomUUID2()}`,
             type: custom ? "custom_tool_call" : "function_call",
             call_id: call.id,
             ...wire,
@@ -4588,23 +4821,70 @@ data: ${JSON.stringify({ type, sequence_number: sequence++, ...fields })}
 
 // src/codex.ts
 var codexHome = await realpath(
-  process.env.CODEX_HOME ?? join(homedir(), ".codex")
+  process.env.CODEX_HOME ?? join2(homedir(), ".codex")
 );
+var RequestError = class extends Error {
+};
+function parseObject(text) {
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch (error) {
+    throw new RequestError(
+      error instanceof Error ? error.message : String(error),
+      { cause: error }
+    );
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new RequestError("A JSON object is required");
+  return value;
+}
+async function* loaded(connection) {
+  let cursor = null;
+  do {
+    const page = await connection.request(
+      "thread/loaded/list",
+      cursor ? { cursor } : {}
+    );
+    yield* page.data;
+    cursor = page.nextCursor;
+  } while (cursor);
+}
+function desktopThread(snapshot) {
+  return {
+    id: snapshot.id,
+    cwd: snapshot.latestThreadSettings?.cwd ?? snapshot.cwd,
+    name: snapshot.title,
+    model: snapshot.latestThreadSettings?.model ?? snapshot.latestModel,
+    modelProvider: snapshot.latestThreadSettings?.modelProvider ?? snapshot.modelProvider,
+    status: snapshot.threadRuntimeStatus ?? { type: "idle" }
+  };
+}
+function desktopTurns(snapshot) {
+  const history = snapshot.turnHistory?.history;
+  return history ? history.islands.flatMap(
+    (island) => island.entries.map(({ value }) => ({
+      key: value,
+      turn: history.entitiesByKey[value]
+    }))
+  ) : snapshot.turns.map((turn, key) => ({ key, turn }));
+}
 var CodexSession = class {
   session;
   tools;
-  #server;
+  connection;
   #inputs = /* @__PURE__ */ new Map();
   #seenInputs = /* @__PURE__ */ new Set();
   #results = /* @__PURE__ */ new Map();
   #attached = false;
+  #desktopTurn;
   thread;
   turn;
   output;
   catalog;
-  constructor(thread, server, config) {
+  constructor(thread, connection, config) {
     this.thread = thread;
-    this.#server = server;
+    this.connection = connection;
     this.session = new Session(this, config);
     this.tools = localTools(this.session);
   }
@@ -4619,15 +4899,16 @@ var CodexSession = class {
     };
   }
   active() {
-    return this.thread.modelProvider === "chappie";
+    return this.thread.modelProvider === "chappie" && this.thread.status.type !== "notLoaded";
   }
   isIdle() {
-    return this.thread.status.type === "idle";
+    return this.thread.status.type === "idle" || this.thread.status.type === "systemError";
   }
   async inspect(signal) {
     await this.session.ready(signal);
-    const result = await this.#server.request("skills/list", { cwds: [this.thread.cwd] });
-    const path = join(codexHome, "AGENTS.md");
+    const request = this.connection instanceof AppServer ? this.connection.request.bind(this.connection) : AppServer.query;
+    const result = await request("skills/list", { cwds: [this.thread.cwd] }, signal);
+    const path = join2(codexHome, "AGENTS.md");
     let globalAgents;
     try {
       await access(path);
@@ -4642,10 +4923,49 @@ var CodexSession = class {
     };
   }
   async history(range) {
+    if (!(this.connection instanceof AppServer)) {
+      const { desktop } = this.connection;
+      const { handledByClientId } = await desktop.request(
+        "thread-follower-load-complete-history",
+        { conversationId: this.thread.id },
+        1,
+        void 0,
+        3e5
+      );
+      const snapshot = await desktop.snapshot(
+        this.thread.id,
+        handledByClientId
+      );
+      const page2 = historyPage(
+        desktopTurns(snapshot).flatMap(
+          ({ turn }) => turn.items.map((item) => ({
+            id: item.id,
+            item,
+            turnId: turn.turnId,
+            timestamp: turn.turnStartedAtMs
+          }))
+        ),
+        range
+      );
+      return historyResult(
+        {
+          entries: await Promise.all(
+            page2.entries.map(async ({ item, turnId, timestamp }) => ({
+              ...await itemMessage(item),
+              id: item.id,
+              turnId,
+              ...timestamp === void 0 ? {} : { timestamp: new Date(timestamp).toISOString() }
+            }))
+          ),
+          hasMore: page2.hasMore
+        },
+        this.thread.id
+      );
+    }
     const items = [];
     let cursor = null;
     do {
-      const page2 = await this.#server.request("thread/items/list", {
+      const page2 = await this.connection.request("thread/items/list", {
         threadId: this.thread.id,
         sortDirection: "desc",
         limit: range.limit + 1,
@@ -4697,33 +5017,58 @@ var CodexSession = class {
     if (!this.isIdle()) return;
     this.thread.status = { type: "active" };
     try {
-      const result = await this.#server.request("turn/start", {
-        threadId: this.thread.id,
-        input: []
-      });
-      this.turn = result.turn.id;
+      const input = { threadId: this.thread.id, input: [] };
+      if (this.connection instanceof AppServer) {
+        const result = await this.connection.request(
+          "turn/start",
+          input
+        );
+        this.turn = result.turn.id;
+      } else {
+        await this.connection.desktop.request(
+          "thread-follower-start-turn",
+          { conversationId: this.thread.id, turnStart: { request: input } },
+          2
+        );
+      }
     } catch (error) {
       this.thread.status = { type: "idle" };
       throw error;
     }
   }
   async abort() {
-    if (this.turn)
-      await this.#server.request("turn/interrupt", {
+    if (!this.turn) return;
+    if (this.connection instanceof AppServer)
+      await this.connection.request("turn/interrupt", {
         threadId: this.thread.id,
         turnId: this.turn
       });
+    else
+      await this.connection.desktop.request(
+        "thread-follower-interrupt-turn",
+        {
+          conversationId: this.thread.id,
+          mode: "user-stop",
+          expectedTurnId: this.turn
+        },
+        4
+      );
   }
   async item(item) {
+    await this.#capture(item);
+    this.session.historyChanged();
+  }
+  async #capture(item) {
     if (!this.active()) return;
     if (this.output?.message.content.some(
       (call) => call.type === "toolCall" && call.id === item.id
     ))
       this.#results.set(item.id, item);
-    if (item.type === "userMessage" && item.content?.length && !this.#seenInputs.has(item.id)) {
-      this.#seenInputs.add(item.id);
-      this.#inputs.set(item.id, {
-        id: item.id,
+    const id = item.type === "userMessage" ? item.id : item.type === "steeringUserMessage" ? item.serverUserMessageId : void 0;
+    if (id && (item.content ?? item.input)?.length && !this.#seenInputs.has(id)) {
+      this.#seenInputs.add(id);
+      this.#inputs.set(id, {
+        id,
         sessionId: this.thread.id,
         message: {
           role: "user",
@@ -4732,19 +5077,80 @@ var CodexSession = class {
         }
       });
     }
+  }
+  async snapshot(snapshot) {
+    Object.assign(this.thread, desktopThread(snapshot));
+    const turns = desktopTurns(snapshot);
+    const current = turns.find(({ turn }) => turn.turnId === this.turn) ?? turns.findLast(({ turn }) => turn.status === "inProgress");
+    if (current) {
+      this.#desktopTurn = current.key;
+      if (current.turn.turnId) this.turn = current.turn.turnId;
+      for (const item of current.turn.items) await this.#capture(item);
+      if (current.turn.turnId && current.turn.status !== "inProgress")
+        await this.settled({
+          id: current.turn.turnId,
+          status: current.turn.status,
+          items: current.turn.items,
+          error: current.turn.error ?? null
+        });
+    }
+    this.session.update();
+  }
+  async patches(patches) {
+    if (this.connection instanceof AppServer) return;
+    let refresh = false;
+    for (const patch of patches) {
+      if ([
+        "title",
+        "cwd",
+        "latestModel",
+        "modelProvider",
+        "latestThreadSettings",
+        "threadRuntimeStatus"
+      ].includes(String(patch.path[0])))
+        refresh = true;
+      const path = patch.path[0] === "turnHistory" && patch.path[1] === "history" && patch.path[2] === "entitiesByKey" ? patch.path.slice(3) : patch.path[0] === "turns" ? patch.path.slice(1) : [];
+      if (path[0] !== this.#desktopTurn) continue;
+      if (path.length === 1 || path[1] === "status" || path[1] === "error" || path[1] === "turnId")
+        refresh = true;
+      if (path[1] === "items" && patch.op !== "remove") {
+        if (path.length === 2 && Array.isArray(patch.value))
+          for (const item of patch.value) await this.#capture(item);
+        else if (path.length === 3 && patch.value && typeof patch.value === "object")
+          await this.#capture(patch.value);
+      }
+    }
+    if (refresh)
+      await this.snapshot(
+        await this.connection.desktop.snapshot(
+          this.thread.id,
+          this.connection.owner
+        )
+      );
     this.session.historyChanged();
   }
-  async respond(request, response, signal) {
+  async respond(request, context, response, signal) {
+    if (context?.request_kind === "turn" && context.turn_id)
+      this.turn = context.turn_id;
     if (!this.#attached) {
-      const result = await this.#server.request("thread/resume", {
-        threadId: this.thread.id,
-        excludeTurns: true,
-        initialTurnsPage: { limit: 1, itemsView: "full" }
-      });
-      this.thread = result.thread;
-      for (const turn of result.initialTurnsPage.data) {
-        if (turn.status === "inProgress") this.turn = turn.id;
-        for (const item of turn.items) await this.item(item);
+      if (this.connection instanceof AppServer) {
+        const result = await this.connection.request("thread/resume", {
+          threadId: this.thread.id,
+          excludeTurns: true,
+          initialTurnsPage: { limit: 1, itemsView: "full" }
+        });
+        this.thread = result.thread;
+        for (const turn of result.initialTurnsPage.data) {
+          if (turn.status === "inProgress") this.turn = turn.id;
+          for (const item of turn.items) await this.item(item);
+        }
+      } else {
+        await this.snapshot(
+          await this.connection.desktop.snapshot(
+            this.thread.id,
+            this.connection.owner
+          )
+        );
       }
       this.#attached = true;
     }
@@ -4766,15 +5172,14 @@ var CodexSession = class {
           toolName: call.name,
           content: responseContent(item.output),
           isError: itemFailed(native),
-          ...native?.result?.structuredContent?.details ? { details: native.result.structuredContent.details } : {}
+          ...native?.result?._meta?.details ? { details: native.result._meta.details } : {}
         });
       }
       this.session.complete(previous.message, results);
       this.output = void 0;
       this.#results.clear();
     }
-    const metadata = request.client_metadata?.["x-codex-turn-metadata"];
-    const kind = metadata ? JSON.parse(metadata).request_kind : void 0;
+    const kind = context?.request_kind;
     if (kind === "compaction") {
       const output2 = new ResponsesOutput(request, [], response, signal);
       try {
@@ -4784,11 +5189,11 @@ var CodexSession = class {
       }
       return;
     }
-    this.catalog = responseTools(request.tools ?? []).flatMap((tool) => {
+    this.catalog = responseTools(request.tools ?? []).map((tool) => {
       const local = ["chappie", "mcp__chappie"].includes(
         tool.wire.namespace ?? ""
       ) ? definitions.find((definition) => definition.name === tool.wire.name) : void 0;
-      return local ? local.name === "transfer" ? [{ ...tool, name: local.name }] : [] : [tool];
+      return local ? { ...tool, name: local.name } : tool;
     });
     const output = new ResponsesOutput(request, this.catalog, response, signal);
     this.output = output;
@@ -4821,7 +5226,7 @@ var CodexSession = class {
               }
             ],
             isError: !item || item.status === "inProgress" || itemFailed(item),
-            ...item?.result?.structuredContent?.details ? { details: item.result.structuredContent.details } : {}
+            ...item?.result?._meta?.details ? { details: item.result._meta.details } : {}
           };
         })
       );
@@ -4834,6 +5239,7 @@ var CodexSession = class {
     }
     this.#results.clear();
     this.#seenInputs.clear();
+    this.#desktopTurn = void 0;
     this.catalog = void 0;
     await this.session.settled(
       turn.error ? new Error(turn.error.message) : void 0
@@ -4856,21 +5262,27 @@ async function itemMessage(item) {
   const message = { ...item };
   let content;
   switch (item.type) {
+    case "steeringUserMessage":
     case "userMessage":
       delete message.content;
+      delete message.input;
+      delete message.restoreMessage;
+      delete message.compareKey;
       message.role = "user";
       content = (await Promise.all(
-        (item.content ?? []).map(async (block) => {
-          if (block.type === "text" && typeof block.text === "string")
-            return [{ type: "text", text: block.text }];
-          if (block.type === "localImage" && typeof block.path === "string")
-            return [await image(block.path)];
-          if (block.type === "image" && typeof block.url === "string")
-            return responseContent([
-              { type: "input_image", image_url: block.url }
-            ]);
-          return [{ type: "text", text: JSON.stringify(block) }];
-        })
+        (item.content ?? item.input ?? []).map(
+          async (block) => {
+            if (block.type === "text" && typeof block.text === "string")
+              return [{ type: "text", text: block.text }];
+            if (block.type === "localImage" && typeof block.path === "string")
+              return [await image(block.path)];
+            if (block.type === "image" && typeof block.url === "string")
+              return responseContent([
+                { type: "input_image", image_url: block.url }
+              ]);
+            return [{ type: "text", text: JSON.stringify(block) }];
+          }
+        )
       )).flat();
       break;
     case "agentMessage":
@@ -4886,8 +5298,7 @@ async function itemMessage(item) {
       if (item.result) {
         const { content: blocks, ...metadata } = item.result;
         message.result = metadata;
-        if (metadata.structuredContent?.details)
-          message.details = metadata.structuredContent.details;
+        if (metadata._meta?.details) message.details = metadata._meta.details;
         content = responseContent(blocks);
       } else {
         delete message.error;
@@ -4923,42 +5334,233 @@ async function serveCodex() {
   const clients = /* @__PURE__ */ new Set();
   const stopped = Promise.withResolvers();
   const stop = () => stopped.resolve();
-  let events = Promise.resolve();
-  const rpc = new AppServer((message) => {
-    events = events.then(() => receive(message)).catch((error) => console.error(error));
-  });
-  function register(thread) {
+  const events = { rpc: Promise.resolve(), desktop: Promise.resolve() };
+  let rpc;
+  let desktop;
+  let rpcConnecting;
+  let desktopConnecting;
+  function register(thread, connection) {
     let state = sessions.get(thread.id);
+    if (state && state.connection !== connection) {
+      if (state.connection instanceof AppServer || connection instanceof AppServer || state.connection.desktop !== connection.desktop) {
+        state.session.close();
+        state = void 0;
+      } else state.connection.owner = connection.owner;
+    }
     if (state) state.thread = thread;
     else {
-      state = new CodexSession(thread, rpc, config);
+      state = new CodexSession(thread, connection, config);
       sessions.set(thread.id, state);
     }
     state.session.update();
     return state;
   }
-  const get = (threadId) => {
+  function disconnected(connection) {
+    if (connection === rpc) rpc = void 0;
+    if (connection === desktop) desktop = void 0;
+    for (const [id, state] of sessions)
+      if (state.connection === connection || !(state.connection instanceof AppServer) && state.connection.desktop === connection) {
+        state.session.close();
+        sessions.delete(id);
+      }
+  }
+  function attachDesktop() {
+    desktopConnecting ??= (async () => {
+      if (desktop) return desktop;
+      const connection = new Desktop((message) => {
+        events.desktop = events.desktop.then(async () => {
+          await desktopConnecting;
+          if (desktop === connection)
+            await receiveDesktop(connection, message);
+        }).catch((error) => console.error(error));
+      });
+      desktop = connection;
+      void connection.closed.then(() => disconnected(connection));
+      try {
+        await connection.connect(codexHome);
+        return connection;
+      } catch (error) {
+        connection.close();
+        if (!["ENOENT", "ECONNREFUSED"].includes(
+          error.code ?? ""
+        ))
+          throw error;
+        return void 0;
+      }
+    })().finally(() => {
+      desktopConnecting = void 0;
+    });
+    return desktopConnecting;
+  }
+  function attachServer() {
+    rpcConnecting ??= (async () => {
+      if (rpc) return rpc;
+      if (!config.codex?.appServer) {
+        try {
+          await access(
+            join2(codexHome, "app-server-control", "app-server-control.sock")
+          );
+        } catch (error) {
+          if (error.code === "ENOENT")
+            return void 0;
+          throw error;
+        }
+      }
+      const connection = new AppServer((message) => {
+        events.rpc = events.rpc.then(async () => {
+          await rpcConnecting;
+          if (rpc === connection) await receive(message, connection);
+        }).catch((error) => console.error(error));
+      });
+      rpc = connection;
+      void connection.closed.then(() => disconnected(connection));
+      await connection.connect(appServer);
+      for await (const threadId of loaded(connection)) {
+        try {
+          const { thread } = await connection.request(
+            "thread/read",
+            { threadId }
+          );
+          register(thread, connection);
+        } catch (error) {
+          console.error(error);
+        }
+      }
+      return connection;
+    })().finally(() => {
+      rpcConnecting = void 0;
+    });
+    return rpcConnecting;
+  }
+  function attach() {
+    void attachDesktop().catch((error) => console.error(error));
+    void attachServer().catch((error) => console.error(error));
+  }
+  const get = (threadId, control = false) => {
     const existing = sessions.get(threadId);
-    if (existing) return Promise.resolve(existing);
+    if (existing && (!control || existing.thread.status.type !== "notLoaded"))
+      return Promise.resolve(existing);
     let pending = loading.get(threadId);
     if (!pending) {
-      pending = rpc.request("thread/read", { threadId }).then(({ thread }) => register(thread)).finally(() => loading.delete(threadId));
+      pending = (async () => {
+        const connection = await Promise.any([
+          attachServer().then(async (connection2) => {
+            if (connection2) {
+              for await (const id of loaded(connection2))
+                if (id === threadId) return connection2;
+            }
+            throw new RequestError(
+              "Thread is not loaded in the Codex app-server"
+            );
+          }),
+          attachDesktop().then(async (desktop2) => {
+            const owner = await desktop2?.owner(threadId);
+            if (desktop2 && owner) return { desktop: desktop2, owner };
+            throw new RequestError("Thread has no Codex desktop owner");
+          })
+        ]).catch((error) => {
+          const Failure = error.errors.every(
+            (reason) => reason instanceof RequestError
+          ) ? RequestError : Error;
+          throw new Failure(
+            `No connected Codex client owns thread ${threadId}: ${error.errors.map(String).join("; ")}`,
+            { cause: error }
+          );
+        });
+        if (connection instanceof AppServer) {
+          const { thread } = await connection.request(
+            "thread/read",
+            { threadId }
+          );
+          return register(thread, connection);
+        }
+        const snapshot = await connection.desktop.snapshot(
+          threadId,
+          connection.owner
+        );
+        const state = register(desktopThread(snapshot), connection);
+        await state.snapshot(snapshot);
+        return state;
+      })().finally(() => loading.delete(threadId));
       loading.set(threadId, pending);
     }
-    return pending;
+    return control ? pending : pending.catch(async (error) => {
+      const connection = await attachServer();
+      if (!connection) throw error;
+      const { thread } = await connection.request(
+        "thread/read",
+        { threadId }
+      );
+      return register(thread, connection);
+    });
   };
-  async function receive(message) {
+  async function receiveDesktop(connection, message) {
+    const params = message.params;
+    if (!params) return;
+    if (message.method === "client-status-changed") {
+      if (params.status === "connected" && params.isSelf !== true && typeof params.clientId === "string") {
+        for (const [id, state2] of sessions)
+          if (!(state2.connection instanceof AppServer) && state2.connection.desktop === connection)
+            connection.follow(id, params.clientId);
+      }
+      if (params.status === "disconnected") {
+        for (const [id, state2] of sessions)
+          if (!(state2.connection instanceof AppServer) && state2.connection.owner === params.clientId) {
+            state2.session.close();
+            sessions.delete(id);
+          }
+      }
+      return;
+    }
+    if (params.hostId !== "local" || typeof params.conversationId !== "string" || !message.sourceClientId)
+      return;
+    const threadId = params.conversationId;
+    if (message.method === "thread-stream-following-changed" && params.following === true || message.method === "thread-stream-following-status-requested") {
+      if (sessions.has(threadId) && message.method === "thread-stream-following-changed")
+        return;
+      const owner = message.method === "thread-stream-following-status-requested" ? message.sourceClientId : await connection.owner(threadId, message.sourceClientId);
+      if (owner) {
+        const snapshot = await connection.snapshot(threadId, owner);
+        await register(desktopThread(snapshot), {
+          desktop: connection,
+          owner
+        }).snapshot(snapshot);
+      }
+      return;
+    }
+    const state = sessions.get(threadId);
+    if (!state || state.connection instanceof AppServer || state.connection.desktop !== connection)
+      return;
+    if (message.method === "thread-stream-state-changed") {
+      const change = params.change;
+      if (state.connection.owner !== message.sourceClientId) {
+        const owner = await connection.owner(threadId, message.sourceClientId);
+        if (!owner) return;
+        const snapshot = change.type === "snapshot" ? change.conversationState : await connection.snapshot(threadId, owner);
+        await register(desktopThread(snapshot), {
+          desktop: connection,
+          owner
+        }).snapshot(snapshot);
+      } else if (change.type === "snapshot")
+        await state.snapshot(change.conversationState);
+      else if (change.type === "patches") await state.patches(change.patches);
+    } else if (message.method === "thread-archived" && state.connection.owner === message.sourceClientId) {
+      state.session.close();
+      sessions.delete(threadId);
+    }
+  }
+  async function receive(message, connection) {
     const params = message.params;
     if (!params) return;
     if (message.id !== void 0) return;
     if (message.method === "thread/started") {
       const thread = params.thread;
-      register(thread);
+      register(thread, connection);
       return;
     }
     if (typeof params.threadId !== "string") return;
     const state = sessions.get(params.threadId);
-    if (!state) return;
+    if (!state || state.connection !== connection) return;
     switch (message.method) {
       case "thread/settings/updated": {
         const settings = params.threadSettings;
@@ -4972,6 +5574,7 @@ async function serveCodex() {
         break;
       case "thread/status/changed":
         state.thread.status = params.status;
+        state.session.update();
         break;
       case "thread/closed":
       case "thread/archived":
@@ -4994,13 +5597,16 @@ async function serveCodex() {
   }
   const server = createServer((request, response) => {
     void handle(request, response).catch((error) => {
+      const status = error instanceof RequestError ? 400 : 500;
+      if (status === 500) console.error(error);
       if (response.headersSent)
         response.destroy(error instanceof Error ? error : void 0);
       else {
-        response.writeHead(500, { "Content-Type": "application/json" });
+        response.writeHead(status, { "Content-Type": "application/json" });
         response.end(
           JSON.stringify({
             error: {
+              type: status === 400 ? "invalid_request_error" : "server_error",
               message: error instanceof Error ? error.message : String(error)
             }
           })
@@ -5016,7 +5622,7 @@ async function serveCodex() {
         controller.abort(new Error("Codex request cancelled"));
     });
     if (request.method === "GET" && route === "/client") {
-      await connected;
+      attach();
       clients.add(response);
       response.once("close", () => {
         clients.delete(response);
@@ -5027,43 +5633,54 @@ async function serveCodex() {
       return;
     }
     if (request.method === "GET" && route === "/") {
-      await connected;
       response.setHeader("Content-Type", "application/json");
       response.end(JSON.stringify({ name: "chappie", codexHome, appServer }));
       return;
     }
-    if (request.method !== "POST") {
-      response.writeHead(404);
-      response.end();
-      return;
-    }
-    await connected;
+    if (request.method !== "POST")
+      throw new RequestError(
+        `Unsupported Chappie request: ${request.method} ${route}`
+      );
     const chunks = [];
     for await (const chunk of request) chunks.push(Buffer.from(chunk));
-    const body = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+    const body = parseObject(Buffer.concat(chunks).toString("utf8"));
     if (route === "/v1/responses") {
+      const payload = body;
+      const metadata = payload.client_metadata?.["x-codex-turn-metadata"];
+      const context = metadata ? parseObject(metadata) : void 0;
+      if (context?.thread_source === "memory_consolidation")
+        throw new RequestError(
+          "Background memory generation is not supported by Chappie"
+        );
       const threadId = request.headers["thread-id"];
       if (typeof threadId !== "string")
-        throw new Error("Codex did not provide a thread-id header");
-      const state = await get(threadId);
-      await events;
+        throw new RequestError("Codex did not provide a thread-id header");
+      const state = await get(threadId, true);
+      await (state.connection instanceof AppServer ? events.rpc : events.desktop);
       if (!state.active()) {
-        const { thread } = await rpc.request(
-          "thread/read",
-          { threadId }
-        );
-        register(thread);
+        if (state.connection instanceof AppServer) {
+          const { thread } = await state.connection.request(
+            "thread/read",
+            { threadId }
+          );
+          register(thread, state.connection);
+        } else {
+          await state.snapshot(
+            await state.connection.desktop.snapshot(
+              threadId,
+              state.connection.owner
+            )
+          );
+        }
       }
-      await state.respond(
-        body,
-        response,
-        controller.signal
-      );
+      if (!state.active())
+        throw new RequestError("Chappie is not active for this session");
+      await state.respond(payload, context, response, controller.signal);
       return;
     }
     if (route === "/resource") {
       if (typeof body.threadId !== "string" || typeof body.uri !== "string")
-        throw new Error("Resource requests require threadId and uri");
+        throw new RequestError("Resource requests require threadId and uri");
       const state = await get(body.threadId);
       const resource = await state.session.resource(
         body.uri,
@@ -5075,20 +5692,18 @@ async function serveCodex() {
     }
     if (route.startsWith("/tools/")) {
       if (typeof body.threadId !== "string")
-        throw new Error("Codex did not provide threadId metadata");
+        throw new RequestError("Codex did not provide threadId metadata");
       const state = await get(body.threadId);
       const name = decodeURIComponent(route.slice("/tools/".length));
       const tool = state.tools.find((tool2) => tool2.name === name);
-      if (!tool) throw new Error(`Unknown Chappie tool: ${name}`);
+      if (!tool) throw new RequestError(`Unknown Chappie tool: ${name}`);
       const result = await tool.execute(body.arguments, controller.signal);
       response.setHeader("Content-Type", "application/json");
       response.end(JSON.stringify(result));
       return;
     }
-    response.writeHead(404);
-    response.end();
+    throw new RequestError(`Unknown Chappie endpoint: ${route}`);
   }
-  let connected;
   try {
     try {
       await new Promise((resolve, reject) => {
@@ -5109,32 +5724,17 @@ async function serveCodex() {
       process.send?.({ ready: true });
       return;
     }
-    connected = rpc.connect(appServer);
-    await connected;
+    attach();
     process.send?.({ ready: true });
-    let cursor = null;
-    do {
-      const page = await rpc.request(
-        "thread/loaded/list",
-        cursor ? { cursor } : {}
-      );
-      for (const id of page.data) {
-        try {
-          await get(id);
-        } catch (error) {
-          console.error(error);
-        }
-      }
-      cursor = page.nextCursor;
-    } while (cursor);
     process.once("SIGINT", stop);
     process.once("SIGTERM", stop);
-    await Promise.race([stopped.promise, rpc.closed]);
+    await stopped.promise;
     process.off("SIGINT", stop);
     process.off("SIGTERM", stop);
   } finally {
     for (const state of sessions.values()) state.session.close();
-    rpc.close();
+    rpc?.close();
+    desktop?.close();
     server.closeAllConnections();
     await new Promise((resolve) => server.close(() => resolve()));
   }