copilotoffice 1.0.0

package/dist/electron/main.js

@@ -0,0 +1,481 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// electron/main.ts
+var import_electron2 = require("electron");
+var path2 = __toESM(require("path"));
+var fs = __toESM(require("fs"));
+var import_child_process2 = require("child_process");
+
+// electron/terminal/ipc-relay.ts
+var import_electron = require("electron");
+var import_child_process = require("child_process");
+var crypto = __toESM(require("crypto"));
+var path = __toESM(require("path"));
+var TerminalRelay = class {
+  constructor(getWindow) {
+    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 = [];
+    this.getWindow = getWindow;
+  }
+  // ── Server Lifecycle ──────────────────────────────────────────
+  spawnServer(distDir) {
+    return new Promise((resolve, reject) => {
+      const serverPath = path.join(distDir, "terminal", "server.js");
+      console.log("[Relay] Forking terminal server:", serverPath);
+      this.server = (0, import_child_process.fork)(serverPath, [], {
+        cwd: process.cwd(),
+        stdio: ["pipe", "inherit", "inherit", "ipc"]
+      });
+      const readyTimeout = setTimeout(() => {
+        reject(new Error("Terminal server did not send ready in time"));
+      }, 15e3);
+      this.server.on("message", (msg) => {
+        this.handleServerMessage(msg, readyTimeout, resolve);
+      });
+      this.server.on("exit", (code, signal) => {
+        console.error(`[Relay] Terminal server exited (code=${code}, signal=${signal})`);
+        clearTimeout(readyTimeout);
+        this.pendingRequests.forEach(
+          (cb) => cb({ success: false, error: "Terminal server crashed" })
+        );
+        this.pendingRequests.clear();
+        this.server = null;
+        if (this.shuttingDown) {
+          console.log("[Relay] Deliberate shutdown \u2014 skipping auto-respawn");
+          return;
+        }
+        const win = this.getWindow();
+        if (win && !win.isDestroyed()) {
+          console.log("[Relay] Respawning terminal server...");
+          this.spawnServer(distDir).catch(
+            (e) => console.error("[Relay] Failed to respawn:", e)
+          );
+        }
+      });
+    });
+  }
+  shutdown() {
+    this.shuttingDown = true;
+    const oldServer = this.server;
+    this.server = null;
+    if (!oldServer) {
+      this.pendingRequests.clear();
+      this.queuedRequests = [];
+      return Promise.resolve();
+    }
+    oldServer.removeAllListeners("exit");
+    oldServer.removeAllListeners("message");
+    if (oldServer.connected) {
+      try {
+        oldServer.send({ type: "shutdown" });
+      } catch {
+      }
+    }
+    this.pendingRequests.forEach(
+      (cb) => cb({ success: false, error: "Terminal server shut down" })
+    );
+    this.pendingRequests.clear();
+    this.queuedRequests = [];
+    const oldPid = oldServer.pid;
+    return new Promise((resolve) => {
+      const onExit = () => {
+        clearTimeout(timeout);
+        resolve();
+      };
+      oldServer.once("exit", onExit);
+      const timeout = setTimeout(() => {
+        oldServer.removeListener("exit", onExit);
+        if (oldPid) {
+          try {
+            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" });
+            } else {
+              process.kill(oldPid, "SIGKILL");
+            }
+          } catch {
+          }
+        }
+        resolve();
+      }, 3e3);
+    });
+  }
+  // ── Internal Helpers ─────────────────────────────────────────
+  send(msg) {
+    if (this.server?.connected) {
+      this.server.send(msg);
+    }
+  }
+  request(msg) {
+    if (!this.server?.connected) {
+      console.log(`[Relay] Server not connected \u2014 queuing request ${msg.type} (${msg.requestId})`);
+      return new Promise((resolve) => {
+        this.queuedRequests.push({ msg, resolve });
+      });
+    }
+    return new Promise((resolve) => {
+      this.pendingRequests.set(msg.requestId, resolve);
+      this.send(msg);
+    });
+  }
+  id() {
+    return crypto.randomUUID();
+  }
+  handleServerMessage(msg, readyTimeout, onReady) {
+    if (msg.type === "ready") {
+      clearTimeout(readyTimeout);
+      this.shuttingDown = false;
+      console.log("[Relay] Terminal server ready");
+      if (this.queuedRequests.length > 0) {
+        console.log(`[Relay] Flushing ${this.queuedRequests.length} queued request(s)`);
+        for (const queued of this.queuedRequests) {
+          this.pendingRequests.set(queued.msg.requestId, queued.resolve);
+          this.send(queued.msg);
+        }
+        this.queuedRequests = [];
+      }
+      onReady();
+      return;
+    }
+    if (msg.type === "response") {
+      const cb = this.pendingRequests.get(msg.requestId);
+      if (cb) {
+        this.pendingRequests.delete(msg.requestId);
+        cb(msg.result);
+      }
+      return;
+    }
+    const win = this.getWindow();
+    if (!win || win.isDestroyed()) return;
+    switch (msg.type) {
+      case "terminal-data":
+        win.webContents.send("terminal-data", msg.agentId, msg.data);
+        break;
+      case "terminal-exit":
+        win.webContents.send("terminal-exit", msg.agentId, msg.exitCode);
+        break;
+      case "copilot-event":
+        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);
+        break;
+      case "copilot-tool-complete":
+        win.webContents.send("copilot-tool-complete", msg.agentId, msg.toolId, msg.success);
+        break;
+      case "copilot-turn-end":
+        win.webContents.send("copilot-turn-end", msg.agentId);
+        break;
+      case "copilot-turn-start":
+        win.webContents.send("copilot-turn-start", msg.agentId);
+        break;
+      case "copilot-user-message":
+        win.webContents.send("copilot-user-message", msg.agentId);
+        break;
+      case "session-meta-updated":
+        win.webContents.send("session-meta-updated", msg.agentId, msg.meta);
+        break;
+      case "terminal-preload-status":
+        win.webContents.send("terminal-preload-status", msg.agentId, msg.status);
+        break;
+    }
+  }
+  // ── IPC Handler Registration ──────────────────────────────────
+  registerIpc() {
+    import_electron.ipcMain.handle(
+      "terminal-start",
+      (_event, officeId, agentId, workingDir, cols, rows, preseededPrompt) => this.request({ type: "start", requestId: this.id(), officeId, agentId, workingDir, cols, rows, preseededPrompt })
+    );
+    import_electron.ipcMain.handle(
+      "terminal-attach",
+      (_event, officeId, agentId) => this.request({ type: "attach", requestId: this.id(), officeId, agentId })
+    );
+    import_electron.ipcMain.handle("terminal-detach", (_event, officeId, agentId) => {
+      this.send({ type: "detach", officeId, agentId });
+      return { success: true };
+    });
+    import_electron.ipcMain.handle(
+      "terminal-write",
+      (_event, officeId, agentId, data) => this.request({ type: "write", requestId: this.id(), officeId, agentId, data })
+    );
+    import_electron.ipcMain.handle("terminal-resize", (_event, officeId, agentId, cols, rows) => {
+      this.send({ type: "resize", officeId, agentId, cols, rows });
+      return { success: true };
+    });
+    import_electron.ipcMain.handle(
+      "terminal-kill",
+      (_event, officeId, agentId) => this.request({ type: "kill", requestId: this.id(), officeId, agentId })
+    );
+    import_electron.ipcMain.handle(
+      "terminal-exists",
+      (_event, officeId, agentId) => this.request({ type: "exists", requestId: this.id(), officeId, agentId })
+    );
+    import_electron.ipcMain.handle(
+      "terminal-pop-out",
+      (_event, officeId, agentId) => this.request({ type: "pop-out", requestId: this.id(), officeId, agentId })
+    );
+    import_electron.ipcMain.handle(
+      "get-session-id",
+      (_event, officeId, agentId) => this.request({ type: "get-session-id", requestId: this.id(), officeId, agentId })
+    );
+    import_electron.ipcMain.handle(
+      "reset-all-sessions",
+      (_event, officeId) => this.request({ type: "reset-all-sessions", requestId: this.id(), officeId })
+    );
+    import_electron.ipcMain.handle(
+      "terminal-reset-session",
+      (_event, officeId, agentId) => this.request({ type: "reset-session", requestId: this.id(), officeId, agentId })
+    );
+    import_electron.ipcMain.handle(
+      "terminal-get-session-history",
+      (_event, officeId, agentId) => this.request({ type: "get-session-history", requestId: this.id(), officeId, agentId })
+    );
+    import_electron.ipcMain.handle(
+      "terminal-clear-session-history",
+      (_event, officeId, agentId) => this.request({ type: "clear-session-history", requestId: this.id(), officeId, agentId })
+    );
+    import_electron.ipcMain.handle(
+      "list-active-terminals",
+      () => this.request({ type: "list-active", requestId: this.id() })
+    );
+    import_electron.ipcMain.handle(
+      "query-agent-statuses",
+      (_event, officeId) => this.request({ type: "query-agent-statuses", requestId: this.id(), officeId })
+    );
+    import_electron.ipcMain.handle(
+      "set-session-meta",
+      (_event, officeId, agentId, meta) => this.request({ type: "set-session-meta", requestId: this.id(), officeId, agentId, meta })
+    );
+    import_electron.ipcMain.handle(
+      "get-session-meta",
+      (_event, officeId, agentId) => this.request({ type: "get-session-meta", requestId: this.id(), officeId, agentId })
+    );
+    import_electron.ipcMain.handle(
+      "get-all-session-meta",
+      (_event, officeId) => this.request({ type: "get-all-session-meta", requestId: this.id(), officeId })
+    );
+    import_electron.ipcMain.handle(
+      "create-office-session",
+      (_event, officeId) => this.request({ type: "create-office-session", requestId: this.id(), officeId })
+    );
+    import_electron.ipcMain.handle(
+      "delete-office-session",
+      (_event, officeId) => this.request({ type: "delete-office-session", requestId: this.id(), officeId })
+    );
+    import_electron.ipcMain.handle(
+      "transfer-session",
+      (_event, fromOfficeId, toOfficeId, agentId) => this.request({ type: "transfer-session", requestId: this.id(), fromOfficeId, toOfficeId, agentId })
+    );
+  }
+};
+
+// 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";
+function killOrphanedProcesses() {
+  try {
+    if (process.platform === "win32") {
+      const out = (0, import_child_process2.execSync)(
+        `wmic process where "CommandLine like '%COPILOT_OFFICE_PROCESS%'" get ProcessId`,
+        { encoding: "utf8", stdio: ["pipe", "pipe", "ignore"] }
+      );
+      const pids = out.split(/\r?\n/).map((l) => parseInt(l.trim(), 10)).filter((n) => !isNaN(n) && n !== process.pid);
+      if (pids.length > 0) {
+        console.log(`[Main] Killing ${pids.length} orphaned COPILOT_OFFICE processes:`, pids);
+        for (const pid of pids) {
+          try {
+            (0, import_child_process2.execSync)(`taskkill /T /F /PID ${pid}`, { stdio: "ignore" });
+          } catch {
+          }
+        }
+      }
+    } else {
+      const out = (0, import_child_process2.execSync)("pgrep -f COPILOT_OFFICE_PROCESS || true", {
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "ignore"]
+      });
+      const pids = out.split(/\r?\n/).map((l) => parseInt(l.trim(), 10)).filter((n) => !isNaN(n) && n !== process.pid);
+      if (pids.length > 0) {
+        console.log(`[Main] Killing ${pids.length} orphaned COPILOT_OFFICE processes:`, pids);
+        for (const pid of pids) {
+          try {
+            process.kill(pid, "SIGKILL");
+          } catch {
+          }
+        }
+      }
+    }
+  } catch {
+  }
+}
+var mainWindow = null;
+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"))) {
+      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,
+        stdio: "pipe"
+      });
+    }
+  } else {
+    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: copilotOfficePath,
+      shell: true,
+      stdio: "pipe"
+    });
+  }
+  if (watcherProcess) {
+    watcherProcess.stdout?.on("data", (data) => {
+      const msg = data.toString();
+      console.log("[Watcher]", msg);
+      if (msg.includes("watching") || msg.includes("built")) {
+        if (mainWindow && !mainWindow.isDestroyed()) {
+          mainWindow.webContents.send("build-complete");
+        }
+      }
+    });
+    watcherProcess.stderr?.on("data", (data) => {
+      console.error("[Watcher Error]", data.toString());
+    });
+    console.log("File watcher started");
+  }
+}
+function createWindow() {
+  mainWindow = new import_electron2.BrowserWindow({
+    width: 2560,
+    height: 1440,
+    title: "Copilot Office",
+    webPreferences: {
+      preload: path2.join(__dirname, "terminal", "preload.js"),
+      contextIsolation: true,
+      nodeIntegration: false
+    }
+  });
+  mainWindow.maximize();
+  mainWindow.loadFile(path2.join(__dirname, "../../src/index.html"));
+  if (OPEN_DEVTOOLS_ON_START) {
+    mainWindow.webContents.openDevTools({ mode: "detach" });
+  }
+  mainWindow.webContents.on("did-start-navigation", (_event, _url, isInPlace) => {
+    if (isInPlace && pendingHardReload) {
+      console.log("[Main] Hard reload \u2014 restarting terminal server");
+      pendingHardReload = false;
+      relay.shutdown().then(
+        () => relay.spawnServer(__dirname)
+      ).catch(
+        (e) => console.error("[Main] Failed to respawn after reload:", e)
+      );
+    } else if (isInPlace) {
+      console.log("[Main] Soft reload \u2014 keeping terminal server alive");
+    }
+  });
+  mainWindow.on("closed", () => {
+    if (watcherProcess) {
+      watcherProcess.kill();
+      watcherProcess = null;
+    }
+    mainWindow = null;
+  });
+}
+import_electron2.app.whenReady().then(async () => {
+  import_electron2.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 };
+    }
+  });
+  await relay.spawnServer(__dirname);
+  if (ENABLE_FILE_WATCHER) {
+    startFileWatcher();
+  } else {
+    console.log("[Main] File watcher disabled");
+  }
+  createWindow();
+  import_electron2.app.on("activate", () => {
+    if (import_electron2.BrowserWindow.getAllWindows().length === 0) createWindow();
+  });
+});
+import_electron2.app.on("window-all-closed", () => {
+  if (watcherProcess) watcherProcess.kill();
+  if (process.platform !== "darwin") import_electron2.app.quit();
+});
+var isShuttingDown = false;
+import_electron2.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();
+  });
+});

package/dist/electron/preload.js

@@ -0,0 +1,90 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// electron/preload.ts
+var preload_exports = {};
+module.exports = __toCommonJS(preload_exports);
+var import_electron = require("electron");
+import_electron.contextBridge.exposeInMainWorld("copilotBridge", {
+  // Terminal management
+  terminalStart: (agentId, workingDir) => {
+    return import_electron.ipcRenderer.invoke("terminal-start", agentId, workingDir);
+  },
+  terminalWrite: (agentId, data) => {
+    return import_electron.ipcRenderer.invoke("terminal-write", agentId, data);
+  },
+  terminalResize: (agentId, cols, rows) => {
+    return import_electron.ipcRenderer.invoke("terminal-resize", agentId, cols, rows);
+  },
+  terminalKill: (agentId) => {
+    return import_electron.ipcRenderer.invoke("terminal-kill", agentId);
+  },
+  terminalExists: (agentId) => {
+    return import_electron.ipcRenderer.invoke("terminal-exists", agentId);
+  },
+  terminalAttach: (agentId) => {
+    return import_electron.ipcRenderer.invoke("terminal-attach", agentId);
+  },
+  terminalDetach: (agentId) => {
+    return import_electron.ipcRenderer.invoke("terminal-detach", agentId);
+  },
+  terminalPopOut: (agentId) => {
+    return import_electron.ipcRenderer.invoke("terminal-pop-out", agentId);
+  },
+  // Session persistence
+  saveSessionId: (agentId, sessionId) => {
+    return import_electron.ipcRenderer.invoke("save-session-id", agentId, sessionId);
+  },
+  getSessionId: (agentId) => {
+    return import_electron.ipcRenderer.invoke("get-session-id", agentId);
+  },
+  // Terminal event listeners
+  onTerminalData: (callback) => {
+    import_electron.ipcRenderer.on("terminal-data", (_event, agentId, data) => callback(agentId, data));
+  },
+  onTerminalExit: (callback) => {
+    import_electron.ipcRenderer.on("terminal-exit", (_event, agentId, exitCode) => callback(agentId, exitCode));
+  },
+  onTerminalPreloadStatus: (callback) => {
+    import_electron.ipcRenderer.on("terminal-preload-status", (_event, agentId, status) => callback(agentId, status));
+  },
+  // Copilot activity event listeners
+  onCopilotEvent: (callback) => {
+    import_electron.ipcRenderer.on("copilot-event", (_event, agentId, copilotEvent) => callback(agentId, copilotEvent));
+  },
+  onCopilotToolStart: (callback) => {
+    import_electron.ipcRenderer.on("copilot-tool-start", (_event, agentId, toolName, toolId, status) => callback(agentId, toolName, toolId, status));
+  },
+  onCopilotToolComplete: (callback) => {
+    import_electron.ipcRenderer.on("copilot-tool-complete", (_event, agentId, toolId, success) => callback(agentId, toolId, success));
+  },
+  onCopilotTurnEnd: (callback) => {
+    import_electron.ipcRenderer.on("copilot-turn-end", (_event, agentId) => callback(agentId));
+  },
+  onCopilotUserMessage: (callback) => {
+    import_electron.ipcRenderer.on("copilot-user-message", (_event, agentId) => callback(agentId));
+  },
+  removeTerminalListeners: () => {
+    import_electron.ipcRenderer.removeAllListeners("terminal-data");
+    import_electron.ipcRenderer.removeAllListeners("terminal-exit");
+  },
+  removeCopilotListeners: () => {
+    import_electron.ipcRenderer.removeAllListeners("copilot-event");
+    import_electron.ipcRenderer.removeAllListeners("copilot-tool-start");
+    import_electron.ipcRenderer.removeAllListeners("copilot-tool-complete");
+    import_electron.ipcRenderer.removeAllListeners("copilot-turn-end");
+    import_electron.ipcRenderer.removeAllListeners("copilot-user-message");
+  }
+});