copilotoffice 1.1.1 → 2.1.0

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

@@ -34,11 +34,131 @@ __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). */
@@ -54,9 +174,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 +200,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 +252,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,7 +291,33 @@ 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") {
@@ -189,6 +343,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 +376,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 +391,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);
@@ -246,6 +423,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

@@ -17,6 +17,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var preload_exports = {};
 module.exports = __toCommonJS(preload_exports);
 var import_electron = require("electron");
+import_electron.contextBridge.exposeInMainWorld("__copilotOfficeE2E", process.env.COPILOT_E2E === "1");
 import_electron.contextBridge.exposeInMainWorld("copilotBridge", {
   // Terminal management
   terminalStart: (officeId, agentId, workingDir, cols, rows, preseededPrompt, launchMode) => {
@@ -31,6 +32,14 @@ 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);
   },
@@ -148,5 +157,41 @@ import_electron.contextBridge.exposeInMainWorld("copilotBridge", {
   // Native OS notifications
   showNativeNotification: (title, body) => {
     return import_electron.ipcRenderer.invoke("show-native-notification", title, body);
+  },
+  // 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.
+  clipboardWriteText: (text) => {
+    return import_electron.ipcRenderer.invoke("clipboard-write-text", text);
+  },
+  // Spec 004: read OS clipboard via Electron main. Renderer pairs this with
+  // 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));
   }
 });