copilotoffice 1.0.0

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

@@ -0,0 +1,230 @@
+"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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// electron/terminal/events-watcher.ts
+var events_watcher_exports = {};
+__export(events_watcher_exports, {
+  EventsWatcher: () => EventsWatcher,
+  formatToolStatus: () => formatToolStatus
+});
+module.exports = __toCommonJS(events_watcher_exports);
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var os = __toESM(require("os"));
+var EventsWatcher = class _EventsWatcher {
+  constructor(sessionId) {
+    this.fileOffset = 0;
+    this.lineBuffer = "";
+    this.watcher = null;
+    this.pollTimer = null;
+    this.fileExistsTimer = null;
+    this.heartbeatTimer = null;
+    this.callback = null;
+    this.stopped = false;
+    this.watchingFile = false;
+    this.initialReadComplete = false;
+    this.sessionId = sessionId;
+    this.filePath = path.join(
+      os.homedir(),
+      ".copilot",
+      "session-state",
+      sessionId,
+      "events.jsonl"
+    );
+  }
+  static {
+    this.POLL_INTERVAL_MS = 500;
+  }
+  static {
+    this.FILE_CHECK_INTERVAL_MS = 200;
+  }
+  static {
+    this.MAX_FILE_WAIT_MS = 6e4;
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+  getFilePath() {
+    return this.filePath;
+  }
+  start(onEvent) {
+    this.callback = onEvent;
+    this.stopped = false;
+    try {
+      fs.accessSync(this.filePath, fs.constants.F_OK);
+      this.startWatching();
+    } catch {
+      console.log(`[EventsWatcher] Waiting for events.jsonl: ${this.filePath}`);
+      const startTime = Date.now();
+      this.fileExistsTimer = setInterval(() => {
+        if (this.stopped) {
+          if (this.fileExistsTimer) clearInterval(this.fileExistsTimer);
+          return;
+        }
+        if (Date.now() - startTime > _EventsWatcher.MAX_FILE_WAIT_MS) {
+          console.warn(`[EventsWatcher] Timed out waiting for events.jsonl after ${_EventsWatcher.MAX_FILE_WAIT_MS / 1e3}s`);
+          if (this.fileExistsTimer) clearInterval(this.fileExistsTimer);
+          this.fileExistsTimer = null;
+          return;
+        }
+        try {
+          fs.accessSync(this.filePath, fs.constants.F_OK);
+          console.log(`[EventsWatcher] Found events.jsonl`);
+          if (this.fileExistsTimer) clearInterval(this.fileExistsTimer);
+          this.fileExistsTimer = null;
+          this.startWatching();
+        } catch {
+        }
+      }, _EventsWatcher.FILE_CHECK_INTERVAL_MS);
+    }
+  }
+  startWatching() {
+    console.log(`[EventsWatcher] Started watching: ${this.filePath}`);
+    this.readNewLines();
+    this.initialReadComplete = true;
+    try {
+      this.watcher = fs.watch(this.filePath, () => {
+        if (!this.stopped) this.readNewLines();
+      });
+    } catch (e) {
+      console.log(`[EventsWatcher] fs.watch failed: ${e}`);
+    }
+    try {
+      fs.watchFile(this.filePath, { interval: _EventsWatcher.POLL_INTERVAL_MS }, () => {
+        if (!this.stopped) this.readNewLines();
+      });
+      this.watchingFile = true;
+    } catch (e) {
+      console.log(`[EventsWatcher] fs.watchFile failed: ${e}`);
+    }
+    this.pollTimer = setInterval(() => {
+      if (!this.stopped) this.readNewLines();
+    }, _EventsWatcher.POLL_INTERVAL_MS);
+    this.heartbeatTimer = setInterval(() => {
+      if (!this.stopped) {
+        console.log(`[EventsWatcher] Heartbeat \u2014 alive, watching ${this.filePath} (offset: ${this.fileOffset})`);
+      }
+    }, 6e4);
+  }
+  /** Synchronous read — no reading guard needed, every trigger processes immediately. */
+  readNewLines() {
+    try {
+      const stat = fs.statSync(this.filePath);
+      if (stat.size <= this.fileOffset) return;
+      const bytesToRead = stat.size - this.fileOffset;
+      const buf = Buffer.alloc(bytesToRead);
+      const fd = fs.openSync(this.filePath, "r");
+      fs.readSync(fd, buf, 0, buf.length, this.fileOffset);
+      fs.closeSync(fd);
+      this.fileOffset = stat.size;
+      const text = this.lineBuffer + buf.toString("utf-8");
+      const lines = text.split("\n");
+      this.lineBuffer = lines.pop() || "";
+      let eventCount = 0;
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const event = JSON.parse(line);
+          eventCount++;
+          if (this.callback) {
+            this.callback(event, !this.initialReadComplete);
+          }
+        } catch (e) {
+          console.log(`[EventsWatcher] Failed to parse line: ${e}`);
+        }
+      }
+      if (eventCount > 0) {
+        console.log(`[EventsWatcher] Read ${eventCount} event(s), +${bytesToRead}B, offset now ${this.fileOffset}`);
+      }
+    } catch (e) {
+    }
+  }
+  stop() {
+    this.stopped = true;
+    if (this.fileExistsTimer) {
+      clearInterval(this.fileExistsTimer);
+      this.fileExistsTimer = null;
+    }
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+    if (this.watchingFile) {
+      try {
+        fs.unwatchFile(this.filePath);
+      } catch {
+      }
+      this.watchingFile = false;
+    }
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+    this.callback = null;
+  }
+};
+function formatToolStatus(toolName, args) {
+  const base = (p) => typeof p === "string" ? path.basename(p) : "";
+  switch (toolName) {
+    case "view":
+      return `Reading ${base(args.path)}`;
+    case "edit":
+      return `Editing ${base(args.path)}`;
+    case "create":
+      return `Creating ${base(args.path)}`;
+    case "powershell":
+      const cmd = args.command || "";
+      return `Running: ${cmd.length > 40 ? cmd.slice(0, 40) + "\u2026" : cmd}`;
+    case "glob":
+      return `Finding files: ${args.pattern || ""}`;
+    case "grep":
+      return `Searching: ${args.pattern || ""}`;
+    case "web_fetch":
+      return `Fetching: ${args.url || ""}`;
+    case "task":
+      return `Subtask: ${args.description || "running"}`;
+    case "ask_user":
+      return "Waiting for your answer";
+    case "report_intent":
+      return `${args.intent || "Working"}`;
+    case "sql":
+      return `Query: ${args.description || "running"}`;
+    default:
+      return `Using ${toolName}`;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EventsWatcher,
+  formatToolStatus
+});

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

@@ -0,0 +1,305 @@
+"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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// electron/terminal/ipc-relay.ts
+var ipc_relay_exports = {};
+__export(ipc_relay_exports, {
+  TerminalRelay: () => TerminalRelay
+});
+module.exports = __toCommonJS(ipc_relay_exports);
+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 })
+    );
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TerminalRelay
+});

package/dist/electron/terminal/preload.js

@@ -0,0 +1,149 @@
+"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/terminal/preload.ts
+var preload_exports = {};
+module.exports = __toCommonJS(preload_exports);
+var import_electron = require("electron");
+import_electron.contextBridge.exposeInMainWorld("copilotBridge", {
+  // Terminal management
+  terminalStart: (officeId, agentId, workingDir, cols, rows, preseededPrompt) => {
+    return import_electron.ipcRenderer.invoke("terminal-start", officeId, agentId, workingDir, cols, rows, preseededPrompt);
+  },
+  terminalWrite: (officeId, agentId, data) => {
+    return import_electron.ipcRenderer.invoke("terminal-write", officeId, agentId, data);
+  },
+  terminalResize: (officeId, agentId, cols, rows) => {
+    return import_electron.ipcRenderer.invoke("terminal-resize", officeId, agentId, cols, rows);
+  },
+  terminalKill: (officeId, agentId) => {
+    return import_electron.ipcRenderer.invoke("terminal-kill", officeId, agentId);
+  },
+  terminalExists: (officeId, agentId) => {
+    return import_electron.ipcRenderer.invoke("terminal-exists", officeId, agentId);
+  },
+  terminalAttach: (officeId, agentId) => {
+    return import_electron.ipcRenderer.invoke("terminal-attach", officeId, agentId);
+  },
+  terminalDetach: (officeId, agentId) => {
+    return import_electron.ipcRenderer.invoke("terminal-detach", officeId, agentId);
+  },
+  terminalPopOut: (officeId, agentId) => {
+    return import_electron.ipcRenderer.invoke("terminal-pop-out", officeId, agentId);
+  },
+  // Session persistence (server is the single source of truth for session IDs)
+  getSessionId: (officeId, agentId) => {
+    return import_electron.ipcRenderer.invoke("get-session-id", officeId, agentId);
+  },
+  resetAllSessions: (officeId) => {
+    return import_electron.ipcRenderer.invoke("reset-all-sessions", officeId);
+  },
+  resetSession: (officeId, agentId) => {
+    return import_electron.ipcRenderer.invoke("terminal-reset-session", officeId, agentId);
+  },
+  getSessionHistory: (officeId, agentId) => {
+    return import_electron.ipcRenderer.invoke("terminal-get-session-history", officeId, agentId);
+  },
+  clearSessionHistory: (officeId, agentId) => {
+    return import_electron.ipcRenderer.invoke("terminal-clear-session-history", officeId, agentId);
+  },
+  listActiveTerminals: () => {
+    return import_electron.ipcRenderer.invoke("list-active-terminals");
+  },
+  queryAgentStatuses: (officeId) => {
+    return import_electron.ipcRenderer.invoke("query-agent-statuses", officeId);
+  },
+  // Session metadata
+  setSessionMeta: (officeId, agentId, meta) => {
+    return import_electron.ipcRenderer.invoke("set-session-meta", officeId, agentId, meta);
+  },
+  getSessionMeta: (officeId, agentId) => {
+    return import_electron.ipcRenderer.invoke("get-session-meta", officeId, agentId);
+  },
+  getAllSessionMeta: (officeId) => {
+    return import_electron.ipcRenderer.invoke("get-all-session-meta", officeId);
+  },
+  // Office session file management
+  createOfficeSession: (officeId) => {
+    return import_electron.ipcRenderer.invoke("create-office-session", officeId);
+  },
+  deleteOfficeSession: (officeId) => {
+    return import_electron.ipcRenderer.invoke("delete-office-session", officeId);
+  },
+  // Transfer a session (ID, metadata, PTY alias) from one office to another
+  transferSession: (fromOfficeId, toOfficeId, agentId) => {
+    return import_electron.ipcRenderer.invoke("transfer-session", fromOfficeId, toOfficeId, agentId);
+  },
+  // Office file persistence
+  saveOffices: (data) => {
+    return import_electron.ipcRenderer.invoke("save-offices", data);
+  },
+  loadOffices: () => {
+    return import_electron.ipcRenderer.invoke("load-offices");
+  },
+  // 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));
+  },
+  onCopilotTurnStart: (callback) => {
+    import_electron.ipcRenderer.on("copilot-turn-start", (_event, agentId) => callback(agentId));
+  },
+  onCopilotUserMessage: (callback) => {
+    import_electron.ipcRenderer.on("copilot-user-message", (_event, agentId) => callback(agentId));
+  },
+  onSessionMetaUpdated: (callback) => {
+    import_electron.ipcRenderer.on("session-meta-updated", (_event, agentId, meta) => callback(agentId, meta));
+  },
+  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-turn-start");
+    import_electron.ipcRenderer.removeAllListeners("copilot-user-message");
+    import_electron.ipcRenderer.removeAllListeners("session-meta-updated");
+  },
+  // Signal the main process that the next reload should restart the terminal server
+  requestHardReload: () => {
+    return import_electron.ipcRenderer.invoke("request-hard-reload");
+  },
+  // Native OS notifications
+  showNativeNotification: (title, body) => {
+    return import_electron.ipcRenderer.invoke("show-native-notification", title, body);
+  }
+});