copilotoffice 2.0.0 → 2.2.0

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

@@ -34,17 +34,139 @@ __export(ipc_relay_exports, {
 });
 module.exports = __toCommonJS(ipc_relay_exports);
 var import_electron = require("electron");
+var import_child_process2 = require("child_process");
+var import_events = require("events");
+var crypto2 = __toESM(require("crypto"));
+var path2 = __toESM(require("path"));
+
+// electron/terminal/pty-registry.ts
 var import_child_process = require("child_process");
 var crypto = __toESM(require("crypto"));
+var fs = __toESM(require("fs"));
+var os = __toESM(require("os"));
 var path = __toESM(require("path"));
+var START_TIME_GRACE_MS = 2e3;
+var DEFAULT_REGISTRY_FILE = path.join(process.cwd(), ".data", "pty-pids.json");
+function readPtyRegistry(file = DEFAULT_REGISTRY_FILE) {
+  try {
+    const raw = fs.readFileSync(file, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter(
+      (r) => !!r && typeof r.pid === "number" && Number.isFinite(r.pid)
+    );
+  } catch {
+    return [];
+  }
+}
+function writePtyRegistry(records, file = DEFAULT_REGISTRY_FILE) {
+  try {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const tmp = `${file}.${process.pid}.${crypto.randomBytes(4).toString("hex")}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(records, null, 2));
+    fs.renameSync(tmp, file);
+  } catch {
+  }
+}
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err?.code === "EPERM";
+  }
+}
+function processStartTimeMs(pid) {
+  try {
+    if (os.platform() === "win32") {
+      const cmd = `powershell -NoProfile -NonInteractive -Command "$p = Get-CimInstance Win32_Process -Filter 'ProcessId=${pid}'; if ($p) { [DateTimeOffset]::new($p.CreationDate).ToUnixTimeMilliseconds() }"`;
+      const out2 = (0, import_child_process.execSync)(cmd, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+      const ms2 = parseInt(out2, 10);
+      return Number.isFinite(ms2) ? ms2 : null;
+    }
+    const out = (0, import_child_process.execSync)(`ps -o lstart= -p ${pid}`, {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    if (!out) return null;
+    const ms = Date.parse(out);
+    return Number.isNaN(ms) ? null : ms;
+  } catch {
+    return null;
+  }
+}
+function processIdentityMatches(record, startTimeOf) {
+  const startMs = startTimeOf(record.pid);
+  if (startMs == null) return false;
+  return startMs <= record.startedAt + START_TIME_GRACE_MS;
+}
+function killTree(pid) {
+  try {
+    if (os.platform() === "win32") {
+      (0, import_child_process.execSync)(`taskkill /T /F /PID ${pid}`, { stdio: "ignore" });
+    } else {
+      try {
+        process.kill(-pid, "SIGKILL");
+      } catch {
+        process.kill(pid, "SIGKILL");
+      }
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+function reapRegisteredPtys(options = {}) {
+  const file = options.file ?? DEFAULT_REGISTRY_FILE;
+  const isAlive = options.isAlive ?? isPidAlive;
+  const kill = options.kill ?? killTree;
+  const startTimeOf = options.startTimeOf ?? processStartTimeMs;
+  const protectedPids = /* @__PURE__ */ new Set([process.pid, ...options.protectedPids ?? []]);
+  const records = readPtyRegistry(file);
+  const reaped = [];
+  const skipped = [];
+  const failed = [];
+  const survivors = [];
+  for (const record of records) {
+    const { pid } = record;
+    if (protectedPids.has(pid) || !isAlive(pid)) {
+      skipped.push(pid);
+      continue;
+    }
+    if (!processIdentityMatches(record, startTimeOf)) {
+      skipped.push(pid);
+      continue;
+    }
+    if (kill(pid)) {
+      reaped.push(pid);
+    } else {
+      failed.push(pid);
+      survivors.push(record);
+    }
+  }
+  writePtyRegistry(survivors, file);
+  return { reaped, skipped, failed };
+}
+
+// electron/terminal/ipc-relay.ts
 var TerminalRelay = class _TerminalRelay {
   constructor(getWindow) {
+    /**
+     * Event bus for main-process consumers (e.g. the Teams service) that need
+     * 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),
+     * 'session-meta-updated' (agentId, meta), 'terminal-exit' (agentId, exitCode).
+     */
+    this.mainEvents = new import_events.EventEmitter();
     this.server = null;
     this.pendingRequests = /* @__PURE__ */ new Map();
     /** True while a deliberate shutdown→respawn is in progress (prevents double-spawn). */
     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 {
@@ -54,9 +176,9 @@ var TerminalRelay = class _TerminalRelay {
   // ── Server Lifecycle ──────────────────────────────────────────
   spawnServer(distDir) {
     return new Promise((resolve, reject) => {
-      const serverPath = path.join(distDir, "terminal", "server.js");
+      const serverPath = path2.join(distDir, "terminal", "server.js");
       console.log("[Relay] Forking terminal server:", serverPath);
-      this.server = (0, import_child_process.fork)(serverPath, [], {
+      this.server = (0, import_child_process2.fork)(serverPath, [], {
         cwd: process.cwd(),
         stdio: ["pipe", "inherit", "inherit", "ipc"]
       });
@@ -80,6 +202,14 @@ var TerminalRelay = class _TerminalRelay {
         }
         const win = this.getWindow();
         if (win && !win.isDestroyed()) {
+          try {
+            const { reaped } = reapRegisteredPtys();
+            if (reaped.length > 0) {
+              console.log(`[Relay] Reaped ${reaped.length} orphaned PTY tree(s) from crashed server:`, reaped);
+            }
+          } catch (e) {
+            console.error("[Relay] Failed to reap orphaned PTYs after crash:", e);
+          }
           console.log("[Relay] Respawning terminal server...");
           this.spawnServer(distDir).catch(
             (e) => console.error("[Relay] Failed to respawn:", e)
@@ -124,7 +254,7 @@ var TerminalRelay = class _TerminalRelay {
             process.kill(oldPid, 0);
             console.log(`[Relay] Server PID ${oldPid} still alive after timeout \u2014 force killing`);
             if (process.platform === "win32") {
-              (0, import_child_process.execSync)(`taskkill /T /F /PID ${oldPid}`, { stdio: "ignore" });
+              (0, import_child_process2.execSync)(`taskkill /T /F /PID ${oldPid}`, { stdio: "ignore" });
             } else {
               process.kill(oldPid, "SIGKILL");
             }
@@ -163,13 +293,48 @@ var TerminalRelay = class _TerminalRelay {
     });
   }
   id() {
-    return crypto.randomUUID();
+    return crypto2.randomUUID();
+  }
+  // ── Main-process gateway (for the Teams service) ──────────────
+  // These let a main-process consumer talk to the terminal server directly,
+  // reusing the same request/response plumbing as the renderer IPC handlers.
+  mainGetSessionId(officeId, agentId) {
+    return this.request({ type: "get-session-id", requestId: this.id(), officeId, agentId });
+  }
+  /** True only when the agent's PTY is alive AND the CLI has signalled ready. */
+  mainIsAgentReady(officeId, agentId) {
+    return this.request({ type: "query-agent-statuses", requestId: this.id(), officeId }).then((statuses) => {
+      const s = statuses?.[agentId];
+      return !!(s && s.alive && s.ready);
+    });
+  }
+  mainGetSessionMeta(officeId, agentId) {
+    return this.request({ type: "get-session-meta", requestId: this.id(), officeId, agentId });
+  }
+  mainWrite(officeId, agentId, data) {
+    return this.request({ type: "write", requestId: this.id(), officeId, agentId, data });
+  }
+  mainSubmitPrompt(officeId, agentId, prompt, label) {
+    return this.request({ type: "submit-prompt", requestId: this.id(), officeId, agentId, prompt, label });
+  }
+  /** 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 });
   }
   handleServerMessage(msg, readyTimeout, onReady) {
     if (msg.type === "ready") {
       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) {
@@ -189,6 +354,29 @@ var TerminalRelay = class _TerminalRelay {
       }
       return;
     }
+    switch (msg.type) {
+      case "copilot-event":
+        this.mainEvents.emit("copilot-event", msg.agentId, msg.event);
+        break;
+      case "copilot-turn-start":
+        this.mainEvents.emit("copilot-turn-start", msg.agentId);
+        break;
+      case "copilot-turn-end":
+        this.mainEvents.emit("copilot-turn-end", msg.agentId);
+        break;
+      case "copilot-user-message":
+        this.mainEvents.emit("copilot-user-message", msg.agentId, msg.text);
+        break;
+      case "copilot-tool-start":
+        this.mainEvents.emit("copilot-tool-start", msg.agentId, msg.toolName, msg.toolId, msg.status);
+        break;
+      case "session-meta-updated":
+        this.mainEvents.emit("session-meta-updated", msg.agentId, msg.meta);
+        break;
+      case "terminal-exit":
+        this.mainEvents.emit("terminal-exit", msg.agentId, msg.exitCode);
+        break;
+    }
     const win = this.getWindow();
     if (!win || win.isDestroyed()) return;
     switch (msg.type) {
@@ -199,7 +387,7 @@ var TerminalRelay = class _TerminalRelay {
         win.webContents.send("terminal-exit", msg.agentId, msg.exitCode);
         break;
       case "copilot-event":
-        win.webContents.send("copilot-event", msg.agentId, msg.event);
+        if (!msg.mainOnly) win.webContents.send("copilot-event", msg.agentId, msg.event);
         break;
       case "copilot-tool-start":
         win.webContents.send("copilot-tool-start", msg.agentId, msg.toolName, msg.toolId, msg.status);
@@ -214,7 +402,7 @@ var TerminalRelay = class _TerminalRelay {
         win.webContents.send("copilot-turn-start", msg.agentId);
         break;
       case "copilot-user-message":
-        win.webContents.send("copilot-user-message", msg.agentId);
+        win.webContents.send("copilot-user-message", msg.agentId, msg.text);
         break;
       case "session-meta-updated":
         win.webContents.send("session-meta-updated", msg.agentId, msg.meta);
@@ -222,17 +410,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 });
@@ -246,6 +441,14 @@ var TerminalRelay = class _TerminalRelay {
       this.send({ type: "resize", officeId, agentId, cols, rows });
       return { success: true };
     });
+    import_electron.ipcMain.handle("set-yolo", (_event, enabled) => {
+      this.send({ type: "set-yolo", enabled: !!enabled });
+      return { success: true };
+    });
+    import_electron.ipcMain.handle("set-additional-params", (_event, params) => {
+      this.send({ type: "set-additional-params", params: String(params ?? "") });
+      return { success: true };
+    });
     import_electron.ipcMain.handle(
       "terminal-kill",
       (_event, officeId, agentId) => this.request({ type: "kill", requestId: this.id(), officeId, agentId })

package/dist/electron/terminal/preload.js

@@ -32,11 +32,19 @@ import_electron.contextBridge.exposeInMainWorld("copilotBridge", {
   terminalKill: (officeId, agentId) => {
     return import_electron.ipcRenderer.invoke("terminal-kill", officeId, agentId);
   },
+  // YOLO mode: push global flag to the PTY server so new copilot sessions launch with --yolo.
+  setYolo: (enabled) => {
+    return import_electron.ipcRenderer.invoke("set-yolo", enabled);
+  },
+  // Additional parameters: push the effective param string (empty = none) to the PTY server.
+  setAdditionalParams: (params) => {
+    return import_electron.ipcRenderer.invoke("set-additional-params", params);
+  },
   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);
@@ -97,37 +105,61 @@ 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);
   },
   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");
@@ -150,6 +182,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.
@@ -160,5 +205,30 @@ import_electron.contextBridge.exposeInMainWorld("copilotBridge", {
   // terminalWrite to implement Paste in the terminal context menu.
   clipboardReadText: () => {
     return import_electron.ipcRenderer.invoke("clipboard-read-text");
+  },
+  // ── Teams Remote Agents (011) ────────────────────────────────
+  teamsStatus: (args) => {
+    return import_electron.ipcRenderer.invoke("teams:status", args ?? {});
+  },
+  teamsRegister: (ctx) => {
+    return import_electron.ipcRenderer.invoke("teams:register", ctx);
+  },
+  teamsStop: (args) => {
+    return import_electron.ipcRenderer.invoke("teams:stop", args);
+  },
+  teamsReconcile: () => {
+    return import_electron.ipcRenderer.invoke("teams:reconcile");
+  },
+  teamsGetSettings: () => {
+    return import_electron.ipcRenderer.invoke("teams:getSettings");
+  },
+  teamsSaveSettings: (settings) => {
+    return import_electron.ipcRenderer.invoke("teams:saveSettings", { settings });
+  },
+  onTeamsStatusChanged: (callback) => {
+    import_electron.ipcRenderer.on("teams:status:changed", (_event, status) => callback(status));
+  },
+  onTeamsToast: (callback) => {
+    import_electron.ipcRenderer.on("teams:toast", (_event, toast) => callback(toast));
   }
 });