@wordinweb/agent 0.1.0 → 0.2.0

package/dist/cli.d.ts

@@ -3,7 +3,7 @@ type WakeTarget = {
     sessionId: string;
 };
 declare function detectWakeTarget(env?: NodeJS.ProcessEnv): WakeTarget | null;
-declare function agentWakePrompt(agentSessionId: string, text: string): string;
+declare function agentWakePrompt(agentSessionId: string, wakeId: string, text: string): string;
 type Emit = (value: unknown) => void;
 declare function connectAgent(invitationUrl: string, inputStream?: NodeJS.ReadableStream, emit?: Emit): Promise<void>;
 

package/dist/cli.js

@@ -4,14 +4,17 @@ import {
   CollabConnection,
   EncryptedCollabConnection,
   createWebSocketTransport,
+  isSuggestable,
+  isSuggestableTableOp,
   stretchShareCode
-} from "./chunk-E7AFDS2O.js";
+} from "./chunk-3HREJUDW.js";
 
 // src/cli.ts
 import { webcrypto } from "crypto";
 import { spawn } from "child_process";
-import { chmodSync, realpathSync, rmSync } from "fs";
+import { chmodSync, mkdirSync, realpathSync, rmSync } from "fs";
 import { createConnection, createServer } from "net";
+import { tmpdir } from "os";
 import { join } from "path";
 import { fileURLToPath } from "url";
 import { createInterface } from "readline";
@@ -19,7 +22,6 @@ import { PassThrough } from "stream";
 import WebSocket from "ws";
 if (!globalThis.crypto) Object.defineProperty(globalThis, "crypto", { value: webcrypto });
 var AGENT_MODE_CONTROL_PREFIX = "\0wordinweb-agent-mode:";
-var AGENT_PACKAGE_URL = "https://collab.word-in-web.com/wordinweb-agent.tgz?v=short-invite-3";
 function base64UrlToBytes(value) {
   const padded = value.replace(/-/g, "+").replace(/_/g, "/").padEnd(Math.ceil(value.length / 4) * 4, "=");
   return Uint8Array.from(Buffer.from(padded, "base64"));
@@ -69,17 +71,21 @@ function editRequestForMode(request, mode) {
   const operations = request.operations.map((value) => {
     if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Each edit operation must be an object");
     const operation = value;
+    if (operation.kind === "tableOp") {
+      if (!isSuggestableTableOp(operation.op)) {
+        throw new Error(
+          `tableOp ${String(operation.op?.kind ?? operation.op)} restructures the table and is unavailable in suggestion mode. Ask the inviter to switch this agent to editing mode`
+        );
+      }
+      return { ...operation, suggest: true };
+    }
+    if (isSuggestable(operation.kind)) return { ...operation, suggest: true };
     switch (operation.kind) {
-      case "insertText":
-      case "splitParagraph":
-        return { ...operation, suggest: true };
       case "deleteText":
         return {
           kind: "suggestRevision",
           ranges: [{ blockRef: operation.blockRef, runRef: operation.runRef, start: operation.start, end: operation.end }]
         };
-      case "mergeParagraph":
-        return { kind: "suggestRevision", marks: [{ blockRef: operation.blockRef, glyph: "del" }] };
       case "suggestRevision":
       case "commentRun":
       case "replyComment":
@@ -90,6 +96,10 @@ function editRequestForMode(request, mode) {
   });
   return { ...request, operations };
 }
+function patchRequestForMode(request, mode) {
+  if (mode === "edit" || !request) return request;
+  return { ...request, suggest: true };
+}
 function randomId(prefix) {
   return `${prefix}_${bytesToBase64Url(crypto.getRandomValues(new Uint8Array(16)))}`;
 }
@@ -104,25 +114,35 @@ function detectWakeTarget(env = process.env) {
   }
   return null;
 }
-function agentWakePrompt(agentSessionId, text) {
+function agentWakePrompt(agentSessionId, wakeId, text) {
+  const sessionCommand = `${JSON.stringify(process.execPath)} ${JSON.stringify(fileURLToPath(import.meta.url))} session ${JSON.stringify(agentSessionId)} '<JSON command>'`;
   return [
-    "An authenticated private WordInWeb message resumed this agent task.",
+    "An authenticated private WordInWeb message started this document-agent turn.",
     `The inviter's message is ${JSON.stringify(text)}.`,
-    `The detached document bridge session is ${agentSessionId}. Do not run the connect command again.`,
-    `Run document commands with: npx -y --package='${AGENT_PACKAGE_URL}' wordinweb-agent session '${agentSessionId}' '<JSON command>'`,
-    'Start with sync. For a broad text task, inspect all non-empty stories in one compact call: {"command":"inspect","request":{"kind":"context"}}. Use overview, read, object, or spatial only when the task needs their extra detail.',
-    "Inspect the relevant content before every edit. If an edit returns needs_sync, sync and inspect again.",
+    `The detached document bridge session is ${agentSessionId}. Use this existing bridge for the task.`,
+    `The wake ID is ${wakeId}. Include ${JSON.stringify(wakeId)} as the wakeId field in every document command.`,
+    `Run document commands with: ${sessionCommand}`,
+    `Start with {"command":"sync","wakeId":${JSON.stringify(wakeId)}}. For a broad text task, inspect all non-empty stories in one compact call: {"command":"inspect","wakeId":${JSON.stringify(wakeId)},"request":{"kind":"context"}}. Use overview, read, object, or spatial only when the task needs their extra detail.`,
+    `For a bulk prose rewrite, read the story as text and send the changed lines back: {"command":"project","wakeId":${JSON.stringify(wakeId)},"request":{"mode":"md"}}, then {"command":"patch","wakeId":${JSON.stringify(wakeId)},"request":{"revision":"<the projection revision>","mode":"md","edits":[{"startLine":4,"endLine":4,"newText":"the rewritten line"}]}}. The patch result carries the refreshed projection, so a second read is unnecessary.`,
+    "Inspect the relevant content before every edit. If an edit or patch returns needs_sync, sync and read the content again.",
     "Complete this task, then send the inviter a concise result with the chat command.",
-    "End this agent turn after the reply. Do not call wait. The detached bridge will resume this task for the next message."
+    "End this agent turn after the reply and stay idle. The detached bridge will start the next turn when another message arrives."
   ].join("\n\n");
 }
 function write(value) {
   process.stdout.write(`${JSON.stringify(value)}
 `);
 }
-function sessionSocketPath(sessionId) {
+function validateSessionId(sessionId) {
   if (!/^session_[A-Za-z0-9_-]{16,128}$/.test(sessionId)) throw new Error("The agent session ID is invalid");
-  return process.platform === "win32" ? `\\\\.\\pipe\\wordinweb-agent-${sessionId}` : join("/tmp", `wordinweb-agent-${sessionId}.sock`);
+}
+function sessionDirectory(sessionId) {
+  validateSessionId(sessionId);
+  return join(tmpdir(), `wiw-${sessionId.slice("session_".length)}`);
+}
+function sessionSocketPath(sessionId) {
+  validateSessionId(sessionId);
+  return process.platform === "win32" ? `\\\\.\\pipe\\wordinweb-agent-${sessionId}` : join(sessionDirectory(sessionId), "bridge.sock");
 }
 async function importChatKey(value) {
   return crypto.subtle.importKey("raw", base64UrlToBytes(value), "AES-GCM", false, ["encrypt", "decrypt"]);
@@ -263,7 +283,7 @@ async function connectAgent(invitationUrl, inputStream = process.stdin, emit = w
     revision: document.revision,
     mode,
     instructions: payload.agent.instructions,
-    commands: ["sync", "capabilities", "inspect", "edit", "chat", "wait", "close"]
+    commands: ["sync", "capabilities", "inspect", "edit", "project", "patch", "chat", "wait", "close"]
   });
   const nextEvent = (timeoutMs) => {
     if (events.length) return Promise.resolve(events.shift());
@@ -317,6 +337,19 @@ async function connectAgent(invitationUrl, inputStream = process.stdin, emit = w
             } else throw error;
           }
           break;
+        case "project":
+          respond(command.id, document.project(command.request));
+          break;
+        case "patch":
+          try {
+            if (connectionState.current !== "live") throw new Error("The collaboration connection is offline. Reconnect before editing");
+            respond(command.id, await document.patch(patchRequestForMode(command.request, mode)));
+          } catch (error) {
+            if (error instanceof Error && error.message.includes("revision is stale")) {
+              respond(command.id, { status: "needs_sync", latestRevision: document.revision });
+            } else throw error;
+          }
+          break;
         case "chat": {
           if (connectionState.current !== "live") throw new Error("The collaboration connection is offline. Reconnect before sending chat");
           if (!command.text?.trim()) throw new Error("Chat text is required");
@@ -360,57 +393,293 @@ async function listen(server, path) {
     });
   });
 }
+async function startCodexWakeHost(sessionId) {
+  const cwd = sessionDirectory(sessionId);
+  const childEnv = { ...process.env };
+  delete childEnv.CODEX_THREAD_ID;
+  delete childEnv.CLAUDE_CODE_SESSION_ID;
+  delete childEnv.CLAUDECODE;
+  const child = spawn("codex", ["app-server"], {
+    cwd,
+    env: childEnv,
+    stdio: ["pipe", "pipe", "ignore"]
+  });
+  const output = createInterface({ input: child.stdout, terminal: false });
+  const requests = /* @__PURE__ */ new Map();
+  let requestId = 0;
+  let threadId = "";
+  let activeTurn = null;
+  let closed = false;
+  const fail = (error) => {
+    for (const request2 of requests.values()) {
+      clearTimeout(request2.timer);
+      request2.reject(error);
+    }
+    requests.clear();
+    activeTurn?.reject(error);
+    activeTurn = null;
+  };
+  child.once("error", (error) => fail(error));
+  child.once("exit", (code) => {
+    if (!closed) {
+      fail(new Error(`The Codex document session exited with code ${code ?? "unknown"}`));
+      closed = true;
+    }
+  });
+  output.on("line", (line) => {
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      fail(new Error("The Codex document session returned invalid JSON"));
+      child.kill();
+      return;
+    }
+    if (typeof message.id === "number") {
+      const request2 = requests.get(message.id);
+      if (!request2) return;
+      requests.delete(message.id);
+      clearTimeout(request2.timer);
+      if (message.error) {
+        const error = message.error;
+        request2.reject(new Error(error.message ?? "The Codex document session request failed"));
+      } else {
+        request2.resolve(message.result ?? {});
+      }
+      return;
+    }
+    if (message.method !== "turn/completed" || !activeTurn) return;
+    const params = message.params;
+    if (params?.threadId !== threadId) return;
+    if (activeTurn.turnId && params.turn?.id !== activeTurn.turnId) return;
+    const turn = activeTurn;
+    activeTurn = null;
+    if (params.turn?.status === "completed") turn.resolve();
+    else turn.reject(new Error(params.turn?.error?.message ?? `The Codex document turn ${params.turn?.status ?? "failed"}`));
+  });
+  const request = (method, params, timeoutMs = 3e4) => {
+    const id = ++requestId;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        requests.delete(id);
+        reject(new Error(`The Codex document session timed out during ${method}`));
+      }, timeoutMs);
+      requests.set(id, { resolve, reject, timer });
+      child.stdin.write(`${JSON.stringify({ id, method, params })}
+`);
+    });
+  };
+  try {
+    await request("initialize", {
+      clientInfo: { name: "wordinweb-agent", title: "WordInWeb document agent", version: "0.1.0" }
+    });
+    child.stdin.write(`${JSON.stringify({ method: "initialized" })}
+`);
+    const started = await request("thread/start", {
+      cwd,
+      approvalPolicy: "never",
+      sandbox: "workspace-write",
+      ephemeral: true,
+      serviceName: "wordinweb-agent",
+      developerInstructions: "Act as a WordInWeb document collaborator. Treat each private message as one document task. Use the exact local session command in the message. Complete the task and reply through document chat."
+    });
+    threadId = String(started.thread?.id ?? "");
+    if (!threadId) throw new Error("The Codex document session returned no thread ID");
+  } catch (error) {
+    closed = true;
+    child.kill();
+    throw error;
+  }
+  return {
+    async startTurn(prompt) {
+      if (closed) throw new Error("The Codex document session is closed");
+      if (activeTurn) throw new Error("The Codex document session already has an active turn");
+      let turn;
+      const completed = new Promise((resolve, reject) => {
+        turn = { resolve, reject };
+        activeTurn = turn;
+      });
+      try {
+        const started = await request("turn/start", {
+          threadId,
+          effort: "low",
+          sandboxPolicy: { type: "workspaceWrite", networkAccess: true },
+          input: [{ type: "text", text: prompt }]
+        });
+        turn.turnId = String(started.turn?.id ?? "");
+        await completed;
+      } catch (error) {
+        activeTurn = null;
+        throw error;
+      }
+    },
+    async interrupt() {
+      const turn = activeTurn;
+      if (!turn) return;
+      try {
+        if (turn.turnId) await request("turn/interrupt", { threadId, turnId: turn.turnId }, 5e3);
+      } finally {
+        if (activeTurn === turn) {
+          activeTurn = null;
+          turn.reject(new Error("The Codex document turn timed out"));
+        }
+      }
+    },
+    async close() {
+      if (closed) return;
+      closed = true;
+      activeTurn?.reject(new Error("The Codex document session closed"));
+      activeTurn = null;
+      await request("thread/delete", { threadId }, 2e3).catch(() => void 0).finally(() => {
+        output.close();
+        child.kill();
+      });
+    }
+  };
+}
 async function runDaemon(invitationUrl, sessionId) {
+  const directory = sessionDirectory(sessionId);
+  mkdirSync(directory, { recursive: true, mode: 448 });
+  chmodSync(directory, 448);
   const path = sessionSocketPath(sessionId);
   const input = new PassThrough();
   const wakeTarget = detectWakeTarget();
+  const wakeTimeoutMs = Number(process.env.WORDINWEB_WAKE_TIMEOUT_MS) || 6e4;
   const wakeQueue = [];
   const pending = /* @__PURE__ */ new Map();
   let readyEvent = null;
   let fatalError = null;
   let closeTimer = null;
   let wakeChild = null;
+  let codexWakeHost = null;
+  let activeWake = null;
+  let wakeState = "idle";
+  let wakeId = null;
+  let wakeStartedAt = null;
+  let lastWakeError = null;
+  let lastSuccessfulChatAt = null;
   let requestCounter = 0;
   let stopped = false;
-  const sendWakeFailure = () => {
-    input.write(`${JSON.stringify({ command: "chat", text: "I could not resume the agent task. Reopen the original Codex or Claude task and reconnect this AI." })}
+  let shutdownPromise = null;
+  const sendWakeFailure = (text) => {
+    input.write(`${JSON.stringify({ command: "chat", text })}
 `);
   };
-  const startNextWake = () => {
-    if (!wakeTarget || wakeChild || wakeQueue.length === 0 || stopped) return;
-    const prompt = agentWakePrompt(sessionId, wakeQueue.shift());
+  let startNextWake = () => void 0;
+  const finishWake = (id, error, failureReply) => {
+    const wake = activeWake;
+    if (!wake || wake.id !== id) return;
+    clearTimeout(wake.timer);
+    activeWake = null;
+    if (error && !wake.replied) {
+      wakeState = "failed";
+      lastWakeError = error;
+      if (!stopped) sendWakeFailure(failureReply);
+    } else {
+      wakeState = "idle";
+      lastWakeError = null;
+    }
+    startNextWake();
+  };
+  startNextWake = () => {
+    if (!wakeTarget || wakeChild || activeWake || wakeQueue.length === 0 || stopped) return;
+    const text = wakeQueue.shift();
+    const id = randomId("wake");
+    const startedAt = Date.now();
+    wakeId = id;
+    wakeStartedAt = startedAt;
+    wakeState = "active";
+    lastWakeError = null;
+    const timer = setTimeout(() => {
+      const wake = activeWake;
+      if (!wake || wake.id !== id) return;
+      wake.timedOut = true;
+      if (wakeTarget.provider === "codex") {
+        const interrupted = codexWakeHost ? codexWakeHost.interrupt() : Promise.resolve();
+        void interrupted.finally(() => {
+          finishWake(id, "turn_timed_out", "The bridge stayed connected, but this document task timed out. Send the task again.");
+        });
+      } else {
+        wakeChild?.kill();
+      }
+    }, wakeTimeoutMs);
+    timer.unref();
+    activeWake = { id, startedAt, replied: false, timedOut: false, timer };
+    const prompt = agentWakePrompt(sessionId, id, text);
+    if (wakeTarget.provider === "codex") {
+      if (!codexWakeHost) {
+        finishWake(id, "wake_host_unavailable", "The bridge stayed connected, but this document task could not start. Send the task again.");
+        return;
+      }
+      void codexWakeHost.startTurn(prompt).then(
+        () => {
+          const replied = activeWake?.id === id && activeWake.replied;
+          finishWake(
+            id,
+            replied ? null : "turn_completed_without_chat",
+            "The bridge stayed connected, but this document task ended before the agent sent a reply. Send the task again."
+          );
+        },
+        () => {
+          const timedOut = activeWake?.id === id && activeWake.timedOut;
+          finishWake(
+            id,
+            timedOut ? "turn_timed_out" : "turn_failed",
+            timedOut ? "The bridge stayed connected, but this document task timed out. Send the task again." : "The bridge stayed connected, but this document task failed. Send the task again."
+          );
+        }
+      );
+      return;
+    }
     const childEnv = { ...process.env };
     delete childEnv.CODEX_THREAD_ID;
     delete childEnv.CLAUDE_CODE_SESSION_ID;
     delete childEnv.CLAUDECODE;
-    wakeChild = wakeTarget.provider === "codex" ? spawn("codex", ["exec", "resume", wakeTarget.sessionId, "-"], { env: childEnv, stdio: ["pipe", "ignore", "ignore"] }) : spawn("claude", ["-p", "--resume", wakeTarget.sessionId], { env: childEnv, stdio: ["pipe", "ignore", "ignore"] });
+    wakeChild = spawn("claude", ["-p", "--resume", wakeTarget.sessionId], { env: childEnv, stdio: ["pipe", "ignore", "ignore"] });
     let finished = false;
     const finish = (ok) => {
       if (finished) return;
       finished = true;
       wakeChild = null;
-      if (!ok && !stopped) sendWakeFailure();
-      startNextWake();
+      const wake = activeWake?.id === id ? activeWake : null;
+      const error = wake?.timedOut ? "turn_timed_out" : ok && wake?.replied ? null : "turn_failed";
+      finishWake(
+        id,
+        error,
+        wake?.timedOut ? "The bridge stayed connected, but this document task timed out. Send the task again." : "The bridge stayed connected, but this document task failed. Send the task again."
+      );
     };
     wakeChild.once("error", () => finish(false));
     wakeChild.once("exit", (code) => finish(code === 0));
     wakeChild.stdin?.on("error", () => void 0);
     wakeChild.stdin?.end(prompt);
   };
+  let serverListening = false;
   const shutdown = () => {
-    if (stopped) return;
+    if (shutdownPromise) return shutdownPromise;
     stopped = true;
     if (closeTimer) clearTimeout(closeTimer);
+    if (activeWake) clearTimeout(activeWake.timer);
+    activeWake = null;
     wakeChild?.kill();
+    const host = codexWakeHost;
+    codexWakeHost = null;
     input.end();
-    server.close();
-    if (process.platform !== "win32") rmSync(path, { force: true });
+    shutdownPromise = Promise.all([
+      host?.close() ?? Promise.resolve(),
+      serverListening ? new Promise((resolve) => server.close(() => resolve())) : Promise.resolve()
+    ]).then(() => {
+      rmSync(directory, { recursive: true, force: true });
+    });
+    return shutdownPromise;
   };
   const emit = (value) => {
     const message = value;
     if (message.event === "ready") readyEvent = message;
     if (message.event === "connection_closed" && !closeTimer) {
-      closeTimer = setTimeout(shutdown, 6e4);
+      closeTimer = setTimeout(() => {
+        void shutdown();
+      }, 6e4);
       closeTimer.unref();
     }
     if (message.event === "chat" && typeof message.text === "string" && wakeTarget) {
@@ -421,6 +690,10 @@ async function runDaemon(invitationUrl, sessionId) {
     const command = pending.get(message.id);
     if (!command) return;
     pending.delete(message.id);
+    if (message.ok === true && command.command === "chat" && command.wakeId && activeWake?.id === command.wakeId) {
+      activeWake.replied = true;
+      lastSuccessfulChatAt = Date.now();
+    }
     const response = { ...message };
     if (command.originalId === void 0) delete response.id;
     else response.id = command.originalId;
@@ -438,16 +711,35 @@ async function runDaemon(invitationUrl, sessionId) {
         const message = JSON.parse(buffer.slice(0, newline));
         if (message.daemon === "status") {
           if (fatalError) sendSocketValue(socket, { ok: false, error: fatalError });
-          else if (readyEvent) sendSocketValue(socket, { ok: true, result: { state: "ready", ready: readyEvent } });
-          else sendSocketValue(socket, { ok: true, result: { state: "starting" } });
+          else sendSocketValue(socket, {
+            ok: true,
+            result: {
+              state: readyEvent ? "ready" : "starting",
+              ready: readyEvent,
+              wakeState,
+              wakeId,
+              wakeStartedAt,
+              lastWakeError,
+              lastSuccessfulChatAt
+            }
+          });
           return;
         }
         if (!readyEvent) {
           sendSocketValue(socket, { ok: false, error: fatalError ?? "The agent bridge is still starting" });
           return;
         }
+        if (message.command === "chat" && activeWake && message.wakeId !== activeWake.id) {
+          sendSocketValue(socket, { ok: false, error: "The chat command must include the current wakeId" });
+          return;
+        }
         const id = `request_${++requestCounter}`;
-        pending.set(id, { socket, originalId: message.id });
+        pending.set(id, {
+          socket,
+          originalId: message.id,
+          command: typeof message.command === "string" ? message.command : void 0,
+          wakeId: typeof message.wakeId === "string" ? message.wakeId : void 0
+        });
         input.write(`${JSON.stringify({ ...message, id })}
 `);
       } catch (error) {
@@ -455,8 +747,10 @@ async function runDaemon(invitationUrl, sessionId) {
       }
     });
   });
-  await listen(server, path);
   try {
+    await listen(server, path);
+    serverListening = true;
+    if (wakeTarget?.provider === "codex") codexWakeHost = await startCodexWakeHost(sessionId);
     await connectAgent(invitationUrl, input, emit);
   } catch (error) {
     fatalError = error instanceof Error ? error.message : String(error);
@@ -464,7 +758,7 @@ async function runDaemon(invitationUrl, sessionId) {
     pending.clear();
     await new Promise((resolve) => setTimeout(resolve, 1e3));
   } finally {
-    shutdown();
+    await shutdown();
   }
 }
 function daemonRequest(sessionId, request, timeoutMs = 6e4) {
@@ -519,7 +813,7 @@ async function startDaemon(invitationUrl) {
       }
     } catch (error) {
       const code = error.code;
-      if (code !== "ENOENT" && code !== "ECONNREFUSED") throw error;
+      if (code !== "ENOENT" && code !== "ECONNREFUSED" && code !== "EINVAL") throw error;
     }
     await new Promise((resolve) => setTimeout(resolve, 100));
   }