copilotoffice 1.0.2 → 1.0.4

package/dist/electron/terminal-server.js

@@ -1,485 +0,0 @@
-"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/terminal-server.ts
-var path2 = __toESM(require("path"));
-var os2 = __toESM(require("os"));
-var fs2 = __toESM(require("fs"));
-var crypto = __toESM(require("crypto"));
-var import_child_process = require("child_process");
-
-// electron/events-watcher.ts
-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.callback = null;
-    this.stopped = false;
-    this.reading = 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;
-    fs.promises.access(this.filePath, fs.constants.F_OK).then(() => 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;
-        }
-        fs.promises.access(this.filePath, fs.constants.F_OK).then(() => {
-          console.log(`[EventsWatcher] Found events.jsonl`);
-          if (this.fileExistsTimer) clearInterval(this.fileExistsTimer);
-          this.fileExistsTimer = null;
-          this.startWatching();
-        }).catch(() => {
-        });
-      }, _EventsWatcher.FILE_CHECK_INTERVAL_MS);
-    });
-  }
-  startWatching() {
-    this.readNewLines();
-    try {
-      this.watcher = fs.watch(this.filePath, () => {
-        if (!this.stopped) this.readNewLines();
-      });
-    } catch (e) {
-      console.log(`[EventsWatcher] fs.watch failed: ${e}`);
-    }
-    this.pollTimer = setInterval(() => {
-      if (!this.stopped) this.readNewLines();
-    }, _EventsWatcher.POLL_INTERVAL_MS);
-  }
-  async readNewLines() {
-    if (this.reading) return;
-    this.reading = true;
-    try {
-      const stat = await fs.promises.stat(this.filePath);
-      if (stat.size <= this.fileOffset) return;
-      const handle = await fs.promises.open(this.filePath, "r");
-      try {
-        const buf = Buffer.alloc(stat.size - this.fileOffset);
-        await handle.read(buf, 0, buf.length, this.fileOffset);
-        this.fileOffset = stat.size;
-        const text = this.lineBuffer + buf.toString("utf-8");
-        const lines = text.split("\n");
-        this.lineBuffer = lines.pop() || "";
-        for (const line of lines) {
-          if (!line.trim()) continue;
-          try {
-            const event = JSON.parse(line);
-            if (this.callback) {
-              this.callback(event);
-            }
-          } catch (e) {
-            console.log(`[EventsWatcher] Failed to parse line: ${e}`);
-          }
-        }
-      } finally {
-        await handle.close();
-      }
-    } catch (e) {
-    } finally {
-      this.reading = false;
-    }
-  }
-  stop() {
-    this.stopped = true;
-    if (this.fileExistsTimer) {
-      clearInterval(this.fileExistsTimer);
-      this.fileExistsTimer = null;
-    }
-    if (this.watcher) {
-      this.watcher.close();
-      this.watcher = null;
-    }
-    if (this.pollTimer) {
-      clearInterval(this.pollTimer);
-      this.pollTimer = 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}`;
-  }
-}
-
-// electron/terminal-server.ts
-var pty = null;
-var ptyProcesses = /* @__PURE__ */ new Map();
-var agentToTerminal = /* @__PURE__ */ new Map();
-var activeAgentViewers = /* @__PURE__ */ new Set();
-var agentWatchers = /* @__PURE__ */ new Map();
-var MAX_BUFFER_LINES = 500;
-var agentScrollbackBuffers = /* @__PURE__ */ new Map();
-var SESSION_FILE = path2.join(process.cwd(), "copilot-office-sessions.json");
-var agentSessionIds = /* @__PURE__ */ new Map();
-function send(msg) {
-  if (process.send) {
-    process.send(msg);
-  }
-}
-function appendToScrollback(agentId, data) {
-  let buf = agentScrollbackBuffers.get(agentId);
-  if (!buf) {
-    buf = [];
-    agentScrollbackBuffers.set(agentId, buf);
-  }
-  const lines = data.split("\n");
-  for (const line of lines) {
-    buf.push(line);
-  }
-  if (buf.length > MAX_BUFFER_LINES) {
-    buf.splice(0, buf.length - MAX_BUFFER_LINES);
-  }
-}
-async function loadSessionIds() {
-  try {
-    const raw = await fs2.promises.readFile(SESSION_FILE, "utf8").catch(() => null);
-    if (raw) {
-      agentSessionIds = new Map(Object.entries(JSON.parse(raw)));
-      console.log("[TermServer] Loaded saved sessions:", agentSessionIds.size);
-    }
-  } catch (e) {
-    console.error("[TermServer] Failed to load session IDs:", e);
-  }
-}
-async function saveSessionIds() {
-  try {
-    const data = Object.fromEntries(agentSessionIds);
-    await fs2.promises.writeFile(SESSION_FILE, JSON.stringify(data, null, 2));
-  } catch (e) {
-    console.error("[TermServer] Failed to save session IDs:", e);
-  }
-}
-function getTerminalKey(agentId) {
-  const assignedKey = agentToTerminal.get(agentId);
-  if (assignedKey && ptyProcesses.has(assignedKey)) return assignedKey;
-  if (ptyProcesses.has(agentId)) return agentId;
-  return null;
-}
-function killAllPtyProcesses() {
-  console.log(`[TermServer] Killing ${ptyProcesses.size} PTY processes`);
-  ptyProcesses.forEach((proc, key) => {
-    try {
-      proc.process.kill();
-    } catch (e) {
-    }
-  });
-  ptyProcesses.clear();
-  agentToTerminal.clear();
-  agentWatchers.forEach((w) => w.stop());
-  agentWatchers.clear();
-}
-async function startTerminalForAgent(agentId, workingDir) {
-  if (!pty) {
-    return { success: false, error: "node-pty not available" };
-  }
-  const existingTerminalKey = agentToTerminal.get(agentId);
-  if (existingTerminalKey && ptyProcesses.has(existingTerminalKey)) {
-    const existing = ptyProcesses.get(existingTerminalKey);
-    return { success: true, pid: existing.pid, sessionId: existing.sessionId, reused: true };
-  }
-  let sessionId = agentSessionIds.get(agentId);
-  if (!sessionId) {
-    sessionId = crypto.randomUUID();
-    agentSessionIds.set(agentId, sessionId);
-    saveSessionIds();
-    console.log(`[TermServer] New session GUID for ${agentId}: ${sessionId}`);
-  } else {
-    console.log(`[TermServer] Reusing session GUID for ${agentId}: ${sessionId}`);
-  }
-  const terminalKey = agentId;
-  const shell = os2.platform() === "win32" ? "powershell.exe" : "bash";
-  let cwd = process.cwd();
-  if (workingDir) {
-    const customPath = path2.join(process.cwd(), workingDir);
-    try {
-      await fs2.promises.access(customPath, fs2.constants.F_OK);
-      cwd = customPath;
-    } catch {
-    }
-  }
-  const taggedEnv = {
-    ...process.env,
-    AGENCY_OFFICE_PROCESS: "true",
-    AGENCY_OFFICE_AGENT: agentId
-  };
-  try {
-    const proc = pty.spawn(shell, [], {
-      name: "xterm-256color",
-      cols: 120,
-      rows: 30,
-      cwd,
-      env: taggedEnv
-    });
-    ptyProcesses.set(terminalKey, {
-      pid: proc.pid,
-      process: proc,
-      agentId: terminalKey,
-      sessionId,
-      workingDir
-    });
-    agentToTerminal.set(agentId, terminalKey);
-    agentSessionIds.set(agentId, sessionId);
-    saveSessionIds();
-    const watcher = new EventsWatcher(sessionId);
-    agentWatchers.set(agentId, watcher);
-    watcher.start((event) => {
-      if (!activeAgentViewers.has(agentId)) return;
-      send({ type: "copilot-event", agentId, event });
-      if (event.type === "tool.execution_start") {
-        const d = event.data;
-        send({ type: "copilot-tool-start", agentId, toolName: d.toolName, toolId: d.toolCallId, status: formatToolStatus(d.toolName, d.arguments) });
-      } else if (event.type === "tool.execution_complete") {
-        const d = event.data;
-        send({ type: "copilot-tool-complete", agentId, toolId: d.toolCallId, success: d.success });
-      } else if (event.type === "assistant.turn_end") {
-        send({ type: "copilot-turn-end", agentId });
-      } else if (event.type === "user.message") {
-        send({ type: "copilot-user-message", agentId });
-      }
-    });
-    const MAX_PENDING_BYTES = 65536;
-    let pendingData = "";
-    let flushTimer = null;
-    const flushData = () => {
-      flushTimer = null;
-      if (pendingData && activeAgentViewers.has(agentId)) {
-        send({ type: "terminal-data", agentId, data: pendingData });
-      }
-      pendingData = "";
-    };
-    proc.onData((data) => {
-      appendToScrollback(agentId, data);
-      if (!activeAgentViewers.has(agentId)) return;
-      pendingData += data;
-      if (pendingData.length >= MAX_PENDING_BYTES) {
-        if (flushTimer) clearTimeout(flushTimer);
-        flushData();
-      } else if (!flushTimer) {
-        flushTimer = setTimeout(flushData, 16);
-      }
-    });
-    proc.onExit(({ exitCode }) => {
-      send({ type: "terminal-exit", agentId, exitCode });
-      ptyProcesses.delete(terminalKey);
-      activeAgentViewers.delete(agentId);
-      agentScrollbackBuffers.delete(agentId);
-      const w = agentWatchers.get(agentId);
-      if (w) {
-        w.stop();
-        agentWatchers.delete(agentId);
-      }
-    });
-    setTimeout(() => {
-      console.log(`[TermServer] Starting copilot --resume for ${agentId}: ${sessionId}`);
-      proc.write(`copilot --resume ${sessionId}\r`);
-    }, 500);
-    return { success: true, pid: proc.pid, sessionId };
-  } catch (error) {
-    return { success: false, error: String(error) };
-  }
-}
-async function handleMessage(msg) {
-  switch (msg.type) {
-    case "start": {
-      activeAgentViewers.add(msg.agentId);
-      const result = await startTerminalForAgent(msg.agentId, msg.workingDir);
-      send({ type: "response", requestId: msg.requestId, result });
-      break;
-    }
-    case "write": {
-      const key = getTerminalKey(msg.agentId);
-      const proc = key ? ptyProcesses.get(key) : null;
-      if (proc) proc.process.write(msg.data);
-      break;
-    }
-    case "resize": {
-      const key = getTerminalKey(msg.agentId);
-      const proc = key ? ptyProcesses.get(key) : null;
-      if (proc) proc.process.resize(msg.cols, msg.rows);
-      break;
-    }
-    case "kill": {
-      const key = getTerminalKey(msg.agentId);
-      const proc = key ? ptyProcesses.get(key) : null;
-      if (proc) {
-        try {
-          proc.process.kill();
-          ptyProcesses.delete(key);
-          agentToTerminal.delete(msg.agentId);
-          send({ type: "response", requestId: msg.requestId, result: { success: true } });
-        } catch (error) {
-          send({ type: "response", requestId: msg.requestId, result: { success: false, error: String(error) } });
-        }
-      } else {
-        send({ type: "response", requestId: msg.requestId, result: { success: false, error: "No terminal for this agent" } });
-      }
-      break;
-    }
-    case "attach": {
-      console.log(`[TermServer] Attaching viewer for ${msg.agentId}`);
-      activeAgentViewers.add(msg.agentId);
-      const scrollback = agentScrollbackBuffers.get(msg.agentId) || [];
-      send({ type: "response", requestId: msg.requestId, result: { success: true, scrollback } });
-      break;
-    }
-    case "detach": {
-      console.log(`[TermServer] Detaching viewer for ${msg.agentId}`);
-      activeAgentViewers.delete(msg.agentId);
-      break;
-    }
-    case "exists": {
-      send({ type: "response", requestId: msg.requestId, result: getTerminalKey(msg.agentId) !== null });
-      break;
-    }
-    case "get-session-id": {
-      send({ type: "response", requestId: msg.requestId, result: agentSessionIds.get(msg.agentId) || null });
-      break;
-    }
-    case "save-session-id": {
-      agentSessionIds.set(msg.agentId, msg.sessionId);
-      saveSessionIds();
-      console.log(`[TermServer] Saved session for ${msg.agentId}: ${msg.sessionId}`);
-      send({ type: "response", requestId: msg.requestId, result: { success: true } });
-      break;
-    }
-    case "pop-out": {
-      const sid = agentSessionIds.get(msg.agentId);
-      if (!sid) {
-        send({ type: "response", requestId: msg.requestId, result: { success: false, error: "No session found for agent" } });
-        break;
-      }
-      const termKey = agentToTerminal.get(msg.agentId);
-      const ptyProc = termKey ? ptyProcesses.get(termKey) : null;
-      let cwd = process.cwd();
-      if (ptyProc?.workingDir) {
-        const customPath = path2.join(process.cwd(), ptyProc.workingDir);
-        try {
-          await fs2.promises.access(customPath, fs2.constants.F_OK);
-          cwd = customPath;
-        } catch {
-        }
-      }
-      try {
-        (0, import_child_process.spawn)("wt", ["-d", cwd, "copilot", "--resume", sid], { detached: true, stdio: "ignore" }).unref();
-        send({ type: "response", requestId: msg.requestId, result: { success: true } });
-      } catch (error) {
-        send({ type: "response", requestId: msg.requestId, result: { success: false, error: String(error) } });
-      }
-      break;
-    }
-    case "shutdown": {
-      console.log("[TermServer] Shutdown requested");
-      killAllPtyProcesses();
-      process.exit(0);
-    }
-  }
-}
-async function main() {
-  console.log("[TermServer] Starting...");
-  try {
-    pty = require("node-pty");
-    console.log("[TermServer] node-pty loaded");
-  } catch (e) {
-    console.error("[TermServer] Failed to load node-pty:", e);
-  }
-  await loadSessionIds();
-  process.on("message", (msg) => {
-    handleMessage(msg).catch((e) => {
-      console.error("[TermServer] Unhandled error in message handler:", e);
-    });
-  });
-  process.on("SIGTERM", () => {
-    killAllPtyProcesses();
-    process.exit(0);
-  });
-  send({ type: "ready" });
-  console.log("[TermServer] Ready");
-}
-main();