copilotoffice 1.1.1 → 2.0.0

package/dist/electron/main.js

@@ -23,9 +23,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // electron/main.ts
-var import_electron2 = require("electron");
-var path2 = __toESM(require("path"));
-var fs = __toESM(require("fs"));
+var import_electron3 = require("electron");
+var path3 = __toESM(require("path"));
+var fs2 = __toESM(require("fs"));
 var import_child_process2 = require("child_process");
 
 // electron/terminal/ipc-relay.ts
@@ -313,6 +313,96 @@ var TerminalRelay = class _TerminalRelay {
   }
 };
 
+// electron/officeFileStore.ts
+var fs = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+var DEFAULT_DATA_SUBDIR = ".data";
+var DEFAULT_FILE_NAME = "copilot-offices.json";
+function createOfficeFileStore(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const dataSubdir = options.dataSubdir ?? DEFAULT_DATA_SUBDIR;
+  const fileName = options.fileName ?? DEFAULT_FILE_NAME;
+  const dataDir = path2.join(cwd, dataSubdir);
+  const filePath = path2.join(dataDir, fileName);
+  return {
+    filePath,
+    load() {
+      try {
+        if (!fs.existsSync(filePath)) return { success: true, data: null };
+        const data = fs.readFileSync(filePath, "utf8");
+        return { success: true, data };
+      } catch (e) {
+        return { success: false, data: null, error: String(e) };
+      }
+    },
+    save(data) {
+      try {
+        fs.mkdirSync(dataDir, { recursive: true });
+        fs.writeFileSync(filePath, data, "utf8");
+        return { success: true };
+      } catch (e) {
+        return { success: false, error: String(e) };
+      }
+    }
+  };
+}
+
+// electron/nonTerminalIpc.ts
+var import_electron2 = require("electron");
+function registerNonTerminalIpc(hooks) {
+  import_electron2.ipcMain.handle("request-hard-reload", () => {
+    console.log("[Main] Hard reload requested by renderer");
+    hooks.onHardReloadRequested();
+    return { success: true };
+  });
+  import_electron2.ipcMain.handle("show-native-notification", (_event, title, body) => {
+    if (!import_electron2.Notification.isSupported()) return { success: false };
+    const notification = new import_electron2.Notification({ title, body });
+    notification.on("click", () => {
+      const win = hooks.getMainWindow();
+      if (win) {
+        if (win.isMinimized()) win.restore();
+        win.focus();
+      }
+    });
+    notification.show();
+    return { success: true };
+  });
+  import_electron2.ipcMain.handle("save-offices", (_event, data) => {
+    return hooks.officeStore.save(data);
+  });
+  import_electron2.ipcMain.handle("load-offices", () => {
+    return hooks.officeStore.load();
+  });
+  import_electron2.ipcMain.handle("clipboard-write-text", (_event, text) => {
+    try {
+      if (typeof text !== "string") {
+        return { success: false, verified: false, error: "text must be a string" };
+      }
+      import_electron2.clipboard.writeText(text);
+      const verify = import_electron2.clipboard.readText();
+      const matched = verify === text;
+      if (!matched) {
+        console.warn(`[Main/Clipboard] writeText verify mismatch len=${text.length}`);
+        return { success: false, verified: false, error: "clipboard verification failed" };
+      }
+      return { success: true, verified: true };
+    } catch (e) {
+      console.warn("[Main/Clipboard] writeText threw", e);
+      return { success: false, verified: false, error: e?.message || String(e) };
+    }
+  });
+  import_electron2.ipcMain.handle("clipboard-read-text", () => {
+    try {
+      const text = import_electron2.clipboard.readText();
+      return { success: true, text };
+    } catch (e) {
+      console.warn("[Main/Clipboard] readText threw", e);
+      return { success: false, text: "", error: e?.message || String(e) };
+    }
+  });
+}
+
 // electron/main.ts
 var OPEN_DEVTOOLS_ON_START = process.env.COPILOT_OFFICE_OPEN_DEVTOOLS !== "0";
 var ENABLE_FILE_WATCHER = process.env.COPILOT_OFFICE_ENABLE_WATCHER !== "0";
@@ -357,9 +447,9 @@ var watcherProcess = null;
 var relay = new TerminalRelay(() => mainWindow);
 var pendingHardReload = false;
 function startFileWatcher() {
-  const copilotOfficePath = path2.join(process.cwd(), "CopilotOffice");
-  if (!fs.existsSync(path2.join(copilotOfficePath, "package.json"))) {
-    if (fs.existsSync(path2.join(process.cwd(), "src", "main.ts"))) {
+  const copilotOfficePath = path3.join(process.cwd(), "CopilotOffice");
+  if (!fs2.existsSync(path3.join(copilotOfficePath, "package.json"))) {
+    if (fs2.existsSync(path3.join(process.cwd(), "src", "main.ts"))) {
       watcherProcess = (0, import_child_process2.spawn)("npx", ["esbuild", "src/main.ts", "--bundle", "--outfile=dist/game.bundle.js", "--platform=browser", "--format=iife", "--global-name=CopilotOffice", "--watch"], {
         cwd: process.cwd(),
         shell: true,
@@ -390,19 +480,19 @@ function startFileWatcher() {
   }
 }
 function createWindow() {
-  mainWindow = new import_electron2.BrowserWindow({
+  mainWindow = new import_electron3.BrowserWindow({
     width: 2560,
     height: 1440,
     title: "Copilot Office",
     webPreferences: {
-      preload: path2.join(__dirname, "terminal", "preload.js"),
+      preload: path3.join(__dirname, "terminal", "preload.js"),
       contextIsolation: true,
       nodeIntegration: false,
       backgroundThrottling: false
     }
   });
   mainWindow.maximize();
-  mainWindow.loadFile(path2.join(__dirname, "../../src/index.html"));
+  mainWindow.loadFile(path3.join(__dirname, "../../src/index.html"));
   if (OPEN_DEVTOOLS_ON_START) {
     mainWindow.webContents.openDevTools({ mode: "detach" });
   }
@@ -427,49 +517,17 @@ function createWindow() {
     mainWindow = null;
   });
 }
-import_electron2.app.whenReady().then(async () => {
-  import_electron2.Menu.setApplicationMenu(null);
+import_electron3.app.whenReady().then(async () => {
+  import_electron3.Menu.setApplicationMenu(null);
   killOrphanedProcesses();
   relay.registerIpc();
-  import_electron2.ipcMain.handle("request-hard-reload", () => {
-    console.log("[Main] Hard reload requested by renderer");
-    pendingHardReload = true;
-    return { success: true };
-  });
-  import_electron2.ipcMain.handle("show-native-notification", (_event, title, body) => {
-    if (!import_electron2.Notification.isSupported()) return { success: false };
-    const notification = new import_electron2.Notification({ title, body });
-    notification.on("click", () => {
-      if (mainWindow) {
-        if (mainWindow.isMinimized()) mainWindow.restore();
-        mainWindow.focus();
-      }
-    });
-    notification.show();
-    return { success: true };
-  });
-  const dataDir = path2.join(process.cwd(), ".data");
-  fs.mkdirSync(dataDir, { recursive: true });
-  const officesFilePath = path2.join(dataDir, "copilot-offices.json");
-  import_electron2.ipcMain.handle("save-offices", (_event, data) => {
-    try {
-      fs.mkdirSync(dataDir, { recursive: true });
-      fs.writeFileSync(officesFilePath, data, "utf8");
-      return { success: true };
-    } catch (e) {
-      console.warn("[Main] Failed to save offices:", e);
-      return { success: false, error: String(e) };
-    }
-  });
-  import_electron2.ipcMain.handle("load-offices", () => {
-    try {
-      if (!fs.existsSync(officesFilePath)) return { success: true, data: null };
-      const data = fs.readFileSync(officesFilePath, "utf8");
-      return { success: true, data };
-    } catch (e) {
-      console.warn("[Main] Failed to load offices:", e);
-      return { success: false, error: String(e), data: null };
-    }
+  const officeStore = createOfficeFileStore();
+  registerNonTerminalIpc({
+    getMainWindow: () => mainWindow,
+    onHardReloadRequested: () => {
+      pendingHardReload = true;
+    },
+    officeStore
   });
   await relay.spawnServer(__dirname);
   if (ENABLE_FILE_WATCHER) {
@@ -478,22 +536,22 @@ import_electron2.app.whenReady().then(async () => {
     console.log("[Main] File watcher disabled");
   }
   createWindow();
-  import_electron2.app.on("activate", () => {
-    if (import_electron2.BrowserWindow.getAllWindows().length === 0) createWindow();
+  import_electron3.app.on("activate", () => {
+    if (import_electron3.BrowserWindow.getAllWindows().length === 0) createWindow();
   });
 });
-import_electron2.app.on("window-all-closed", () => {
+import_electron3.app.on("window-all-closed", () => {
   if (watcherProcess) watcherProcess.kill();
-  if (process.platform !== "darwin") import_electron2.app.quit();
+  if (process.platform !== "darwin") import_electron3.app.quit();
 });
 var isShuttingDown = false;
-import_electron2.app.on("before-quit", (event) => {
+import_electron3.app.on("before-quit", (event) => {
   if (isShuttingDown) return;
   isShuttingDown = true;
   event.preventDefault();
   console.log("[Main] Awaiting relay shutdown before quit\u2026");
   relay.shutdown().finally(() => {
     console.log("[Main] Relay shutdown complete \u2014 quitting");
-    import_electron2.app.quit();
+    import_electron3.app.quit();
   });
 });

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) => {
@@ -148,5 +149,16 @@ 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");
   }
 });

package/dist/electron/terminal/server.js

@@ -5070,7 +5070,7 @@ var init_dist = __esm({
 var path3 = __toESM(require("path"));
 var os3 = __toESM(require("os"));
 var fs2 = __toESM(require("fs"));
-var crypto = __toESM(require("crypto"));
+var crypto2 = __toESM(require("crypto"));
 var import_child_process2 = require("child_process");
 
 // electron/terminal/events-watcher.ts
@@ -5595,10 +5595,66 @@ function createSdkCliLaunchConfig(cliPath) {
   return { cliPath, cliArgs: [] };
 }
 
+// electron/terminal/agent-viewers.ts
+function addAgentViewer(ck, maps) {
+  maps.activeAgentViewers.add(ck);
+  const termKey = maps.agentToTerminal.get(ck);
+  if (termKey && termKey !== ck) {
+    maps.activeAgentViewers.add(termKey);
+    return { aliasKey: termKey };
+  }
+  return { aliasKey: null };
+}
+function removeAgentViewer(ck, maps) {
+  maps.activeAgentViewers.delete(ck);
+  const termKey = maps.agentToTerminal.get(ck);
+  if (termKey && termKey !== ck) {
+    maps.activeAgentViewers.delete(termKey);
+    return { aliasKey: termKey };
+  }
+  return { aliasKey: null };
+}
+function hasActiveViewer(ck, maps) {
+  if (maps.activeAgentViewers.has(ck)) return true;
+  for (const [alias, termKey] of maps.agentToTerminal) {
+    if (termKey === ck && maps.activeAgentViewers.has(alias)) return true;
+  }
+  return false;
+}
+
+// electron/terminal/session-repair.ts
+var crypto = __toESM(require("crypto"));
+function repairDuplicateSessionIds(officeId, data, options = {}) {
+  const logger = options.logger ?? { warn: (msg) => console.warn(msg) };
+  const mintId = options.mintId ?? (() => crypto.randomUUID());
+  const seen = /* @__PURE__ */ new Map();
+  let repaired = false;
+  for (const [agentId, sessionId] of data.sessionIds.entries()) {
+    const firstAgent = seen.get(sessionId);
+    if (firstAgent === void 0) {
+      seen.set(sessionId, agentId);
+      continue;
+    }
+    let fresh = mintId();
+    while (seen.has(fresh) || data.sessionIds.get(agentId) === fresh) {
+      fresh = mintId();
+    }
+    data.sessionIds.set(agentId, fresh);
+    seen.set(fresh, agentId);
+    logger.warn(
+      `[TermServer] Repaired duplicate sessionId for officeId=${officeId} agentId=${agentId} from=${sessionId} to=${fresh}`
+    );
+    repaired = true;
+  }
+  return repaired;
+}
+
 // electron/terminal/server.ts
 var ptyProcesses = /* @__PURE__ */ new Map();
+var DEBUG_COLD_START = process.env.COPILOT_OFFICE_DEBUG_COLD_START === "1";
 var agentToTerminal = /* @__PURE__ */ new Map();
 var activeAgentViewers = /* @__PURE__ */ new Set();
+var viewerMaps = { activeAgentViewers, agentToTerminal };
 var agentWatchers = /* @__PURE__ */ new Map();
 var terminalBackend = null;
 var eventSourceFactory = new FileWatcherEventSourceFactory();
@@ -5626,12 +5682,8 @@ function getOfficeSession(officeId) {
 function compositeKey(officeId, agentId) {
   return `${officeId}:${agentId}`;
 }
-function hasActiveViewer(ck) {
-  if (activeAgentViewers.has(ck)) return true;
-  for (const [alias, termKey] of agentToTerminal) {
-    if (termKey === ck && activeAgentViewers.has(alias)) return true;
-  }
-  return false;
+function hasActiveViewer2(ck) {
+  return hasActiveViewer(ck, viewerMaps);
 }
 function send(msg) {
   if (process.send) {
@@ -5675,6 +5727,10 @@ async function loadOfficeSessionFile(officeId) {
         data.sessionMeta = /* @__PURE__ */ new Map();
         await saveOfficeSessionFile(officeId);
       }
+      const repaired = repairDuplicateSessionIds(officeId, data);
+      if (repaired) {
+        await saveOfficeSessionFile(officeId);
+      }
       console.log(`[TermServer] Loaded sessions for ${officeId}: ${data.sessionIds.size} current, ${data.sessionHistory.size} history`);
     }
   } catch (e) {
@@ -5790,6 +5846,9 @@ function killPtyProcess(proc) {
 }
 var pendingPreseededPrompts = /* @__PURE__ */ new Map();
 async function startTerminalForAgent(officeId, agentId, workingDir, cols, rows, preseededPrompt, launchMode = "copilot") {
+  if (process.env.COPILOT_E2E === "1") {
+    launchMode = "shell";
+  }
   if (!terminalBackend || !terminalBackend.isAvailable()) {
     return { success: false, error: "terminal backend not available" };
   }
@@ -5806,7 +5865,7 @@ async function startTerminalForAgent(officeId, agentId, workingDir, cols, rows,
   const officeData = getOfficeSession(officeId);
   let sessionId = officeData.sessionIds.get(agentId);
   if (!sessionId) {
-    sessionId = crypto.randomUUID();
+    sessionId = crypto2.randomUUID();
     officeData.sessionIds.set(agentId, sessionId);
     await saveOfficeSessionFile(officeId);
     console.log(`[TermServer] New session GUID for ${ck}: ${sessionId}`);
@@ -5939,7 +5998,7 @@ async function startTerminalForAgent(officeId, agentId, workingDir, cols, rows,
           console.log(`[TermServer] Subagent FAILED for ${ck}: ${d.agentName ?? "unknown"} (toolCallId: ${d.toolCallId ?? "?"}, error: ${d.error ?? "unknown"})`);
         }
         const isFleetCriticalEvent = event.type.startsWith("subagent.") || event.type === "system.notification" || event.type === "tool.execution_start" && event.data?.toolName === "task";
-        if (isFleetCriticalEvent || hasActiveViewer(ck)) {
+        if (isFleetCriticalEvent || hasActiveViewer2(ck)) {
           send({ type: "copilot-event", agentId, event });
         } else {
           console.warn(`[TermServer] Dropped copilot-event ${event.type} for ${ck} \u2014 no active viewer (viewers: [${[...activeAgentViewers].join(", ")}])`);
@@ -5952,18 +6011,22 @@ async function startTerminalForAgent(officeId, agentId, workingDir, cols, rows,
     let flushTimer = null;
     const flushData = () => {
       flushTimer = null;
-      if (pendingData && hasActiveViewer(ck)) {
+      if (pendingData && hasActiveViewer2(ck)) {
         send({ type: "terminal-data", agentId, data: pendingData });
       }
       pendingData = "";
     };
     proc.onData((data) => {
       appendToScrollback(ck, data);
-      if (!shellOnlyMode && terminalBackend?.name === "node-pty" && !hasSignalledReady && data.includes("Environment loaded")) {
-        console.log(`[TermServer] Primary ready signal for ${ck}: "Environment loaded" detected`);
-        signalReady();
+      if (!shellOnlyMode && terminalBackend?.name === "node-pty" && !hasSignalledReady) {
+        const hasLegacyReadyMarker = data.includes("Environment loaded");
+        const hasInteractiveFooter = data.includes("/ commands") || data.includes("? help");
+        if (hasLegacyReadyMarker || hasInteractiveFooter) {
+          console.log(`[TermServer] Ready signal for ${ck}: PTY marker detected`);
+          signalReady();
+        }
       }
-      if (!hasActiveViewer(ck)) return;
+      if (!hasActiveViewer2(ck)) return;
       pendingData += data;
       if (pendingData.length >= MAX_PENDING_BYTES) {
         if (flushTimer) clearTimeout(flushTimer);
@@ -5989,7 +6052,7 @@ async function startTerminalForAgent(officeId, agentId, workingDir, cols, rows,
     if (!shellOnlyMode && terminalBackend.name === "node-pty") {
       setTimeout(() => {
         console.log(`[TermServer] Starting copilot --session-id for ${ck}: ${sessionId}`);
-        proc.write(`copilot --session-id ${sessionId}\r`);
+        proc.write(`copilot --session-id=${sessionId}\r`);
       }, 500);
     }
     return { success: true, pid: proc.pid, sessionId };
@@ -6058,11 +6121,9 @@ async function handleMessage(msg) {
     case "attach": {
       const ck = compositeKey(msg.officeId, msg.agentId);
       console.log(`[TermServer] Attaching viewer for ${ck}`);
-      activeAgentViewers.add(ck);
-      const termKey = agentToTerminal.get(ck);
-      if (termKey && termKey !== ck) {
-        activeAgentViewers.add(termKey);
-        console.log(`[TermServer] Also marking original key ${termKey} as active viewer (transferred session)`);
+      const { aliasKey } = addAgentViewer(ck, viewerMaps);
+      if (aliasKey) {
+        console.log(`[TermServer] Also marking original key ${aliasKey} as active viewer (transferred session)`);
       }
       const chunks = agentScrollbackBuffers.get(ck) || [];
       const rawScrollback = chunks.join("");
@@ -6072,11 +6133,7 @@ async function handleMessage(msg) {
     case "detach": {
       const ck = compositeKey(msg.officeId, msg.agentId);
       console.log(`[TermServer] Detaching viewer for ${ck}`);
-      activeAgentViewers.delete(ck);
-      const termKey = agentToTerminal.get(ck);
-      if (termKey && termKey !== ck) {
-        activeAgentViewers.delete(termKey);
-      }
+      removeAgentViewer(ck, viewerMaps);
       break;
     }
     case "exists": {
@@ -6093,6 +6150,15 @@ async function handleMessage(msg) {
       const officeData = getOfficeSession(msg.officeId);
       const current = officeData.sessionIds.get(msg.agentId);
       const changed = !!normalized && current !== normalized;
+      if (changed && normalized) {
+        for (const [otherAgent, otherSid] of officeData.sessionIds) {
+          if (otherAgent !== msg.agentId && otherSid === normalized) {
+            console.warn(`[TermServer] Rejected set-session-id ${normalized} for ${compositeKey(msg.officeId, msg.agentId)} \u2014 already in use by ${otherAgent}`);
+            send({ type: "response", requestId: msg.requestId, result: { success: false, error: "sessionId already in use by another agent in this office" } });
+            return;
+          }
+        }
+      }
       if (changed) {
         archiveSessionId(msg.officeId, msg.agentId);
         officeData.sessionIds.set(msg.agentId, normalized);
@@ -6159,7 +6225,7 @@ async function handleMessage(msg) {
       hasAutoTitled.delete(ck);
       send({ type: "session-meta-updated", agentId: msg.agentId, meta: { title: "" } });
       archiveSessionId(msg.officeId, msg.agentId);
-      const newSessionId = crypto.randomUUID();
+      const newSessionId = crypto2.randomUUID();
       officeDataReset.sessionIds.set(msg.agentId, newSessionId);
       await saveOfficeSessionFile(msg.officeId);
       console.log(`[TermServer] Reset session for ${ck}: new GUID ${newSessionId}`);
@@ -6210,7 +6276,7 @@ async function handleMessage(msg) {
       }
       officeData.sessionMeta.clear();
       for (const agentId of officeData.sessionIds.keys()) {
-        officeData.sessionIds.set(agentId, crypto.randomUUID());
+        officeData.sessionIds.set(agentId, crypto2.randomUUID());
       }
       await saveOfficeSessionFile(officeId);
       console.log(`[TermServer] All sessions reset for ${officeId}`);
@@ -6266,7 +6332,15 @@ async function handleMessage(msg) {
     }
     case "get-all-session-meta": {
       const officeData = getOfficeSession(msg.officeId);
-      send({ type: "response", requestId: msg.requestId, result: Object.fromEntries(officeData.sessionMeta) });
+      const merged = {};
+      for (const [agentId, meta] of officeData.sessionMeta.entries()) {
+        const sessionId = officeData.sessionIds.get(agentId);
+        merged[agentId] = sessionId ? { ...meta, sessionId } : { ...meta };
+      }
+      for (const [agentId, sessionId] of officeData.sessionIds.entries()) {
+        if (!merged[agentId]) merged[agentId] = { title: "", sessionId };
+      }
+      send({ type: "response", requestId: msg.requestId, result: merged });
       break;
     }
     case "create-office-session": {