@rajat-rastogi/maestro 0.1.6 → 0.2.0

package/app/out/main/main.js

@@ -0,0 +1,1805 @@
+"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
+));
+const electron = require("electron");
+const path = require("path");
+const fs = require("fs");
+const child_process = require("child_process");
+const net = require("net");
+const os = require("os");
+const ini = require("ini");
+const crypto = require("crypto");
+const WebSocket = require("ws");
+const util = require("util");
+const pty = require("node-pty");
+const ssh2 = require("ssh2");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const path__namespace = /* @__PURE__ */ _interopNamespaceDefault(path);
+const fs__namespace = /* @__PURE__ */ _interopNamespaceDefault(fs);
+const net__namespace = /* @__PURE__ */ _interopNamespaceDefault(net);
+const os__namespace = /* @__PURE__ */ _interopNamespaceDefault(os);
+const pty__namespace = /* @__PURE__ */ _interopNamespaceDefault(pty);
+function extractPreview(content) {
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed && !trimmed.startsWith("#") && !trimmed.startsWith("---")) {
+      return trimmed.slice(0, 120);
+    }
+  }
+  return "";
+}
+function registerPlanIpc() {
+  electron.ipcMain.handle("plan:list", async (_event, dir) => {
+    try {
+      const entries = fs__namespace.readdirSync(dir, { withFileTypes: true });
+      const plans = [];
+      for (const entry of entries) {
+        if (entry.isFile() && entry.name.endsWith(".md")) {
+          const filePath = path__namespace.join(dir, entry.name);
+          try {
+            const stat = fs__namespace.statSync(filePath);
+            const content = fs__namespace.readFileSync(filePath, "utf8");
+            plans.push({
+              name: entry.name.replace(/\.md$/, ""),
+              filePath,
+              mtime: stat.mtimeMs,
+              preview: extractPreview(content)
+            });
+          } catch {
+          }
+        }
+      }
+      return plans.sort((a, b) => b.mtime - a.mtime);
+    } catch {
+      return [];
+    }
+  });
+  electron.ipcMain.handle("plan:openDialog", async (_event) => {
+    const win = electron.BrowserWindow.getFocusedWindow();
+    const result = await electron.dialog.showOpenDialog(win, {
+      title: "Open Plan File",
+      filters: [{ name: "Markdown Plans", extensions: ["md"] }],
+      properties: ["openFile"]
+    });
+    return result.canceled ? null : result.filePaths[0];
+  });
+  electron.ipcMain.handle("plan:read", async (_event, filePath) => {
+    try {
+      return fs__namespace.readFileSync(filePath, "utf8");
+    } catch {
+      return null;
+    }
+  });
+  electron.ipcMain.handle("plan:defaultDir", async (_event) => {
+    const cwd = process.cwd();
+    const candidates = [
+      path__namespace.join(cwd, "docs", "plans"),
+      path__namespace.join(cwd, "plans"),
+      cwd
+    ];
+    for (const c of candidates) {
+      if (fs__namespace.existsSync(c)) return c;
+    }
+    return cwd;
+  });
+}
+function resolveMaestro() {
+  const repoRoot = path__namespace.resolve(__dirname, "..", "..", "..");
+  const distMain = path__namespace.join(repoRoot, "dist", "main.js");
+  if (fs__namespace.existsSync(distMain)) {
+    return { cmd: process.execPath, leadArgs: [distMain] };
+  }
+  const binDir = path__namespace.join(repoRoot, "node_modules", ".bin");
+  const winBin = path__namespace.join(binDir, "maestro.cmd");
+  const unixBin = path__namespace.join(binDir, "maestro");
+  if (process.platform === "win32" && fs__namespace.existsSync(winBin)) {
+    return { cmd: winBin, leadArgs: [] };
+  }
+  if (process.platform !== "win32" && fs__namespace.existsSync(unixBin)) {
+    return { cmd: unixBin, leadArgs: [] };
+  }
+  const parentDist = path__namespace.join(repoRoot, "..", "dist", "main.js");
+  if (fs__namespace.existsSync(parentDist)) {
+    return { cmd: process.execPath, leadArgs: [path__namespace.resolve(parentDist)] };
+  }
+  throw new Error(
+    `Cannot find the maestro CLI.
+Expected: ${distMain}
+Run "npm run build" in the repo root first, or install maestro globally.`
+  );
+}
+function allocateFreePort() {
+  return new Promise((resolve, reject) => {
+    const server = net__namespace.createServer();
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      if (!addr || typeof addr === "string") {
+        server.close();
+        reject(new Error("Failed to get port"));
+        return;
+      }
+      const port = addr.port;
+      server.close(() => resolve(port));
+    });
+    server.on("error", reject);
+  });
+}
+const registry = /* @__PURE__ */ new Map();
+function getActiveProcess(role) {
+  return registry.get(role);
+}
+function killProcess(role) {
+  const entry = registry.get(role);
+  if (entry) {
+    if (!entry.process.killed) {
+      entry.process.kill("SIGTERM");
+      setTimeout(() => {
+        if (!entry.process.killed) entry.process.kill("SIGKILL");
+      }, 3e3);
+    }
+    registry.delete(role);
+  }
+}
+function spawnMaestro(opts) {
+  killProcess(opts.role);
+  const { cmd, leadArgs } = resolveMaestro();
+  const allArgs = [...leadArgs, ...opts.args];
+  const child = child_process.spawn(cmd, allArgs, {
+    stdio: ["pipe", "pipe", "pipe"],
+    // Inherit the shell PATH so subprocesses can find tools
+    env: { ...process.env },
+    // Use cmd.exe shell on Windows only when running a .cmd file
+    shell: cmd.endsWith(".cmd")
+  });
+  const handle = {
+    process: child,
+    port: opts.port,
+    kill() {
+      if (!child.killed) {
+        child.kill("SIGTERM");
+        setTimeout(() => {
+          if (!child.killed) child.kill("SIGKILL");
+        }, 3e3);
+      }
+    }
+  };
+  registry.set(opts.role, handle);
+  if (opts.onData) {
+    const handler = opts.onData;
+    let buf = "";
+    const processChunk = (chunk) => {
+      buf += chunk.toString();
+      const lines = buf.split("\n");
+      buf = lines.pop() ?? "";
+      lines.forEach((l) => handler(l));
+    };
+    child.stdout?.on("data", processChunk);
+    child.stderr?.on("data", processChunk);
+  }
+  if (opts.onExit) {
+    child.on("exit", opts.onExit);
+  }
+  child.on("exit", () => {
+    if (registry.get(opts.role) === handle) {
+      registry.delete(opts.role);
+    }
+  });
+  return handle;
+}
+const ROLE$2 = "run";
+function registerRunIpc(getMainWindow) {
+  electron.ipcMain.handle("run:start", async (_event, planFile, opts) => {
+    const port = await allocateFreePort();
+    const args = [planFile, "--serve", "-p", String(port)];
+    if (opts.provider) args.push("--provider", opts.provider);
+    if (opts.maxIterations) args.push("-m", String(opts.maxIterations));
+    if (opts.worktree) args.push("--worktree");
+    if (opts.tasksOnly) args.push("--tasks-only");
+    if (opts.reviewOnly) args.push("--review");
+    spawnMaestro({
+      role: ROLE$2,
+      args,
+      port,
+      onData(line) {
+        const win = getMainWindow();
+        win?.webContents.send("run:log", line);
+      },
+      onExit(code) {
+        const win = getMainWindow();
+        win?.webContents.send("run:exit", code);
+      }
+    });
+    return port;
+  });
+  electron.ipcMain.handle("run:stop", async () => {
+    killProcess(ROLE$2);
+  });
+  electron.ipcMain.handle("run:status", async () => {
+    const proc = getActiveProcess(ROLE$2);
+    return proc ? "running" : "idle";
+  });
+  electron.ipcMain.handle("run:stdin", async (_event, data) => {
+    const proc = getActiveProcess(ROLE$2);
+    if (proc?.process.stdin) {
+      proc.process.stdin.write(data + "\n");
+    }
+  });
+}
+const ROLE$1 = "replay";
+function registerReplayIpc() {
+  electron.ipcMain.handle("replay:start", async () => {
+    const port = await allocateFreePort();
+    spawnMaestro({
+      role: ROLE$1,
+      args: ["--replay", "-p", String(port)],
+      port
+    });
+    await new Promise((resolve) => setTimeout(resolve, 1500));
+    return port;
+  });
+  electron.ipcMain.handle("replay:stop", async () => {
+    killProcess(ROLE$1);
+  });
+  electron.ipcMain.handle("replay:status", async () => {
+    return getActiveProcess(ROLE$1) ? "running" : "idle";
+  });
+}
+const DEFAULTS = {
+  ai_provider: "copilot",
+  claude_command: "claude",
+  claude_args: "--dangerously-skip-permissions --output-format stream-json --verbose",
+  claude_error_patterns: ["You've hit your limit", "API Error:", "cannot be launched inside another Claude Code session"],
+  copilot_command: "copilot",
+  copilot_args: "--autopilot --allow-all",
+  copilot_error_patterns: ["authentication required", "Copilot is not enabled", "rate limit exceeded"],
+  max_iterations: 50,
+  max_external_iterations: 0,
+  max_diff_chars: 5e4,
+  iteration_delay_ms: 2e3,
+  task_retry_count: 1,
+  validation_timeout_ms: 6e4,
+  finalize_enabled: false,
+  use_worktree: false,
+  plans_dir: "docs/plans",
+  default_branch: "",
+  vcs_command: "git",
+  push_on_complete: false,
+  watch_dirs: [],
+  port: 8080,
+  color_task: "#00ff00",
+  color_review: "#00ffff",
+  color_claude_eval: "#64c8ff",
+  color_warn: "#ffff00",
+  color_error: "#ff0000",
+  color_signal: "#ff6464",
+  color_timestamp: "#8a8a8a",
+  color_info: "#b4b4b4"
+};
+const BOOLEAN_KEYS = /* @__PURE__ */ new Set(["finalize_enabled", "use_worktree", "push_on_complete"]);
+const NUMBER_KEYS = /* @__PURE__ */ new Set([
+  "max_iterations",
+  "max_external_iterations",
+  "max_diff_chars",
+  "iteration_delay_ms",
+  "task_retry_count",
+  "validation_timeout_ms",
+  "port"
+]);
+const ARRAY_KEYS = /* @__PURE__ */ new Set(["claude_error_patterns", "copilot_error_patterns", "watch_dirs"]);
+function resolveConfigDir() {
+  return process.env["MAESTRO_CONFIG_DIR"] ?? path__namespace.join(os__namespace.homedir(), ".config", "maestro");
+}
+function parseConfigFile(filePath) {
+  if (!fs__namespace.existsSync(filePath)) return {};
+  try {
+    const raw = fs__namespace.readFileSync(filePath, "utf8");
+    const parsed = ini.parse(raw);
+    const result = {};
+    for (const [key, raw2] of Object.entries(parsed)) {
+      if (!(key in DEFAULTS)) continue;
+      if (BOOLEAN_KEYS.has(key)) {
+        result[key] = raw2 === "true";
+      } else if (NUMBER_KEYS.has(key)) {
+        result[key] = parseInt(raw2) || 0;
+      } else if (ARRAY_KEYS.has(key)) {
+        result[key] = String(raw2).split(",").map((s) => s.trim()).filter(Boolean);
+      } else {
+        result[key] = raw2;
+      }
+    }
+    return result;
+  } catch {
+    return {};
+  }
+}
+function mergeConfig(...layers) {
+  const result = { ...DEFAULTS };
+  for (const layer of layers) {
+    for (const [k, v] of Object.entries(layer)) {
+      if (v !== void 0 && v !== null) result[k] = v;
+    }
+  }
+  return result;
+}
+function buildState(globalPath, projectPath) {
+  const globalOverrides = parseConfigFile(globalPath);
+  const projectOverrides = parseConfigFile(projectPath);
+  const merged = mergeConfig(globalOverrides, projectOverrides);
+  return {
+    merged,
+    defaults: DEFAULTS,
+    globalOverrides,
+    projectOverrides,
+    globalConfigPath: globalPath,
+    projectConfigPath: projectPath,
+    globalExists: fs__namespace.existsSync(globalPath),
+    projectExists: fs__namespace.existsSync(projectPath)
+  };
+}
+function configToIni(overrides) {
+  const lines = [];
+  for (const [key, value] of Object.entries(overrides)) {
+    if (value === void 0 || value === null) continue;
+    if (Array.isArray(value)) {
+      lines.push(`${key} = ${value.join(", ")}`);
+    } else {
+      lines.push(`${key} = ${String(value)}`);
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+function registerConfigIpc() {
+  electron.ipcMain.handle("config:load", async () => {
+    const configDir = resolveConfigDir();
+    const globalPath = path__namespace.join(configDir, "config");
+    const projectPath = path__namespace.join(process.cwd(), ".maestro", "config");
+    return buildState(globalPath, projectPath);
+  });
+  electron.ipcMain.handle("config:save", async (_event, overrides, target) => {
+    const configDir = resolveConfigDir();
+    const targetPath = target === "project" ? path__namespace.join(process.cwd(), ".maestro", "config") : path__namespace.join(configDir, "config");
+    fs__namespace.mkdirSync(path__namespace.dirname(targetPath), { recursive: true });
+    const existing = parseConfigFile(targetPath);
+    const merged = { ...existing, ...overrides };
+    const toWrite = {};
+    for (const [k, v] of Object.entries(merged)) {
+      const def = DEFAULTS[k];
+      if (Array.isArray(def) && Array.isArray(v)) {
+        if (JSON.stringify(v) !== JSON.stringify(def)) toWrite[k] = v;
+      } else if (v !== def) {
+        toWrite[k] = v;
+      }
+    }
+    fs__namespace.writeFileSync(targetPath, configToIni(toWrite), "utf8");
+    return { ok: true };
+  });
+}
+const ROLE = "creator";
+function registerCreatorIpc(getMainWindow) {
+  electron.ipcMain.handle("creator:start", async (_event, description) => {
+    const port = await allocateFreePort();
+    const args = ["--plan", description, "--serve", "-p", String(port)];
+    spawnMaestro({
+      role: ROLE,
+      args,
+      port,
+      onData(line) {
+        const win = getMainWindow();
+        win?.webContents.send("creator:log", line);
+      },
+      onExit(code) {
+        const win = getMainWindow();
+        win?.webContents.send("creator:exit", code);
+      }
+    });
+    return port;
+  });
+  electron.ipcMain.handle("creator:stdin", async (_event, data) => {
+    const proc = getActiveProcess(ROLE);
+    if (proc?.process.stdin) {
+      proc.process.stdin.write(data + "\n");
+    }
+  });
+  electron.ipcMain.handle("creator:stop", async () => {
+    killProcess(ROLE);
+  });
+  electron.ipcMain.handle("creator:status", async () => {
+    return getActiveProcess(ROLE) ? "running" : "idle";
+  });
+}
+function registerMachinesIpc(machineManager2) {
+  electron.ipcMain.handle("machines:list", async () => {
+    return machineManager2.list();
+  });
+  electron.ipcMain.handle("machines:add", async (_e, partial) => {
+    return machineManager2.add(partial);
+  });
+  electron.ipcMain.handle("machines:remove", async (_e, id) => {
+    machineManager2.remove(id);
+  });
+  electron.ipcMain.handle("machines:ping", async (_e, id) => {
+    return machineManager2.ping(id);
+  });
+  electron.ipcMain.handle("machines:update", async (_e, id, partial) => {
+    return machineManager2.update(id, partial);
+  });
+  electron.ipcMain.handle("machines:updateAddress", async (_e, id, address) => {
+    return machineManager2.updateAddress(id, address);
+  });
+  electron.ipcMain.handle("machines:discoverDevBoxes", async () => {
+    return machineManager2.discoverDevBoxes();
+  });
+  electron.ipcMain.handle("machines:launchRdp", async (_e, id) => {
+    return machineManager2.launchRdp(id);
+  });
+}
+function registerSessionsIpc(sessionManager2) {
+  electron.ipcMain.handle("sessions:list", async () => {
+    return sessionManager2.list();
+  });
+  electron.ipcMain.handle("sessions:getBuffer", async (_e, id) => {
+    return sessionManager2.getBuffer(id);
+  });
+  electron.ipcMain.handle("sessions:create", async (_e, opts) => {
+    return sessionManager2.create(opts);
+  });
+  electron.ipcMain.handle("sessions:destroy", async (_e, id) => {
+    sessionManager2.destroy(id);
+  });
+  electron.ipcMain.handle("sessions:rename", async (_e, id, name) => {
+    sessionManager2.rename(id, name);
+  });
+  electron.ipcMain.handle("sessions:updateTags", async (_e, id, tags) => {
+    sessionManager2.updateTags(id, tags);
+  });
+  electron.ipcMain.handle("sessions:sendInput", async (_e, id, data) => {
+    sessionManager2.sendInput(id, data);
+  });
+  electron.ipcMain.handle("sessions:resize", async (_e, id, cols, rows) => {
+    sessionManager2.resize(id, cols, rows);
+  });
+}
+class AgentConnectionPool {
+  static instance = new AgentConnectionPool();
+  static getInstance() {
+    return AgentConnectionPool.instance;
+  }
+  pool = /* @__PURE__ */ new Map();
+  wingetEnv() {
+    const env = { ...process.env };
+    const local = env.LOCALAPPDATA ?? "";
+    if (local) env.PATH = `${local}\\Microsoft\\WinGet\\Links;${env.PATH ?? ""}`;
+    return env;
+  }
+  /** Get a ready WebSocket for tunnelId, spawning devtunnel connect if needed. */
+  async getConnection(tunnelId) {
+    const existing = this.pool.get(tunnelId);
+    if (existing) {
+      if (existing.ready && existing.ws?.readyState === WebSocket.OPEN) {
+        return existing.ws;
+      }
+      return new Promise((resolve) => existing.queue.push(resolve));
+    }
+    const entry = { proc: null, ws: null, ready: false, queue: [] };
+    this.pool.set(tunnelId, entry);
+    entry.proc = child_process.spawn("devtunnel", ["connect", tunnelId], { shell: true, env: this.wingetEnv() });
+    entry.proc.on("error", () => this.teardown(tunnelId));
+    entry.proc.on("exit", () => this.teardown(tunnelId));
+    await new Promise((r) => setTimeout(r, 4e3));
+    const ws = new WebSocket("ws://127.0.0.1:9741");
+    entry.ws = ws;
+    return new Promise((resolve, reject) => {
+      ws.on("open", () => {
+        entry.ready = true;
+        entry.queue.forEach((cb) => cb(ws));
+        entry.queue = [];
+        resolve(ws);
+      });
+      ws.on("error", () => {
+        this.teardown(tunnelId);
+        reject(new Error("agent ws error"));
+      });
+      ws.on("close", () => this.teardown(tunnelId));
+    });
+  }
+  /** Ping the agent via WebSocket, return true if pong received within 5s. */
+  async ping(tunnelId) {
+    try {
+      const ws = await this.getConnection(tunnelId);
+      return new Promise((resolve) => {
+        const t = setTimeout(() => {
+          ws.removeListener("message", handler);
+          resolve(false);
+        }, 5e3);
+        const handler = (data) => {
+          try {
+            const msg = JSON.parse(data.toString());
+            if (msg.type === "pong") {
+              clearTimeout(t);
+              ws.removeListener("message", handler);
+              resolve(true);
+            }
+          } catch {
+          }
+        };
+        ws.on("message", handler);
+        ws.send(JSON.stringify({ type: "ping" }));
+      });
+    } catch {
+      return false;
+    }
+  }
+  teardown(tunnelId) {
+    const entry = this.pool.get(tunnelId);
+    if (entry) {
+      try {
+        entry.proc?.kill();
+      } catch {
+      }
+      try {
+        entry.ws?.close();
+      } catch {
+      }
+      this.pool.delete(tunnelId);
+    }
+  }
+  releaseAll() {
+    for (const id of Array.from(this.pool.keys())) {
+      this.teardown(id);
+    }
+  }
+}
+const agentConnectionPool = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  AgentConnectionPool
+}, Symbol.toStringTag, { value: "Module" }));
+function registerFsIpc(machineManager2) {
+  electron.ipcMain.handle("fs:listDir", async (_e, machineId, dirPath) => {
+    const machine = machineManager2.getById(machineId);
+    if (!machine || machineId === "local") {
+      return listLocalDir(dirPath);
+    }
+    if (machine.authMethod === "dev-tunnel") {
+      return listRemoteDirViaTunnel(machine.tunnelId ?? "", dirPath);
+    }
+    return listRemoteDir(machine.address, dirPath, machine.authMethod, machine.keyPath);
+  });
+  electron.ipcMain.handle("fs:homeDir", async (_e, machineId) => {
+    const machine = machineManager2.getById(machineId);
+    if (!machine || machineId === "local") {
+      return os__namespace.homedir();
+    }
+    return "C:\\Users";
+  });
+}
+function listLocalDir(dirPath) {
+  try {
+    const entries = fs__namespace.readdirSync(dirPath, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory() || e.isFile()).map((e) => ({ name: e.name, isDir: e.isDirectory() })).sort((a, b) => {
+      if (a.isDir !== b.isDir) return a.isDir ? -1 : 1;
+      return a.name.localeCompare(b.name);
+    });
+  } catch {
+    return [];
+  }
+}
+function listRemoteDir(host, dirPath, authMethod, keyPath) {
+  return new Promise((resolve) => {
+    if (authMethod === "ssh-key" && keyPath) {
+      import("ssh2").then(({ Client }) => {
+        const conn = new Client();
+        conn.on("ready", () => {
+          const psCmd = `powershell -Command "Get-ChildItem -LiteralPath '${dirPath.replace(/'/g, "''")}' | Select-Object Name,@{N='IsDir';E={$_.PSIsContainer}} | ConvertTo-Json -Compress"`;
+          conn.exec(psCmd, (err, stream) => {
+            if (err) {
+              conn.end();
+              resolve([]);
+              return;
+            }
+            let output = "";
+            stream.on("data", (chunk) => {
+              output += chunk.toString();
+            });
+            stream.on("close", () => {
+              conn.end();
+              try {
+                const parsed = JSON.parse(output);
+                const items = Array.isArray(parsed) ? parsed : [parsed];
+                resolve(
+                  items.map((i) => ({ name: i.Name, isDir: i.IsDir })).sort((a, b) => {
+                    if (a.isDir !== b.isDir) return a.isDir ? -1 : 1;
+                    return a.name.localeCompare(b.name);
+                  })
+                );
+              } catch {
+                resolve([]);
+              }
+            });
+          });
+        });
+        conn.on("error", () => resolve([]));
+        import("fs").then((fsModule) => {
+          import("os").then((osModule) => {
+            conn.connect({
+              host,
+              port: 22,
+              username: osModule.userInfo().username,
+              privateKey: fsModule.readFileSync(keyPath),
+              readyTimeout: 8e3
+            });
+          });
+        });
+      }).catch(() => resolve([]));
+    } else {
+      resolve([]);
+    }
+  });
+}
+async function listRemoteDirViaTunnel(tunnelId, dirPath) {
+  if (!tunnelId) return [];
+  try {
+    const ws = await AgentConnectionPool.getInstance().getConnection(tunnelId);
+    const id = crypto.randomUUID();
+    return new Promise((resolve) => {
+      const t = setTimeout(() => {
+        ws.removeListener("message", handler);
+        resolve([]);
+      }, 8e3);
+      const handler = (raw) => {
+        try {
+          const msg = JSON.parse(raw.toString());
+          if (msg.id === id && msg.type === "dirList") {
+            clearTimeout(t);
+            ws.removeListener("message", handler);
+            resolve(msg.entries ?? []);
+          }
+        } catch {
+        }
+      };
+      ws.on("message", handler);
+      ws.send(JSON.stringify({ type: "listDir", id, path: dirPath }));
+    });
+  } catch {
+    return [];
+  }
+}
+const execAsync$1 = util.promisify(child_process.exec);
+async function runAz(args) {
+  const { stdout } = await execAsync$1(`az ${args} --output json`, {
+    timeout: 3e4
+  });
+  return JSON.parse(stdout);
+}
+function powerStateToStatus(powerState) {
+  switch (powerState?.toLowerCase()) {
+    case "running":
+      return "online";
+    case "hibernated":
+      return "hibernated";
+    case "stopped":
+    case "deallocated":
+      return "offline";
+    default:
+      return "unknown";
+  }
+}
+async function discoverDevBoxes() {
+  try {
+    await execAsync$1("az account show --output none", { timeout: 1e4 });
+  } catch (err) {
+    const msg = String(err?.message ?? "");
+    if (msg.includes("ENOENT") || msg.includes("not found") || msg.includes("not recognized")) {
+      return { machines: [], error: "az-not-found" };
+    }
+    return { machines: [], error: "not-logged-in", errorMessage: msg };
+  }
+  let endpoints = [];
+  try {
+    const graphResult = await runAz(
+      `graph query -q "Resources | where type =~ 'microsoft.devcenter/projects' | project properties.devCenterUri"`
+    );
+    endpoints = [
+      ...new Set(
+        graphResult.data.map((p) => p.properties_devCenterUri).filter(Boolean)
+      )
+    ];
+  } catch {
+    return { machines: [], error: "unknown", errorMessage: "resource-graph query failed" };
+  }
+  if (endpoints.length === 0) return { machines: [] };
+  const discovered = [];
+  for (const endpoint of endpoints) {
+    try {
+      const boxes = await runAz(
+        `devcenter dev dev-box list --endpoint "${endpoint}" --user-id me`
+      );
+      if (!Array.isArray(boxes)) continue;
+      for (const box of boxes) {
+        discovered.push({
+          name: box.name ?? "Dev Box",
+          type: "devbox",
+          status: powerStateToStatus(box.powerState),
+          onboarded: false,
+          // SSH not yet verified
+          address: "",
+          // unknown until user sets it up
+          authMethod: "az-ssh",
+          discoverySource: "azure-devbox",
+          projectName: box.projectName,
+          endpoint,
+          specs: box.hardwareProfile ? {
+            cpus: box.hardwareProfile.vCPUs ?? 0,
+            memoryGB: box.hardwareProfile.memoryGB ?? 0,
+            storageGB: box.storageProfile?.osDisk?.diskSizeGB ?? 0
+          } : void 0,
+          powerState: box.powerState
+        });
+      }
+    } catch {
+    }
+  }
+  return { machines: discovered };
+}
+async function discoverCloudPCs() {
+  return { machines: [] };
+}
+const execAsync = util.promisify(child_process.exec);
+const LOCAL_MACHINE = {
+  id: "local",
+  name: "This Machine",
+  type: "host",
+  status: "online",
+  onboarded: true,
+  address: "127.0.0.1",
+  authMethod: "az-ssh"
+};
+class MachineManager {
+  machines = /* @__PURE__ */ new Map();
+  statusCallbacks = [];
+  pingInterval = null;
+  persistPath;
+  constructor() {
+    this.persistPath = path__namespace.join(electron.app.getPath("userData"), "machines.json");
+    this.load();
+  }
+  load() {
+    this.machines.set("local", { ...LOCAL_MACHINE });
+    try {
+      const data = fs__namespace.readFileSync(this.persistPath, "utf8");
+      const saved = JSON.parse(data);
+      for (const m of saved) {
+        if (m.id !== "local") {
+          this.machines.set(m.id, m);
+        }
+      }
+    } catch {
+    }
+  }
+  save() {
+    try {
+      const data = JSON.stringify(
+        Array.from(this.machines.values()).filter((m) => m.id !== "local"),
+        null,
+        2
+      );
+      fs__namespace.writeFileSync(this.persistPath, data, "utf8");
+    } catch {
+    }
+  }
+  list() {
+    return Array.from(this.machines.values());
+  }
+  getById(id) {
+    return this.machines.get(id);
+  }
+  add(partial) {
+    const machine = { ...partial, id: crypto.randomUUID(), status: "unknown" };
+    this.machines.set(machine.id, machine);
+    this.save();
+    return machine;
+  }
+  remove(id) {
+    if (id === "local") return;
+    this.machines.delete(id);
+    this.save();
+  }
+  update(id, partial) {
+    const machine = this.machines.get(id);
+    if (!machine) return void 0;
+    Object.assign(machine, partial);
+    if ("address" in partial && !partial.address) machine.onboarded = false;
+    this.save();
+    return machine;
+  }
+  updateAddress(id, address) {
+    const machine = this.machines.get(id);
+    if (!machine) return void 0;
+    machine.address = address;
+    if (!address) machine.onboarded = false;
+    this.save();
+    return machine;
+  }
+  async discoverDevBoxes() {
+    const [devBoxResult, cloudPcResult] = await Promise.all([
+      discoverDevBoxes(),
+      discoverCloudPCs()
+    ]);
+    const allDiscovered = [...devBoxResult.machines, ...cloudPcResult.machines];
+    for (const partial of allDiscovered) {
+      const existing = Array.from(this.machines.values()).find((m) => {
+        if (partial.discoverySource === "azure-devbox") {
+          return m.discoverySource === "azure-devbox" && m.name === partial.name && m.projectName === partial.projectName;
+        }
+        if (partial.discoverySource === "cloud-pc") {
+          return m.discoverySource === "cloud-pc" && m.cloudPcId === partial.cloudPcId;
+        }
+        return false;
+      });
+      if (existing) {
+        existing.status = partial.status;
+        existing.powerState = partial.powerState;
+        if (partial.specs) existing.specs = partial.specs;
+      } else {
+        const machine = { ...partial, id: crypto.randomUUID() };
+        this.machines.set(machine.id, machine);
+      }
+    }
+    this.save();
+    const error = devBoxResult.error ?? cloudPcResult.error;
+    const errorMessage = devBoxResult.errorMessage ?? cloudPcResult.errorMessage;
+    return { machines: this.list(), error, errorMessage };
+  }
+  async launchRdp(id) {
+    const machine = this.machines.get(id);
+    if (!machine) throw new Error("Machine not found");
+    if (machine.discoverySource === "cloud-pc" && machine.cloudPcId) {
+      const upn = machine.cloudPcUpn ?? "";
+      const params = new URLSearchParams({ cpcid: machine.cloudPcId, version: "1.0" });
+      if (upn) params.set("username", upn);
+      await electron.shell.openExternal(`ms-cloudpc:connect?${params.toString()}`);
+      return;
+    }
+    if (machine.discoverySource === "azure-devbox" && machine.endpoint && machine.projectName) {
+      try {
+        const { stdout } = await execAsync(
+          `az devcenter dev dev-box show-remote-connection --endpoint "${machine.endpoint}" --user-id me --dev-box-name "${machine.name}" --project-name "${machine.projectName}" --output json`,
+          { timeout: 3e4 }
+        );
+        const conn = JSON.parse(stdout);
+        const url = conn.rdpConnectionUrl ?? conn.webUrl;
+        if (url) {
+          await electron.shell.openExternal(url);
+          return;
+        }
+      } catch {
+      }
+    }
+    if (machine.address) {
+      child_process.exec(`mstsc /v:${machine.address}`);
+    } else {
+      throw new Error("No RDP connection method available for this machine");
+    }
+  }
+  async ping(id) {
+    const machine = this.machines.get(id);
+    if (!machine) return "unknown";
+    if (id === "local") return "online";
+    const status = machine.authMethod === "az-ssh" ? await azSshPing(machine.address) : machine.authMethod === "dev-tunnel" ? await devTunnelPing(machine.tunnelId ?? "") : await tcpPing(machine.address, 22, 5e3);
+    machine.status = status;
+    if (status === "online") machine.onboarded = true;
+    this.save();
+    this.emitStatusChanged({ machineId: id, status });
+    return status;
+  }
+  onStatusChanged(cb) {
+    this.statusCallbacks.push(cb);
+  }
+  startPingLoop() {
+    this.pingInterval = setInterval(() => {
+      for (const machine of this.machines.values()) {
+        if (machine.id !== "local") {
+          this.ping(machine.id).catch(() => {
+          });
+        }
+      }
+    }, 3e4);
+  }
+  stopPingLoop() {
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval);
+      this.pingInterval = null;
+    }
+    AgentConnectionPool.getInstance().releaseAll();
+  }
+  emitStatusChanged(ev) {
+    for (const cb of this.statusCallbacks) cb(ev);
+  }
+}
+function azSshPing(address) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      child.kill();
+      resolve("offline");
+    }, 2e4);
+    const child = child_process.exec(
+      `az ssh vm --ip "${address}" -- exit`,
+      { timeout: 2e4 },
+      (err) => {
+        clearTimeout(timer);
+        resolve(err ? "offline" : "online");
+      }
+    );
+  });
+}
+async function devTunnelPing(tunnelId) {
+  if (!tunnelId) return "offline";
+  const ok = await AgentConnectionPool.getInstance().ping(tunnelId);
+  return ok ? "online" : "offline";
+}
+function tcpPing(host, port, timeoutMs) {
+  return new Promise((resolve) => {
+    const socket = new net__namespace.Socket();
+    const timer = setTimeout(() => {
+      socket.destroy();
+      resolve("offline");
+    }, timeoutMs);
+    socket.connect(port, host, () => {
+      clearTimeout(timer);
+      socket.destroy();
+      resolve("online");
+    });
+    socket.on("error", () => {
+      clearTimeout(timer);
+      resolve("offline");
+    });
+  });
+}
+class LocalPtyAdapter {
+  ptyProcess;
+  dataHandlers = [];
+  exitHandlers = [];
+  constructor(cwd, cols, rows) {
+    this.ptyProcess = pty__namespace.spawn("powershell.exe", [], {
+      name: "xterm-256color",
+      cols,
+      rows,
+      cwd,
+      env: { ...process.env }
+    });
+    this.ptyProcess.onData((data) => {
+      for (const h of this.dataHandlers) h(data);
+    });
+    this.ptyProcess.onExit(({ exitCode }) => {
+      for (const h of this.exitHandlers) h(exitCode);
+    });
+  }
+  onData(cb) {
+    this.dataHandlers.push(cb);
+  }
+  onExit(cb) {
+    this.exitHandlers.push(cb);
+  }
+  write(data) {
+    this.ptyProcess.write(data);
+  }
+  resize(cols, rows) {
+    try {
+      this.ptyProcess.resize(cols, rows);
+    } catch {
+    }
+  }
+  kill() {
+    try {
+      this.ptyProcess.kill();
+    } catch {
+    }
+  }
+  autoLaunch(provider) {
+    if (provider === "claude") {
+      setTimeout(() => this.write("claude\r"), 800);
+    } else if (provider === "copilot") {
+      setTimeout(() => this.write("copilot --output-format json\r"), 800);
+    }
+  }
+}
+class SshPtyAdapter {
+  callbacks = { onData: [], onExit: [] };
+  ptyProcess = null;
+  // for az-ssh path
+  sshClient = null;
+  // for ssh-key / dev-tunnel path
+  sshStream = null;
+  devtunnelProc = null;
+  // for dev-tunnel path
+  cols;
+  rows;
+  constructor(cols, rows) {
+    this.cols = cols;
+    this.rows = rows;
+  }
+  async connect(machine, workingDirectory) {
+    if (machine.authMethod === "az-ssh") {
+      await this.connectAzSsh(machine, workingDirectory);
+    } else if (machine.authMethod === "dev-tunnel") {
+      await this.connectDevTunnel(machine, workingDirectory);
+    } else {
+      await this.connectSshKey(machine, workingDirectory);
+    }
+  }
+  connectDevTunnel(machine, workingDirectory) {
+    return new Promise((resolve, reject) => {
+      if (!machine.tunnelId) {
+        reject(new Error("No tunnelId configured for this machine"));
+        return;
+      }
+      const localAppData = process.env.LOCALAPPDATA ?? "";
+      const env = { ...process.env };
+      if (localAppData) env.PATH = `${localAppData}\\Microsoft\\WinGet\\Links;${env.PATH ?? ""}`;
+      const child = child_process.spawn("devtunnel", ["connect", machine.tunnelId], { shell: true, env });
+      this.devtunnelProc = child;
+      let portReady = false;
+      child.on("error", (err) => {
+        if (!portReady) reject(err);
+      });
+      child.on("close", (code) => {
+        if (!portReady) {
+          reject(new Error(`devtunnel connect exited with code ${code}`));
+        } else {
+          for (const h of this.callbacks.onExit) h(code ?? void 0);
+        }
+      });
+      setTimeout(() => {
+        if (!portReady) {
+          portReady = true;
+          this.connectSshKey({ ...machine, address: "127.0.0.1" }, workingDirectory).then(resolve).catch((err) => {
+            child.kill();
+            reject(err);
+          });
+        }
+      }, 4e3);
+      setTimeout(() => {
+        if (!portReady) {
+          portReady = true;
+          child.kill();
+          reject(new Error("devtunnel connect timed out after 20s"));
+        }
+      }, 2e4);
+    });
+  }
+  connectAzSsh(machine, workingDirectory) {
+    return new Promise((resolve, reject) => {
+      try {
+        const cdCmd = workingDirectory ? `powershell.exe -NoExit -Command "Set-Location '${workingDirectory.replace(/'/g, "''")}'"` : "powershell.exe";
+        this.ptyProcess = pty__namespace.spawn(
+          "az",
+          ["ssh", "vm", "--ip", machine.address, "--", cdCmd],
+          {
+            name: "xterm-256color",
+            cols: this.cols,
+            rows: this.rows,
+            env: { ...process.env }
+          }
+        );
+        this.ptyProcess.onData((data) => {
+          for (const h of this.callbacks.onData) h(data);
+          resolve();
+        });
+        this.ptyProcess.onExit(({ exitCode }) => {
+          for (const h of this.callbacks.onExit) h(exitCode);
+        });
+        setTimeout(() => reject(new Error("az ssh connection timeout")), 3e4);
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+  connectSshKey(machine, workingDirectory) {
+    return new Promise((resolve, reject) => {
+      if (!machine.keyPath) {
+        reject(new Error("No keyPath set for ssh-key auth"));
+        return;
+      }
+      let privateKey;
+      try {
+        privateKey = fs__namespace.readFileSync(machine.keyPath);
+      } catch (err) {
+        reject(new Error(`Cannot read SSH key at ${machine.keyPath}: ${err}`));
+        return;
+      }
+      this.sshClient = new ssh2.Client();
+      this.sshClient.on("ready", () => {
+        const initialCmd = workingDirectory ? `powershell.exe -NoExit -Command "Set-Location '${workingDirectory.replace(/'/g, "''")}'; $Host.UI.RawUI.WindowSize = New-Object Management.Automation.Host.Size(${this.cols},${this.rows})"` : "powershell.exe";
+        this.sshClient.exec(
+          initialCmd,
+          { pty: { term: "xterm-256color", cols: this.cols, rows: this.rows } },
+          (err, stream) => {
+            if (err) {
+              reject(err);
+              return;
+            }
+            this.sshStream = stream;
+            stream.on("data", (chunk) => {
+              const data = chunk.toString();
+              for (const h of this.callbacks.onData) h(data);
+            });
+            stream.stderr.on("data", (chunk) => {
+              const data = chunk.toString();
+              for (const h of this.callbacks.onData) h(data);
+            });
+            stream.on("close", (code) => {
+              for (const h of this.callbacks.onExit) h(code);
+            });
+            resolve();
+          }
+        );
+      });
+      this.sshClient.on("error", (err) => reject(err));
+      this.sshClient.connect({
+        host: machine.address,
+        port: 22,
+        username: os__namespace.userInfo().username,
+        privateKey,
+        readyTimeout: 15e3
+      });
+    });
+  }
+  onData(cb) {
+    this.callbacks.onData.push(cb);
+  }
+  onExit(cb) {
+    this.callbacks.onExit.push(cb);
+  }
+  write(data) {
+    if (this.ptyProcess) {
+      this.ptyProcess.write(data);
+    } else if (this.sshStream) {
+      this.sshStream.stdin.write(data);
+    }
+  }
+  resize(cols, rows) {
+    this.cols = cols;
+    this.rows = rows;
+    if (this.ptyProcess) {
+      try {
+        this.ptyProcess.resize(cols, rows);
+      } catch {
+      }
+    } else if (this.sshStream) {
+      try {
+        this.sshStream.setWindow(rows, cols, 0, 0);
+      } catch {
+      }
+    }
+  }
+  kill() {
+    try {
+      this.ptyProcess?.kill();
+    } catch {
+    }
+    try {
+      this.sshStream?.close();
+    } catch {
+    }
+    try {
+      this.sshClient?.end();
+    } catch {
+    }
+    try {
+      this.devtunnelProc?.kill();
+    } catch {
+    }
+    this.ptyProcess = null;
+    this.sshStream = null;
+    this.sshClient = null;
+    this.devtunnelProc = null;
+  }
+  autoLaunch(provider) {
+    if (provider === "claude") {
+      setTimeout(() => this.write("claude\r"), 1200);
+    } else if (provider === "copilot") {
+      setTimeout(() => this.write("copilot --output-format json\r"), 1200);
+    }
+  }
+}
+class AgentPtyAdapter {
+  constructor(tunnelId, sessionId) {
+    this.tunnelId = tunnelId;
+    this.sessionId = sessionId;
+  }
+  ws = null;
+  dataCallback = null;
+  exitCallback = null;
+  messageHandler = null;
+  async connect(cwd, cols, rows) {
+    this.ws = await AgentConnectionPool.getInstance().getConnection(this.tunnelId);
+    this.messageHandler = (raw) => {
+      try {
+        const msg = JSON.parse(raw.toString());
+        if (msg.id !== this.sessionId) return;
+        if (msg.type === "data" && this.dataCallback) {
+          this.dataCallback(Buffer.from(msg.data ?? "", "base64").toString());
+        } else if (msg.type === "exit" && this.exitCallback) {
+          this.exitCallback(msg.code ?? null);
+        }
+      } catch {
+      }
+    };
+    this.ws.on("message", this.messageHandler);
+    this.ws.send(JSON.stringify({ type: "create", id: this.sessionId, shell: "powershell", cwd, cols, rows }));
+    await new Promise((resolve) => {
+      const t = setTimeout(resolve, 5e3);
+      const ackHandler = (raw) => {
+        try {
+          const msg = JSON.parse(raw.toString());
+          if (msg.id === this.sessionId && msg.type === "created") {
+            clearTimeout(t);
+            this.ws.removeListener("message", ackHandler);
+            resolve();
+          }
+        } catch {
+        }
+      };
+      this.ws.on("message", ackHandler);
+    });
+  }
+  onData(cb) {
+    this.dataCallback = cb;
+  }
+  onExit(cb) {
+    this.exitCallback = cb;
+  }
+  write(data) {
+    this.ws?.send(JSON.stringify({ type: "input", id: this.sessionId, data }));
+  }
+  resize(cols, rows) {
+    this.ws?.send(JSON.stringify({ type: "resize", id: this.sessionId, cols, rows }));
+  }
+  kill() {
+    if (this.ws && this.messageHandler) {
+      this.ws.removeListener("message", this.messageHandler);
+    }
+    this.ws?.send(JSON.stringify({ type: "destroy", id: this.sessionId }));
+  }
+  autoLaunch(provider) {
+    if (provider === "claude") {
+      setTimeout(() => this.write("claude\r"), 600);
+    } else if (provider === "copilot") {
+      setTimeout(() => this.write("copilot --output-format json\r"), 600);
+    }
+  }
+}
+class StateMonitor {
+  opts;
+  fileWatcher = null;
+  silenceTimer = null;
+  stopped = false;
+  jsonlBuf = "";
+  // Set to true once we see the copilot banner — ignores PowerShell startup noise
+  copilotReady = false;
+  // Track last emitted state to avoid duplicate emissions from TUI redraws
+  lastEmittedState = null;
+  // Regex to strip ANSI escape sequences:
+  // - CSI sequences: \x1b[ (with optional ? > = prefix) digits/semicolons, ending in letter or ~
+  // - OSC sequences: \x1b] ... BEL
+  // - Simple escapes: \x1b followed by single char
+  static ANSI_RE = /\x1b\[[\?>=!]?[0-9;]*[a-zA-Z~]|\x1b\][^\x07]*\x07|\x1b[^\[]/g;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  start() {
+    if (this.opts.provider === "claude") {
+      this.startClaudeHookMonitor();
+    } else if (this.opts.provider !== "copilot") {
+      this.resetSilenceTimer();
+    }
+  }
+  /** Called with every PTY data chunk from the adapter */
+  onPtyData(data) {
+    if (this.stopped) return;
+    if (this.opts.provider === "copilot") {
+      if (!this.copilotReady && data.includes("GitHub Copilot")) {
+        this.copilotReady = true;
+        console.log(`[StateMonitor] ${this.opts.sessionId.slice(0, 8)} copilotReady=true (banner detected)`);
+      }
+      this.jsonlBuf += data;
+      const lines = this.jsonlBuf.split("\n");
+      this.jsonlBuf = lines.pop() ?? "";
+      if (lines.length > 0) {
+        console.log(`[StateMonitor] ${this.opts.sessionId.slice(0, 8)} JSONL: ${lines.length} lines to parse, buf remainder=${this.jsonlBuf.length} chars`);
+      }
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.length > 0) {
+          const stripped = trimmed.replace(/\x1b\[[\?>=!]?[0-9;]*[a-zA-Z~]/g, "").trim();
+          const startsWithBrace = stripped.startsWith("{");
+          console.log(`[StateMonitor] ${this.opts.sessionId.slice(0, 8)} JSONL line: startsWithBrace=${startsWithBrace} len=${trimmed.length} preview=${JSON.stringify(stripped.slice(0, 120))}`);
+        }
+        this.parseJsonlLine(line.trim());
+      }
+      if (this.copilotReady && data.length >= 50) {
+        if (data.includes("Enter to select")) {
+          this.emitState("permission", "heuristic", '"Enter to select" — input required');
+        } else if (data.includes("Esc to cancel") || data.includes("Esc to stop")) {
+          this.emitState("working", "heuristic", '"Esc to cancel/stop" — copilot working');
+        } else if (data.length >= 200) {
+          this.emitState("waiting", "heuristic", "no working/input signals — at prompt");
+        }
+      }
+      if (this.jsonlBuf.length > 1e4) {
+        this.jsonlBuf = this.jsonlBuf.slice(-2e3);
+      }
+    } else if (this.opts.provider !== "claude") {
+      this.resetSilenceTimer();
+    }
+  }
+  stop() {
+    this.stopped = true;
+    this.fileWatcher?.close();
+    this.fileWatcher = null;
+    const localFile = path__namespace.join(os__namespace.homedir(), ".claude", "session-status.txt");
+    fs__namespace.unwatchFile(localFile);
+    if (this.claudePollingInterval) {
+      clearInterval(this.claudePollingInterval);
+      this.claudePollingInterval = null;
+    }
+    if (this.silenceTimer) clearTimeout(this.silenceTimer);
+  }
+  lastClaudeFileContent = null;
+  claudePollingInterval = null;
+  startClaudeHookMonitor() {
+    const isRemote = this.opts.machineId !== "local" && !!this.opts.tunnelId;
+    const statusFilePath = isRemote ? "$HOME/.claude/session-status.txt" : path__namespace.join(os__namespace.homedir(), ".claude", "session-status.txt");
+    console.log(`[StateMonitor] ${this.opts.sessionId.slice(0, 8)} Claude hook monitor starting (${isRemote ? "remote via agent" : "local"})`);
+    console.log(`[StateMonitor] ${this.opts.sessionId.slice(0, 8)}   file: ${statusFilePath}`);
+    if (isRemote) {
+      this.startRemoteClaudePolling();
+    } else {
+      const localFile = path__namespace.join(os__namespace.homedir(), ".claude", "session-status.txt");
+      this.applyClaudeStatus(localFile);
+      fs__namespace.watchFile(localFile, { interval: 500 }, (curr, prev) => {
+        if (curr.mtimeMs !== prev.mtimeMs) {
+          this.applyClaudeStatus(localFile);
+        }
+      });
+    }
+  }
+  startRemoteClaudePolling() {
+    const pollRemote = async () => {
+      if (this.stopped) return;
+      try {
+        const { AgentConnectionPool: AgentConnectionPool2 } = await Promise.resolve().then(() => agentConnectionPool);
+        const ws = await AgentConnectionPool2.getInstance().getConnection(this.opts.tunnelId);
+        const id = `status-${Date.now()}`;
+        return new Promise((resolve) => {
+          const timeout = setTimeout(() => {
+            resolve();
+          }, 3e3);
+          const handler = (raw) => {
+            try {
+              const msg = JSON.parse(raw.toString());
+              if (msg.id === id && msg.type === "fileContent") {
+                clearTimeout(timeout);
+                ws.removeListener("message", handler);
+                const content = (msg.content ?? "").trim().toUpperCase();
+                if (content !== this.lastClaudeFileContent) {
+                  console.log(`[StateMonitor] ${this.opts.sessionId.slice(0, 8)} remote Claude status: "${content}" (was: "${this.lastClaudeFileContent}")`);
+                  this.lastClaudeFileContent = content;
+                  if (content === "WAITING") {
+                    this.opts.onStateChange("waiting", "high");
+                  } else if (content === "RUNNING") {
+                    this.opts.onStateChange("working", "high");
+                  }
+                }
+                resolve();
+              }
+            } catch {
+            }
+          };
+          ws.on("message", handler);
+          ws.send(JSON.stringify({
+            type: "readFile",
+            id,
+            path: "~/.claude/session-status.txt"
+          }));
+        });
+      } catch (err) {
+        console.log(`[StateMonitor] ${this.opts.sessionId.slice(0, 8)} remote poll error: ${err}`);
+      }
+    };
+    setTimeout(() => {
+      pollRemote();
+      this.claudePollingInterval = setInterval(pollRemote, 1e3);
+    }, 5e3);
+  }
+  applyClaudeStatus(localFile) {
+    if (this.stopped) return;
+    try {
+      const raw = fs__namespace.readFileSync(localFile, "utf8");
+      const content = raw.trim().toUpperCase();
+      if (content !== this.lastClaudeFileContent) {
+        console.log(`[StateMonitor] ${this.opts.sessionId.slice(0, 8)} Claude status: "${content}" (was: "${this.lastClaudeFileContent}")`);
+        this.lastClaudeFileContent = content;
+        if (content === "WAITING") {
+          this.opts.onStateChange("waiting", "high");
+        } else if (content === "RUNNING") {
+          this.opts.onStateChange("working", "high");
+        }
+      }
+    } catch {
+    }
+  }
+  parseJsonlLine(line) {
+    const clean = line.replace(/\x1b\[[\?>=!]?[0-9;]*[a-zA-Z~]|\x1b\][^\x07]*\x07|\x1b[^\[]/g, "").trim();
+    if (!clean.startsWith("{")) return;
+    try {
+      const obj = JSON.parse(clean);
+      const type = obj["type"];
+      if (type === "turn_start" || type === "tool_call") {
+        this.emitState("working", "high", `JSONL: ${type}`);
+        this.resetSilenceTimer();
+      } else if (type === "turn_end" || type === "response_end") {
+        this.emitState("waiting", "high", `JSONL: ${type}`);
+        if (this.silenceTimer) {
+          clearTimeout(this.silenceTimer);
+          this.silenceTimer = null;
+        }
+      } else {
+        console.log(`[StateMonitor] ${this.opts.sessionId.slice(0, 8)} JSONL parsed type="${type}" (no state change)`);
+      }
+    } catch {
+    }
+  }
+  /** Emit state change, deduplicating consecutive identical states (from TUI redraws) */
+  emitState(state, confidence, reason) {
+    const key = `${state}:${confidence}`;
+    if (key !== this.lastEmittedState) {
+      console.log(`[StateMonitor] ${this.opts.sessionId.slice(0, 8)} → ${state.toUpperCase()} (${confidence}, ${reason})`);
+      this.lastEmittedState = key;
+      this.opts.onStateChange(state, confidence);
+    }
+  }
+  resetSilenceTimer() {
+    if (this.silenceTimer) clearTimeout(this.silenceTimer);
+    const isCopilot = this.opts.provider === "copilot";
+    this.silenceTimer = setTimeout(() => {
+      if (!this.stopped) {
+        console.log(`[StateMonitor] ${this.opts.sessionId.slice(0, 8)} → ${isCopilot ? "WAITING" : "IDLE"} (silence timer fired, ${isCopilot ? "5s" : "15s"})`);
+        this.opts.onStateChange(isCopilot ? "waiting" : "idle", "heuristic");
+      }
+    }, isCopilot ? 5e3 : 15e3);
+  }
+}
+const CLAUDE_DIR = path__namespace.join(os__namespace.homedir(), ".claude");
+const SETTINGS_FILE = path__namespace.join(CLAUDE_DIR, "settings.json");
+const HOOK_SCRIPT = path__namespace.join(CLAUDE_DIR, "maestro-hook.js");
+const HOOK_MARKER = "maestro-status-hook";
+const HOOK_SCRIPT_CONTENT = `// ${HOOK_MARKER} — auto-generated by Maestro
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const logFile = path.join(os.homedir(), '.claude', 'maestro-hook.log');
+function log(msg) {
+  try {
+    fs.appendFileSync(logFile, new Date().toISOString() + ' ' + msg + '\\n');
+  } catch {}
+}
+
+log('hook invoked, reading stdin...');
+
+let input = '';
+process.stdin.on('data', d => input += d);
+process.stdin.on('end', () => {
+  log('stdin received: ' + input.length + ' chars');
+  try {
+    const data = JSON.parse(input);
+    const event = data.hook_event_name;
+    log('event: ' + event);
+    let status;
+    if (event === 'UserPromptSubmit' || event === 'PreToolUse') {
+      status = 'RUNNING';
+    } else if (event === 'Stop' || event === 'Notification') {
+      status = 'WAITING';
+    }
+    if (status) {
+      const file = path.join(os.homedir(), '.claude', 'session-status.txt');
+      fs.writeFileSync(file, status);
+      log('wrote status: ' + status + ' to ' + file);
+    } else {
+      log('no status mapped for event: ' + event);
+    }
+  } catch (e) {
+    log('ERROR: ' + e.message);
+  }
+});
+`;
+function ensureClaudeHooks() {
+  try {
+    if (!fs__namespace.existsSync(CLAUDE_DIR)) {
+      fs__namespace.mkdirSync(CLAUDE_DIR, { recursive: true });
+    }
+    const hookScriptPath = HOOK_SCRIPT.replace(/\\/g, "/");
+    fs__namespace.writeFileSync(HOOK_SCRIPT, HOOK_SCRIPT_CONTENT, "utf8");
+    console.log(`[ClaudeHooks] Hook script written to ${HOOK_SCRIPT}`);
+    const hookCommand = `node "${hookScriptPath}"`;
+    let settings = {};
+    if (fs__namespace.existsSync(SETTINGS_FILE)) {
+      const raw = fs__namespace.readFileSync(SETTINGS_FILE, "utf8");
+      settings = JSON.parse(raw);
+    }
+    if (!settings.hooks) {
+      settings.hooks = {};
+    }
+    const hookEvents = ["UserPromptSubmit", "PreToolUse", "Stop", "Notification"];
+    let changed = false;
+    for (const event of hookEvents) {
+      if (!settings.hooks[event]) {
+        settings.hooks[event] = [];
+      }
+      const before = settings.hooks[event].length;
+      settings.hooks[event] = settings.hooks[event].filter((rule) => {
+        const flat = rule;
+        if (flat.command?.includes(HOOK_MARKER)) return false;
+        if (rule.hooks?.some((h) => h.command?.includes(HOOK_MARKER) || h.command?.includes("maestro-hook"))) return false;
+        return true;
+      });
+      if (settings.hooks[event].length !== before) changed = true;
+      settings.hooks[event].push({
+        matcher: "",
+        hooks: [{
+          type: "command",
+          command: hookCommand
+        }]
+      });
+      changed = true;
+    }
+    if (changed) {
+      fs__namespace.writeFileSync(SETTINGS_FILE, JSON.stringify(settings, null, 2), "utf8");
+      console.log(`[ClaudeHooks] Registered hooks in ${SETTINGS_FILE}`);
+      console.log(`[ClaudeHooks] Hook command: ${hookCommand}`);
+    }
+  } catch (err) {
+    console.error("[ClaudeHooks] Failed to register hooks:", err);
+  }
+}
+const OUTPUT_BUFFER_MAX = 20 * 1024;
+class SessionManager {
+  entries = /* @__PURE__ */ new Map();
+  machineManager;
+  push;
+  constructor(machineManager2, push) {
+    this.machineManager = machineManager2;
+    this.push = push;
+  }
+  list() {
+    return Array.from(this.entries.values()).map((e) => ({
+      ...e.session,
+      outputBuffer: e.outputBuffer
+    }));
+  }
+  getBuffer(id) {
+    const buf = this.entries.get(id)?.outputBuffer ?? "";
+    console.log(`[SessionManager] getBuffer(${id}) → ${buf.length} chars`);
+    return buf;
+  }
+  async create(opts) {
+    if (opts.provider === "claude") {
+      ensureClaudeHooks();
+    }
+    const cols = opts.cols ?? 120;
+    const rows = opts.rows ?? 30;
+    const machine = this.machineManager.getById(opts.machineId);
+    const session = {
+      id: crypto.randomUUID(),
+      name: opts.name,
+      machineId: opts.machineId,
+      provider: opts.provider,
+      workingDirectory: opts.workingDirectory,
+      state: "idle",
+      stateConfidence: "heuristic",
+      stateEnteredAt: (/* @__PURE__ */ new Date()).toISOString(),
+      tags: {
+        ...opts.tags,
+        "machine": opts.machineId,
+        "provider": opts.provider
+      },
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    let adapter;
+    if (!machine || opts.machineId === "local") {
+      adapter = new LocalPtyAdapter(opts.workingDirectory || process.cwd(), cols, rows);
+    } else if (machine.authMethod === "dev-tunnel") {
+      const agentAdapter = new AgentPtyAdapter(machine.tunnelId, session.id);
+      await agentAdapter.connect(opts.workingDirectory, cols, rows);
+      adapter = agentAdapter;
+    } else {
+      const sshAdapter = new SshPtyAdapter(cols, rows);
+      await sshAdapter.connect(machine, opts.workingDirectory);
+      adapter = sshAdapter;
+    }
+    const monitor = new StateMonitor({
+      sessionId: session.id,
+      provider: opts.provider,
+      machineId: opts.machineId,
+      tunnelId: machine?.tunnelId,
+      onStateChange: (state, confidence) => {
+        this.updateState(session.id, state, confidence);
+      }
+    });
+    const entry = { session, adapter, monitor, outputBuffer: "" };
+    this.entries.set(session.id, entry);
+    adapter.onData((data) => {
+      const e = this.entries.get(session.id);
+      if (!e) return;
+      e.outputBuffer += data;
+      if (e.outputBuffer.length > OUTPUT_BUFFER_MAX) {
+        e.outputBuffer = e.outputBuffer.slice(e.outputBuffer.length - OUTPUT_BUFFER_MAX);
+      }
+      this.push("sessions:data", { sessionId: session.id, data });
+      monitor.onPtyData(data);
+    });
+    adapter.onExit((code) => {
+      const e = this.entries.get(session.id);
+      if (e) {
+        const state = code === 0 || code == null ? "done" : "error";
+        this.updateState(session.id, state, "high");
+      }
+      this.push("sessions:destroyed", session.id);
+    });
+    monitor.start();
+    if (opts.provider !== "none") {
+      adapter.autoLaunch(opts.provider);
+    }
+    return { ...session };
+  }
+  destroy(id) {
+    const entry = this.entries.get(id);
+    if (!entry) return;
+    entry.monitor.stop();
+    entry.adapter.kill();
+    this.entries.delete(id);
+  }
+  rename(id, name) {
+    const entry = this.entries.get(id);
+    if (entry) entry.session.name = name;
+  }
+  updateTags(id, tags) {
+    const entry = this.entries.get(id);
+    if (entry) entry.session.tags = tags;
+  }
+  sendInput(id, data) {
+    this.entries.get(id)?.adapter.write(data);
+  }
+  resize(id, cols, rows) {
+    this.entries.get(id)?.adapter.resize(cols, rows);
+  }
+  destroyAll() {
+    for (const id of Array.from(this.entries.keys())) {
+      this.destroy(id);
+    }
+  }
+  updateState(id, state, confidence) {
+    const entry = this.entries.get(id);
+    if (!entry) return;
+    entry.session.state = state;
+    entry.session.stateConfidence = confidence;
+    entry.session.stateEnteredAt = (/* @__PURE__ */ new Date()).toISOString();
+    entry.session.tags["state"] = state;
+    const ev = {
+      sessionId: id,
+      state,
+      confidence,
+      enteredAt: entry.session.stateEnteredAt
+    };
+    this.push("sessions:stateChanged", ev);
+  }
+}
+const startupArgs = process.argv.slice(2);
+let startupPlanFile = null;
+const pfIdx = startupArgs.indexOf("--plan-file");
+if (pfIdx !== -1 && startupArgs[pfIdx + 1]) {
+  startupPlanFile = startupArgs[pfIdx + 1];
+}
+let mainWindow = null;
+function sendToRenderer(channel, payload) {
+  mainWindow?.webContents.send(channel, payload);
+}
+const machineManager = new MachineManager();
+const sessionManager = new SessionManager(machineManager, sendToRenderer);
+function createWindow() {
+  mainWindow = new electron.BrowserWindow({
+    width: 1280,
+    height: 840,
+    minWidth: 900,
+    minHeight: 600,
+    title: "Maestro",
+    backgroundColor: "#1a1a2e",
+    show: false,
+    webPreferences: {
+      preload: path.join(__dirname, "../preload/preload.js"),
+      contextIsolation: true,
+      nodeIntegration: false,
+      sandbox: false
+    }
+  });
+  mainWindow.once("ready-to-show", () => {
+    mainWindow?.show();
+  });
+  mainWindow.on("closed", () => {
+    for (const role of ["run", "replay", "creator"]) {
+      killProcess(role);
+    }
+    sessionManager.destroyAll();
+    machineManager.stopPingLoop();
+    mainWindow = null;
+  });
+  if (process.env["ELECTRON_RENDERER_URL"]) {
+    mainWindow.loadURL(process.env["ELECTRON_RENDERER_URL"]);
+    mainWindow.webContents.openDevTools({ mode: "detach" });
+  } else {
+    mainWindow.loadFile(path.join(__dirname, "../renderer/index.html"));
+  }
+}
+electron.app.whenReady().then(() => {
+  electron.Menu.setApplicationMenu(null);
+  registerPlanIpc();
+  registerRunIpc(() => mainWindow);
+  registerReplayIpc();
+  registerConfigIpc();
+  registerCreatorIpc(() => mainWindow);
+  registerMachinesIpc(machineManager);
+  registerSessionsIpc(sessionManager);
+  registerFsIpc(machineManager);
+  machineManager.onStatusChanged((ev) => sendToRenderer("machines:statusChanged", ev));
+  machineManager.startPingLoop();
+  electron.ipcMain.handle("app:getStartupArgs", () => ({
+    planFile: startupPlanFile
+  }));
+  createWindow();
+  electron.app.on("activate", () => {
+    if (electron.BrowserWindow.getAllWindows().length === 0) {
+      createWindow();
+    }
+  });
+});
+electron.app.on("window-all-closed", () => {
+  if (process.platform !== "darwin") {
+    electron.app.quit();
+  }
+});