copilotoffice 2.1.0 → 2.3.0

package/dist/electron/terminal/events-watcher.js

@@ -31,7 +31,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var events_watcher_exports = {};
 __export(events_watcher_exports, {
   EventsWatcher: () => EventsWatcher,
-  formatToolStatus: () => formatToolStatus
+  buildAskUserRelay: () => buildAskUserRelay,
+  formatToolStatus: () => formatToolStatus,
+  normalizeAskUserArgs: () => normalizeAskUserArgs
 });
 module.exports = __toCommonJS(events_watcher_exports);
 var fs = __toESM(require("fs"));
@@ -223,8 +225,57 @@ function formatToolStatus(toolName, args) {
       return `Using ${toolName}`;
   }
 }
+function normalizeAskUserArgs(args) {
+  const a = args ?? {};
+  const questionRaw = a.question ?? a.prompt ?? a.message ?? a.text ?? "";
+  const question = typeof questionRaw === "string" ? questionRaw : String(questionRaw ?? "");
+  const rawOptions = a.options ?? a.choices ?? a.answers ?? a.selections ?? [];
+  const options = [];
+  if (Array.isArray(rawOptions)) {
+    for (const opt of rawOptions) {
+      if (typeof opt === "string") {
+        options.push({ text: opt });
+      } else if (opt && typeof opt === "object") {
+        const o = opt;
+        const text = o.text ?? o.label ?? o.value ?? o.name ?? "";
+        options.push({ text: typeof text === "string" ? text : String(text ?? "") });
+      }
+    }
+  }
+  const freeformRaw = a.freeform ?? a.allowFreeform ?? a.allowFreeText ?? a.allowCustom ?? a.freeText ?? false;
+  const freeform = Boolean(freeformRaw);
+  return { question, options, freeform };
+}
+function buildAskUserRelay(event, backendName) {
+  const d = event.data ?? {};
+  if (event.type === "user_input.requested") {
+    const options = Array.isArray(d.choices) ? d.choices.map((c) => ({
+      text: typeof c === "string" ? c : String(c?.text ?? c?.label ?? c?.value ?? "")
+    })) : [];
+    return {
+      toolId: String(d.toolCallId ?? ""),
+      requestId: String(d.requestId ?? ""),
+      question: String(d.question ?? ""),
+      options,
+      freeform: Boolean(d.allowFreeform)
+    };
+  }
+  if (event.type === "tool.execution_start" && d.toolName === "ask_user" && backendName === "node-pty") {
+    const norm = normalizeAskUserArgs(d.arguments);
+    return {
+      toolId: String(d.toolCallId ?? ""),
+      requestId: "",
+      question: norm.question,
+      options: norm.options,
+      freeform: norm.freeform
+    };
+  }
+  return null;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   EventsWatcher,
-  formatToolStatus
+  buildAskUserRelay,
+  formatToolStatus,
+  normalizeAskUserArgs
 });

package/dist/electron/terminal/ipc-relay.js

@@ -156,7 +156,9 @@ var TerminalRelay = class _TerminalRelay {
      * server→main copilot/terminal events without going through the renderer.
      * Emits: 'copilot-event' (agentId, event), 'copilot-turn-start' (agentId),
      * 'copilot-turn-end' (agentId), 'copilot-tool-start' (agentId, toolName, toolId, status),
+     * 'copilot-ask-user' (agentId, toolId, requestId, question, options, freeform),
      * 'session-meta-updated' (agentId, meta), 'terminal-exit' (agentId, exitCode).
+     * Accepts (via mainSubmitAnswer): 'submit-answer' (officeId, agentId, requestId?, answer, wasFreeform).
      */
     this.mainEvents = new import_events.EventEmitter();
     this.server = null;
@@ -165,6 +167,8 @@ var TerminalRelay = class _TerminalRelay {
     this.shuttingDown = false;
     /** Requests that arrived while the server was not connected. Flushed on ready. */
     this.queuedRequests = [];
+    /** Latest backend-selection outcome reported by the server on 'ready'. */
+    this.backendInfo = null;
     this.getWindow = getWindow;
   }
   static {
@@ -315,6 +319,22 @@ var TerminalRelay = class _TerminalRelay {
   mainSubmitPrompt(officeId, agentId, prompt, label) {
     return this.request({ type: "submit-prompt", requestId: this.id(), officeId, agentId, prompt, label });
   }
+  /**
+   * spec 015: answer a pending `ask_user` interaction. Distinct from
+   * mainSubmitPrompt — resolves the pending user-input interaction (SDK/ui-server)
+   * or injects keystrokes (node-pty). `requestId` is the single-resolution key.
+   */
+  mainSubmitAnswer(officeId, agentId, a) {
+    return this.request({
+      type: "submit-answer",
+      requestId: this.id(),
+      officeId,
+      agentId,
+      answerRequestId: a.requestId,
+      answer: a.answer,
+      wasFreeform: a.wasFreeform
+    });
+  }
   /** Fire-and-forget: control whether copilot-events are mirrored to main for an agent without a viewer. */
   mainSetAgentForwarding(officeId, agentId, enabled) {
     this.send({ type: "set-agent-forwarding", officeId, agentId, enabled });
@@ -324,6 +344,15 @@ var TerminalRelay = class _TerminalRelay {
       clearTimeout(readyTimeout);
       this.shuttingDown = false;
       console.log("[Relay] Terminal server ready");
+      if (msg.backend) {
+        this.backendInfo = msg.backend;
+        if (msg.backend.fellBack) {
+          const win2 = this.getWindow();
+          if (win2 && !win2.isDestroyed()) {
+            win2.webContents.send("backend-fallback", this.backendInfo);
+          }
+        }
+      }
       if (this.queuedRequests.length > 0) {
         console.log(`[Relay] Flushing ${this.queuedRequests.length} queued request(s)`);
         for (const queued of this.queuedRequests) {
@@ -359,6 +388,12 @@ var TerminalRelay = class _TerminalRelay {
       case "copilot-tool-start":
         this.mainEvents.emit("copilot-tool-start", msg.agentId, msg.toolName, msg.toolId, msg.status);
         break;
+      case "copilot-ask-user":
+        this.mainEvents.emit("copilot-ask-user", msg.agentId, msg.toolId, msg.requestId, msg.question, msg.options, msg.freeform);
+        break;
+      case "copilot-ask-user-complete":
+        this.mainEvents.emit("copilot-ask-user-complete", msg.agentId, msg.requestId);
+        break;
       case "session-meta-updated":
         this.mainEvents.emit("session-meta-updated", msg.agentId, msg.meta);
         break;
@@ -381,6 +416,12 @@ var TerminalRelay = class _TerminalRelay {
       case "copilot-tool-start":
         win.webContents.send("copilot-tool-start", msg.agentId, msg.toolName, msg.toolId, msg.status);
         break;
+      case "copilot-ask-user":
+        win.webContents.send("copilot-ask-user", msg.agentId, msg.toolId, msg.requestId, msg.question, msg.options, msg.freeform);
+        break;
+      case "copilot-ask-user-complete":
+        win.webContents.send("copilot-ask-user-complete", msg.agentId, msg.requestId);
+        break;
       case "copilot-tool-complete":
         win.webContents.send("copilot-tool-complete", msg.agentId, msg.toolId, msg.success);
         break;
@@ -399,17 +440,24 @@ var TerminalRelay = class _TerminalRelay {
       case "terminal-preload-status":
         win.webContents.send("terminal-preload-status", msg.agentId, msg.status);
         break;
+      case "backend-online":
+        win.webContents.send("backend-online", msg.officeId, msg.backend);
+        break;
+      case "backend-session-fallback":
+        win.webContents.send("backend-session-fallback", msg.officeId, msg.agentId, msg.reason);
+        break;
     }
   }
   // ── IPC Handler Registration ──────────────────────────────────
   registerIpc() {
+    import_electron.ipcMain.handle("terminal-backend-info", () => this.backendInfo);
     import_electron.ipcMain.handle(
       "terminal-start",
       (_event, officeId, agentId, workingDir, cols, rows, preseededPrompt, launchMode) => this.request({ type: "start", requestId: this.id(), officeId, agentId, workingDir, cols, rows, preseededPrompt, launchMode })
     );
     import_electron.ipcMain.handle(
       "terminal-attach",
-      (_event, officeId, agentId) => this.request({ type: "attach", requestId: this.id(), officeId, agentId })
+      (_event, officeId, agentId, foreground) => this.request({ type: "attach", requestId: this.id(), officeId, agentId, foreground })
     );
     import_electron.ipcMain.handle("terminal-detach", (_event, officeId, agentId) => {
       this.send({ type: "detach", officeId, agentId });

package/dist/electron/terminal/preload.js

@@ -43,8 +43,8 @@ import_electron.contextBridge.exposeInMainWorld("copilotBridge", {
   terminalExists: (officeId, agentId) => {
     return import_electron.ipcRenderer.invoke("terminal-exists", officeId, agentId);
   },
-  terminalAttach: (officeId, agentId) => {
-    return import_electron.ipcRenderer.invoke("terminal-attach", officeId, agentId);
+  terminalAttach: (officeId, agentId, foreground) => {
+    return import_electron.ipcRenderer.invoke("terminal-attach", officeId, agentId, foreground);
   },
   terminalDetach: (officeId, agentId) => {
     return import_electron.ipcRenderer.invoke("terminal-detach", officeId, agentId);
@@ -105,37 +105,67 @@ import_electron.contextBridge.exposeInMainWorld("copilotBridge", {
   loadOffices: () => {
     return import_electron.ipcRenderer.invoke("load-offices");
   },
-  // Terminal event listeners
+  // Terminal event listeners. Each returns an unsubscribe function that removes
+  // ONLY this registration (not every listener on the channel), so a controller
+  // can dispose its own listener before re-registering. This prevents duplicate
+  // registrations from writing the same PTY byte to xterm more than once (the
+  // classic "double characters" bug). Callers may ignore the return value.
   onTerminalData: (callback) => {
-    import_electron.ipcRenderer.on("terminal-data", (_event, agentId, data) => callback(agentId, data));
+    const handler = (_event, agentId, data) => callback(agentId, data);
+    import_electron.ipcRenderer.on("terminal-data", handler);
+    return () => import_electron.ipcRenderer.removeListener("terminal-data", handler);
   },
   onTerminalExit: (callback) => {
-    import_electron.ipcRenderer.on("terminal-exit", (_event, agentId, exitCode) => callback(agentId, exitCode));
+    const handler = (_event, agentId, exitCode) => callback(agentId, exitCode);
+    import_electron.ipcRenderer.on("terminal-exit", handler);
+    return () => import_electron.ipcRenderer.removeListener("terminal-exit", handler);
   },
   onTerminalPreloadStatus: (callback) => {
-    import_electron.ipcRenderer.on("terminal-preload-status", (_event, agentId, status) => callback(agentId, status));
+    const handler = (_event, agentId, status) => callback(agentId, status);
+    import_electron.ipcRenderer.on("terminal-preload-status", handler);
+    return () => import_electron.ipcRenderer.removeListener("terminal-preload-status", handler);
   },
   // Copilot activity event listeners
   onCopilotEvent: (callback) => {
-    import_electron.ipcRenderer.on("copilot-event", (_event, agentId, copilotEvent) => callback(agentId, copilotEvent));
+    const handler = (_event, agentId, copilotEvent) => callback(agentId, copilotEvent);
+    import_electron.ipcRenderer.on("copilot-event", handler);
+    return () => import_electron.ipcRenderer.removeListener("copilot-event", handler);
   },
   onCopilotToolStart: (callback) => {
-    import_electron.ipcRenderer.on("copilot-tool-start", (_event, agentId, toolName, toolId, status) => callback(agentId, toolName, toolId, status));
+    const handler = (_event, agentId, toolName, toolId, status) => callback(agentId, toolName, toolId, status);
+    import_electron.ipcRenderer.on("copilot-tool-start", handler);
+    return () => import_electron.ipcRenderer.removeListener("copilot-tool-start", handler);
+  },
+  // spec 015: additive ask_user relay (renderer parity — no Phaser consumer required).
+  onCopilotAskUser: (callback) => {
+    const handler = (_event, agentId, toolId, requestId, question, options, freeform) => callback(agentId, toolId, requestId, question, options, freeform);
+    import_electron.ipcRenderer.on("copilot-ask-user", handler);
+    return () => import_electron.ipcRenderer.removeListener("copilot-ask-user", handler);
   },
   onCopilotToolComplete: (callback) => {
-    import_electron.ipcRenderer.on("copilot-tool-complete", (_event, agentId, toolId, success) => callback(agentId, toolId, success));
+    const handler = (_event, agentId, toolId, success) => callback(agentId, toolId, success);
+    import_electron.ipcRenderer.on("copilot-tool-complete", handler);
+    return () => import_electron.ipcRenderer.removeListener("copilot-tool-complete", handler);
   },
   onCopilotTurnEnd: (callback) => {
-    import_electron.ipcRenderer.on("copilot-turn-end", (_event, agentId) => callback(agentId));
+    const handler = (_event, agentId) => callback(agentId);
+    import_electron.ipcRenderer.on("copilot-turn-end", handler);
+    return () => import_electron.ipcRenderer.removeListener("copilot-turn-end", handler);
   },
   onCopilotTurnStart: (callback) => {
-    import_electron.ipcRenderer.on("copilot-turn-start", (_event, agentId) => callback(agentId));
+    const handler = (_event, agentId) => callback(agentId);
+    import_electron.ipcRenderer.on("copilot-turn-start", handler);
+    return () => import_electron.ipcRenderer.removeListener("copilot-turn-start", handler);
   },
   onCopilotUserMessage: (callback) => {
-    import_electron.ipcRenderer.on("copilot-user-message", (_event, agentId) => callback(agentId));
+    const handler = (_event, agentId) => callback(agentId);
+    import_electron.ipcRenderer.on("copilot-user-message", handler);
+    return () => import_electron.ipcRenderer.removeListener("copilot-user-message", handler);
   },
   onSessionMetaUpdated: (callback) => {
-    import_electron.ipcRenderer.on("session-meta-updated", (_event, agentId, meta) => callback(agentId, meta));
+    const handler = (_event, agentId, meta) => callback(agentId, meta);
+    import_electron.ipcRenderer.on("session-meta-updated", handler);
+    return () => import_electron.ipcRenderer.removeListener("session-meta-updated", handler);
   },
   removeTerminalListeners: () => {
     import_electron.ipcRenderer.removeAllListeners("terminal-data");
@@ -144,6 +174,7 @@ import_electron.contextBridge.exposeInMainWorld("copilotBridge", {
   removeCopilotListeners: () => {
     import_electron.ipcRenderer.removeAllListeners("copilot-event");
     import_electron.ipcRenderer.removeAllListeners("copilot-tool-start");
+    import_electron.ipcRenderer.removeAllListeners("copilot-ask-user");
     import_electron.ipcRenderer.removeAllListeners("copilot-tool-complete");
     import_electron.ipcRenderer.removeAllListeners("copilot-turn-end");
     import_electron.ipcRenderer.removeAllListeners("copilot-turn-start");
@@ -158,6 +189,19 @@ import_electron.contextBridge.exposeInMainWorld("copilotBridge", {
   showNativeNotification: (title, body) => {
     return import_electron.ipcRenderer.invoke("show-native-notification", title, body);
   },
+  // Terminal backend selection (ui-server / node-pty / sdk).
+  getBackendInfo: () => {
+    return import_electron.ipcRenderer.invoke("terminal-backend-info");
+  },
+  onBackendFallback: (callback) => {
+    import_electron.ipcRenderer.on("backend-fallback", (_event, info) => callback(info));
+  },
+  onBackendOnline: (callback) => {
+    import_electron.ipcRenderer.on("backend-online", (_event, officeId, backend) => callback(officeId, backend));
+  },
+  onBackendSessionFallback: (callback) => {
+    import_electron.ipcRenderer.on("backend-session-fallback", (_event, officeId, agentId, reason) => callback(officeId, agentId, reason));
+  },
   // Spec 003 follow-up: write to OS clipboard via Electron main process.
   // Bypasses Permissions API + focus restrictions that make
   // navigator.clipboard.writeText unreliable in xterm-focused contexts.