@phenx-inc/ctlsurf 0.1.0

package/out/main/index.js

@@ -0,0 +1,1131 @@
+"use strict";
+const electron = require("electron");
+const path = require("path");
+const fs = require("fs");
+const os = require("os");
+const module$1 = require("module");
+const crypto = require("crypto");
+function getShellCommand() {
+  if (process.platform === "win32") return "powershell.exe";
+  return process.env.SHELL || "/bin/zsh";
+}
+function getBuiltinAgents() {
+  return [
+    {
+      id: "shell",
+      name: "Shell",
+      command: getShellCommand(),
+      args: ["-l"],
+      // login shell to load PATH
+      description: "Default system shell"
+    },
+    {
+      id: "claude",
+      name: "Claude Code",
+      command: "claude",
+      args: [],
+      description: "Anthropic Claude Code CLI"
+    },
+    {
+      id: "codex",
+      name: "Codex CLI",
+      command: "codex",
+      args: [],
+      description: "OpenAI Codex CLI"
+    }
+  ];
+}
+function getDefaultAgent() {
+  return getBuiltinAgents()[0];
+}
+function isCodingAgent(agent) {
+  return agent.id !== "shell";
+}
+function getSettingsDir(useElectron) {
+  {
+    const { app } = require("electron");
+    return app.getPath("userData");
+  }
+}
+const require$1 = module$1.createRequire(require("url").pathToFileURL(__filename).href);
+const pty = require$1("node-pty");
+class PtyManager {
+  process = null;
+  dataCallbacks = [];
+  exitCallbacks = [];
+  constructor(agent, cwd) {
+    const shell = agent.command;
+    const args = agent.args || [];
+    try {
+      console.log(`[pty] Spawning: ${shell} ${args.join(" ")} in ${cwd}`);
+    } catch {
+    }
+    this.process = pty.spawn(shell, args, {
+      name: "xterm-256color",
+      cwd,
+      env: process.env,
+      cols: 80,
+      rows: 24
+    });
+    this.process.onData((data) => {
+      for (const cb of this.dataCallbacks) {
+        cb(data);
+      }
+    });
+    this.process.onExit(({ exitCode }) => {
+      for (const cb of this.exitCallbacks) {
+        cb(exitCode);
+      }
+      this.process = null;
+    });
+  }
+  write(data) {
+    this.process?.write(data);
+  }
+  resize(cols, rows) {
+    this.process?.resize(cols, rows);
+  }
+  kill() {
+    this.process?.kill();
+    this.process = null;
+  }
+  onData(cb) {
+    this.dataCallbacks.push(cb);
+  }
+  onExit(cb) {
+    this.exitCallbacks.push(cb);
+  }
+}
+const CTLSURF_BASE_URL = "https://app.ctlsurf.com/api";
+class CtlsurfApi {
+  baseUrl;
+  apiKey = null;
+  constructor(baseUrl) {
+    this.baseUrl = baseUrl || CTLSURF_BASE_URL;
+  }
+  setApiKey(key) {
+    this.apiKey = key;
+  }
+  setBaseUrl(url) {
+    this.baseUrl = url.endsWith("/api") ? url : `${url}/api`;
+  }
+  getApiKey() {
+    return this.apiKey;
+  }
+  headers() {
+    const h = { "Content-Type": "application/json" };
+    if (this.apiKey) {
+      h["Authorization"] = `Bearer ${this.apiKey}`;
+    }
+    return h;
+  }
+  async request(method, path2, body) {
+    const url = `${this.baseUrl}${path2}`;
+    const opts = {
+      method,
+      headers: this.headers()
+    };
+    if (body) {
+      opts.body = JSON.stringify(body);
+    }
+    const res = await fetch(url, opts);
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`ctlsurf API ${method} ${path2}: ${res.status} ${text}`);
+    }
+    return res.json();
+  }
+  // ─── Pages ───────────────────────────────────────────
+  async createPage(params) {
+    return this.request("POST", "/pages", params);
+  }
+  async findPageByRootPath(rootPath) {
+    return this.request("POST", "/pages/find-by-root-path", { root_path: rootPath });
+  }
+  // ─── Blocks ──────────────────────────────────────────
+  async createBlock(pageId, params) {
+    return this.request("POST", `/blocks/page/${pageId}`, params);
+  }
+  async getBlock(blockId) {
+    return this.request("GET", `/blocks/${blockId}`);
+  }
+  async updateBlock(blockId, params) {
+    return this.request("PUT", `/blocks/${blockId}`, params);
+  }
+  // ─── Folders ────────────────────────────────────────
+  async createFolder(params) {
+    return this.request("POST", "/folders", params);
+  }
+  // ─── Workers ────────────────────────────────────────
+  async getAuthCode() {
+    return this.request("POST", "/workers/token-exchange");
+  }
+  async findFolderByPath(rootPath) {
+    return this.request("POST", "/folders/find-by-path", { root_path: rootPath });
+  }
+  async getFolderPages(folderId) {
+    const folder = await this.request("GET", `/folders/${folderId}`);
+    return folder?.pages || [];
+  }
+  async findFolderByGitRemote(gitRemote) {
+    const folders = await this.request("GET", "/folders");
+    return folders?.find((f) => f.git_remote === gitRemote || f.root_path === gitRemote) || null;
+  }
+  // ─── Log convenience ─────────────────────────────────
+  async appendLog(blockId, action, message, data) {
+    const block = await this.getBlock(blockId);
+    const props = block.props || {};
+    const entries = Array.isArray(props.entries) ? [...props.entries] : [];
+    const maxEntries = props.max_entries || 1e3;
+    const entry = {
+      _id: `log_${entries.length}`,
+      _timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      action,
+      message
+    };
+    if (data) {
+      entry.data = data;
+    }
+    entries.push(entry);
+    const trimmed = entries.length > maxEntries ? entries.slice(-maxEntries) : entries;
+    return this.updateBlock(blockId, {
+      props: { ...props, entries: trimmed }
+    });
+  }
+}
+class ConversationBridge {
+  api;
+  logBlockId = null;
+  pageId = null;
+  buffer = "";
+  flushTimer = null;
+  flushIntervalMs = 3e3;
+  // flush every 3 seconds
+  agentName = "shell";
+  sessionActive = false;
+  inputBuffer = "";
+  constructor(api) {
+    this.api = api;
+  }
+  /**
+   * Start a new logging session.
+   * Creates a log block on the given dataspace page.
+   */
+  async startSession(dataspacePageId, agentName, cwd) {
+    if (!this.api.getApiKey()) {
+      console.log("[bridge] No API key set, skipping session logging");
+      return;
+    }
+    this.pageId = dataspacePageId;
+    this.agentName = agentName;
+    this.buffer = "";
+    this.inputBuffer = "";
+    try {
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").substring(0, 19);
+      const block = await this.api.createBlock(dataspacePageId, {
+        type: "log",
+        title: `${agentName} — ${timestamp} — ${cwd}`,
+        props: {
+          entries: [],
+          max_entries: 1e3
+        }
+      });
+      this.logBlockId = block.id;
+      this.sessionActive = true;
+      await this.api.appendLog(this.logBlockId, "session_start", `Started ${agentName} session`, {
+        agent: agentName,
+        cwd,
+        timestamp
+      });
+      console.log(`[bridge] Session started, log block: ${this.logBlockId}`);
+    } catch (err) {
+      console.error(`[bridge] Failed to start session:`, err.message);
+      this.sessionActive = false;
+    }
+  }
+  /**
+   * Feed terminal output data into the bridge.
+   * Buffers and flushes periodically.
+   */
+  feedOutput(data) {
+    if (!this.sessionActive) return;
+    this.buffer += data;
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+    }
+    this.flushTimer = setTimeout(() => this.flush(), this.flushIntervalMs);
+  }
+  /**
+   * Feed user input data into the bridge.
+   */
+  feedInput(data) {
+    if (!this.sessionActive) return;
+    this.inputBuffer += data;
+    if (data.includes("\r") || data.includes("\n")) {
+      const input = this.inputBuffer.trim();
+      if (input.length > 0) {
+        this.logEntry("user_input", input);
+      }
+      this.inputBuffer = "";
+    }
+  }
+  /**
+   * Flush buffered output to ctlsurf.
+   */
+  async flush() {
+    if (!this.logBlockId || this.buffer.length === 0) return;
+    const chunk = this.buffer;
+    this.buffer = "";
+    const cleaned = stripAnsi(chunk);
+    if (cleaned.trim().length === 0) return;
+    try {
+      await this.api.appendLog(this.logBlockId, "terminal_output", cleaned);
+    } catch (err) {
+      console.error(`[bridge] Failed to append log:`, err.message);
+    }
+  }
+  /**
+   * Log a specific entry immediately.
+   */
+  async logEntry(action, message, data) {
+    if (!this.logBlockId) return;
+    try {
+      await this.api.appendLog(this.logBlockId, action, message, data);
+    } catch (err) {
+      console.error(`[bridge] Failed to log entry:`, err.message);
+    }
+  }
+  /**
+   * End the current session.
+   */
+  async endSession(exitCode) {
+    if (!this.sessionActive || !this.logBlockId) return;
+    await this.flush();
+    try {
+      await this.api.appendLog(this.logBlockId, "session_end", `Session ended (exit code: ${exitCode ?? "unknown"})`, {
+        agent: this.agentName,
+        exitCode
+      });
+    } catch (err) {
+      console.error(`[bridge] Failed to log session end:`, err.message);
+    }
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    this.sessionActive = false;
+    this.logBlockId = null;
+    this.buffer = "";
+    this.inputBuffer = "";
+    console.log("[bridge] Session ended");
+  }
+}
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[\x30-\x3f]*[\x20-\x2f]*[\x40-\x7e]/g, "").replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, "").replace(/\x1b[^[\]](.|$)/g, "").replace(/\x1b/g, "").replace(/\r/g, "").replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, "");
+}
+function log$2(...args) {
+  try {
+    console.log(...args);
+  } catch {
+  }
+}
+const HEARTBEAT_INTERVAL_MS = 3e4;
+const RECONNECT_DELAY_MS = 5e3;
+const MAX_RECONNECT_DELAY_MS = 6e4;
+class WorkerWsClient {
+  ws = null;
+  apiKey = null;
+  baseUrl;
+  events;
+  heartbeatTimer = null;
+  reconnectTimer = null;
+  reconnectDelay = RECONNECT_DELAY_MS;
+  registration = null;
+  workerId = null;
+  _status = "disconnected";
+  shouldReconnect = false;
+  fingerprint;
+  constructor(events, baseUrl) {
+    this.events = events;
+    this.baseUrl = baseUrl || "wss://app.ctlsurf.com";
+    this.fingerprint = this.generateFingerprint();
+  }
+  get status() {
+    return this._status;
+  }
+  get currentWorkerId() {
+    return this.workerId;
+  }
+  setApiKey(key) {
+    this.apiKey = key;
+  }
+  setBaseUrl(url) {
+    this.baseUrl = url;
+  }
+  generateFingerprint() {
+    const data = `${os.hostname()}:${os.userInfo().username}:${os.platform()}:${os.arch()}`;
+    return crypto.createHash("sha256").update(data).digest("hex").slice(0, 32);
+  }
+  setStatus(status) {
+    if (this._status !== status) {
+      this._status = status;
+      this.events.onStatusChange(status);
+    }
+  }
+  connect(registration) {
+    this.registration = { ...registration, fingerprint: this.fingerprint };
+    this.shouldReconnect = true;
+    this.doConnect();
+  }
+  disconnect() {
+    this.shouldReconnect = false;
+    this.clearTimers();
+    if (this.ws) {
+      const oldWs = this.ws;
+      this.ws = null;
+      oldWs.onopen = null;
+      oldWs.onmessage = null;
+      oldWs.onclose = null;
+      oldWs.onerror = null;
+      try {
+        oldWs.close(1e3, "client disconnect");
+      } catch {
+      }
+    }
+    this.setStatus("disconnected");
+  }
+  sendResponse(parentId, content, metadata) {
+    this.send({
+      type: "response",
+      parent_id: parentId,
+      content,
+      metadata
+    });
+  }
+  sendStatusUpdate(status) {
+    this.send({ type: "status_update", status });
+  }
+  sendAck(messageId) {
+    this.send({ type: "ack", message_id: messageId });
+  }
+  sendTerminalData(data) {
+    this.send({ type: "terminal_stream", data });
+  }
+  sendTerminalResize(cols, rows) {
+    this.send({ type: "terminal_resize", cols, rows });
+  }
+  doConnect() {
+    if (!this.apiKey || !this.registration) {
+      log$2("[worker-ws] No API key or registration, skipping connect");
+      return;
+    }
+    this.clearTimers();
+    if (this.ws) {
+      const oldWs = this.ws;
+      this.ws = null;
+      oldWs.onopen = null;
+      oldWs.onmessage = null;
+      oldWs.onclose = null;
+      oldWs.onerror = null;
+      try {
+        oldWs.close();
+      } catch {
+      }
+      setTimeout(() => this.doConnectNow(), 500);
+      return;
+    }
+    this.doConnectNow();
+  }
+  doConnectNow() {
+    if (!this.apiKey || !this.registration) return;
+    if (!this.shouldReconnect) {
+      log$2("[worker-ws] shouldReconnect is false, aborting connect");
+      return;
+    }
+    this.setStatus("connecting");
+    const wsBase = this.baseUrl.replace(/^http/, "ws");
+    const url = `${wsBase}/api/ws/worker?token=${encodeURIComponent(this.apiKey)}`;
+    log$2(`[worker-ws] Connecting to ${url.replace(/token=.*/, "token=***")}...`);
+    try {
+      this.ws = new WebSocket(url);
+    } catch (err) {
+      log$2("[worker-ws] Failed to create WebSocket:", err);
+      this.scheduleReconnect();
+      return;
+    }
+    this.ws.onopen = () => {
+      log$2("[worker-ws] Connected, sending register");
+      this.reconnectDelay = RECONNECT_DELAY_MS;
+      this.send({
+        type: "register",
+        ...this.registration
+      });
+      this.startHeartbeat();
+    };
+    this.ws.onmessage = (event) => {
+      try {
+        const data = JSON.parse(String(event.data));
+        this.handleMessage(data);
+      } catch (err) {
+        log$2("[worker-ws] Failed to parse message:", err);
+      }
+    };
+    this.ws.onclose = (event) => {
+      log$2(`[worker-ws] Disconnected: ${event.code} ${event.reason}`);
+      this.ws = null;
+      this.clearHeartbeat();
+      this.setStatus("disconnected");
+      if (this.shouldReconnect) {
+        this.scheduleReconnect();
+      }
+    };
+    this.ws.onerror = () => {
+      log$2("[worker-ws] WebSocket error");
+    };
+  }
+  handleMessage(data) {
+    const msgType = data.type;
+    switch (msgType) {
+      case "registered": {
+        this.workerId = data.worker_id;
+        const workerStatus = data.status;
+        console.log(`[worker-ws] Registered as ${this.workerId}, status: ${workerStatus}`);
+        if (workerStatus === "pending_approval") {
+          this.setStatus("pending_approval");
+        } else {
+          this.setStatus("connected");
+        }
+        const pendingMessages = data.pending_messages || [];
+        this.events.onRegistered({
+          worker_id: this.workerId,
+          folder_id: data.folder_id,
+          status: workerStatus,
+          pending_messages: pendingMessages
+        });
+        for (const msg of pendingMessages) {
+          this.events.onMessage(msg);
+        }
+        break;
+      }
+      case "approved": {
+        log$2("[worker-ws] Worker approved!");
+        this.setStatus("connected");
+        break;
+      }
+      case "message": {
+        const msg = data.message;
+        if (msg) {
+          console.log(`[worker-ws] Received message: ${msg.id}`);
+          this.events.onMessage(msg);
+        }
+        break;
+      }
+      case "terminal_input": {
+        const inputData = data.data;
+        if (inputData && this.events.onTerminalInput) {
+          this.events.onTerminalInput(inputData);
+        }
+        break;
+      }
+      case "heartbeat_ack":
+        break;
+      default:
+        console.log(`[worker-ws] Unknown message type: ${msgType}`);
+    }
+  }
+  send(data) {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(data));
+    }
+  }
+  startHeartbeat() {
+    this.clearHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      this.send({ type: "heartbeat" });
+    }, HEARTBEAT_INTERVAL_MS);
+  }
+  clearHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  scheduleReconnect() {
+    if (!this.shouldReconnect) return;
+    console.log(`[worker-ws] Reconnecting in ${this.reconnectDelay / 1e3}s...`);
+    this.reconnectTimer = setTimeout(() => {
+      this.doConnect();
+    }, this.reconnectDelay);
+    this.reconnectDelay = Math.min(this.reconnectDelay * 2, MAX_RECONNECT_DELAY_MS);
+  }
+  clearTimers() {
+    this.clearHeartbeat();
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+}
+function log$1(...args) {
+  try {
+    console.log(...args);
+  } catch {
+  }
+}
+const DEFAULT_PROFILES = {
+  production: {
+    name: "Production",
+    apiKey: "",
+    baseUrl: "https://app.ctlsurf.com",
+    dataspacePageId: ""
+  }
+};
+const TERM_STREAM_INTERVAL_MS = 50;
+class Orchestrator {
+  settingsDir;
+  events;
+  // Core services
+  ctlsurfApi = new CtlsurfApi();
+  bridge = new ConversationBridge(this.ctlsurfApi);
+  workerWs;
+  // State
+  ptyManager = null;
+  currentAgent = null;
+  currentCwd = null;
+  settings = {
+    activeProfile: "production",
+    profiles: { ...DEFAULT_PROFILES }
+  };
+  // Terminal stream batching
+  termStreamBuffer = "";
+  termStreamTimer = null;
+  constructor(settingsDir, events) {
+    this.settingsDir = settingsDir;
+    this.events = events;
+    this.workerWs = new WorkerWsClient({
+      onStatusChange: (status) => {
+        log$1(`[worker-ws] Status: ${status}`);
+        events.onWorkerStatus(status);
+      },
+      onMessage: (message) => {
+        log$1(`[worker-ws] Incoming message: ${message.id} (${message.type})`);
+        events.onWorkerMessage(message);
+        this.workerWs.sendAck(message.id);
+        if (message.type === "prompt" || message.type === "task_dispatch") {
+          if (this.ptyManager) {
+            this.ptyManager.write(message.content + "\r");
+            this.bridge.feedInput(message.content);
+          }
+        }
+      },
+      onRegistered: (data) => {
+        log$1(`[worker-ws] Registered: worker_id=${data.worker_id}, folder_id=${data.folder_id}, status=${data.status}`);
+        events.onWorkerRegistered(data);
+        if (!data.folder_id) {
+          events.onWorkerStatus("no_project");
+        }
+      },
+      onTerminalInput: (data) => {
+        this.ptyManager?.write(data);
+      }
+    });
+  }
+  // ─── Settings ───────────────────────────────────
+  getActiveProfile() {
+    return this.settings.profiles[this.settings.activeProfile] || this.settings.profiles.production || DEFAULT_PROFILES.production;
+  }
+  get settingsData() {
+    return this.settings;
+  }
+  get cwd() {
+    return this.currentCwd;
+  }
+  get agent() {
+    return this.currentAgent;
+  }
+  applyProfile(profile) {
+    const apiKey = profile.apiKey || process.env.CTLSURF_API_KEY || "";
+    if (apiKey) {
+      this.ctlsurfApi.setApiKey(apiKey);
+      this.workerWs.setApiKey(apiKey);
+    } else {
+      this.ctlsurfApi.setApiKey("");
+      this.workerWs.setApiKey(null);
+    }
+    const baseUrl = profile.baseUrl || process.env.CTLSURF_BASE_URL || "https://app.ctlsurf.com";
+    this.ctlsurfApi.setBaseUrl(baseUrl);
+    this.workerWs.setBaseUrl(baseUrl);
+    log$1(`[settings] Profile applied: ${profile.name} (${baseUrl})`);
+  }
+  loadSettings() {
+    try {
+      fs.mkdirSync(this.settingsDir, { recursive: true });
+    } catch {
+    }
+    const settingsPath = path.join(this.settingsDir, "settings.json");
+    try {
+      if (fs.existsSync(settingsPath)) {
+        const raw = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+        if (!raw.profiles) {
+          this.settings = {
+            activeProfile: "production",
+            profiles: {
+              production: {
+                name: "Production",
+                apiKey: raw.ctlsurfApiKey || "",
+                baseUrl: raw.ctlsurfBaseUrl || "https://app.ctlsurf.com",
+                dataspacePageId: raw.ctlsurfDataspacePageId || ""
+              }
+            }
+          };
+          this.saveSettings();
+          log$1("[settings] Migrated legacy settings to profiles");
+        } else {
+          this.settings = raw;
+          if (!this.settings.profiles.production) {
+            this.settings.profiles.production = { ...DEFAULT_PROFILES.production };
+          }
+        }
+      }
+    } catch {
+      this.settings = {
+        activeProfile: "production",
+        profiles: { ...DEFAULT_PROFILES }
+      };
+    }
+    this.applyProfile(this.getActiveProfile());
+  }
+  saveSettings() {
+    const settingsPath = path.join(this.settingsDir, "settings.json");
+    try {
+      fs.mkdirSync(this.settingsDir, { recursive: true });
+      fs.writeFileSync(settingsPath, JSON.stringify(this.settings, null, 2));
+    } catch (err) {
+      log$1("[settings] Failed to save:", err.message);
+    }
+  }
+  overrideApiKey(key) {
+    this.ctlsurfApi.setApiKey(key);
+    this.workerWs.setApiKey(key);
+  }
+  overrideBaseUrl(url) {
+    this.ctlsurfApi.setBaseUrl(url);
+    this.workerWs.setBaseUrl(url);
+  }
+  // ─── Profile CRUD ───────────────────────────────
+  listProfiles() {
+    return {
+      activeProfile: this.settings.activeProfile,
+      profiles: Object.entries(this.settings.profiles).map(([id, p]) => ({
+        id,
+        name: p.name,
+        baseUrl: p.baseUrl,
+        hasApiKey: !!p.apiKey,
+        dataspacePageId: p.dataspacePageId || null
+      }))
+    };
+  }
+  getProfile(profileId) {
+    const p = this.settings.profiles[profileId];
+    if (!p) return null;
+    return {
+      id: profileId,
+      name: p.name,
+      baseUrl: p.baseUrl,
+      hasApiKey: !!p.apiKey,
+      dataspacePageId: p.dataspacePageId || ""
+    };
+  }
+  saveProfile(profileId, data) {
+    const existing = this.settings.profiles[profileId];
+    this.settings.profiles[profileId] = {
+      name: data.name,
+      apiKey: data.apiKey !== void 0 ? data.apiKey : existing?.apiKey || "",
+      baseUrl: data.baseUrl || "https://app.ctlsurf.com",
+      dataspacePageId: data.dataspacePageId || ""
+    };
+    this.saveSettings();
+    if (profileId === this.settings.activeProfile) {
+      this.applyProfile(this.settings.profiles[profileId]);
+      if (this.currentAgent && this.currentCwd) {
+        this.workerWs.disconnect();
+        this.connectWorkerWs(this.currentAgent, this.currentCwd);
+      }
+    }
+  }
+  switchProfile(profileId) {
+    if (!this.settings.profiles[profileId]) return { ok: false, error: "Profile not found" };
+    this.workerWs.disconnect();
+    this.settings.activeProfile = profileId;
+    this.saveSettings();
+    this.applyProfile(this.getActiveProfile());
+    if (this.currentAgent && this.currentCwd) {
+      this.connectWorkerWs(this.currentAgent, this.currentCwd);
+    }
+    return { ok: true };
+  }
+  deleteProfile(profileId) {
+    if (profileId === "production") return { ok: false, error: "Cannot delete Production profile" };
+    if (!this.settings.profiles[profileId]) return { ok: false, error: "Profile not found" };
+    if (this.settings.activeProfile === profileId) {
+      this.workerWs.disconnect();
+      this.settings.activeProfile = "production";
+      this.applyProfile(this.getActiveProfile());
+      if (this.currentAgent && this.currentCwd) {
+        this.connectWorkerWs(this.currentAgent, this.currentCwd);
+      }
+    }
+    delete this.settings.profiles[profileId];
+    this.saveSettings();
+    return { ok: true };
+  }
+  // ─── PTY & Agent ────────────────────────────────
+  async spawnAgent(agent, cwd) {
+    if (this.ptyManager) {
+      await this.bridge.endSession();
+      this.ptyManager.kill();
+    }
+    this.currentAgent = agent;
+    const prevCwd = this.currentCwd;
+    this.currentCwd = cwd;
+    if (prevCwd !== cwd) {
+      this.events.onCwdChanged();
+    }
+    this.ptyManager = new PtyManager(agent, cwd);
+    this.ptyManager.onData((data) => {
+      this.events.onPtyData(data);
+      this.bridge.feedOutput(data);
+      this.streamTerminalData(data);
+    });
+    const thisPtyManager = this.ptyManager;
+    this.ptyManager.onExit(async (exitCode) => {
+      this.events.onPtyExit(exitCode);
+      await this.bridge.endSession(exitCode);
+      if (thisPtyManager === this.ptyManager && this.currentAgent && isCodingAgent(this.currentAgent)) {
+        this.workerWs.disconnect();
+      }
+    });
+    const profile = this.getActiveProfile();
+    const dataspacePageId = profile.dataspacePageId || process.env.CTLSURF_DATASPACE_PAGE_ID || "";
+    if (dataspacePageId && this.ctlsurfApi.getApiKey()) {
+      await this.bridge.startSession(dataspacePageId, agent.name, cwd);
+    }
+    if (isCodingAgent(agent)) {
+      this.connectWorkerWs(agent, cwd);
+    } else {
+      this.workerWs.disconnect();
+      this.checkProjectStatus(cwd);
+    }
+  }
+  writePty(data) {
+    this.ptyManager?.write(data);
+    this.bridge.feedInput(data);
+  }
+  resizePty(cols, rows) {
+    this.ptyManager?.resize(cols, rows);
+    this.workerWs.sendTerminalResize(cols, rows);
+  }
+  async killAgent() {
+    await this.bridge.endSession();
+    this.ptyManager?.kill();
+    this.ptyManager = null;
+    if (this.currentAgent && isCodingAgent(this.currentAgent)) {
+      this.workerWs.disconnect();
+    }
+  }
+  // ─── Worker WebSocket ───────────────────────────
+  connectWorkerWs(agent, cwd) {
+    const profile = this.getActiveProfile();
+    const apiKey = profile.apiKey || process.env.CTLSURF_API_KEY;
+    if (!apiKey) {
+      log$1("[worker-ws] No API key, skipping WS connect");
+      return;
+    }
+    this.workerWs.connect({
+      machine: os.hostname(),
+      cwd,
+      agent: agent.name
+    });
+  }
+  async checkProjectStatus(cwd) {
+    if (!this.ctlsurfApi.getApiKey()) {
+      this.events.onWorkerStatus("no_project");
+      return;
+    }
+    try {
+      const folder = await this.ctlsurfApi.findFolderByPath(cwd);
+      if (!folder?.id) {
+        this.events.onWorkerStatus("no_project");
+      }
+    } catch {
+      this.events.onWorkerStatus("no_project");
+    }
+  }
+  streamTerminalData(data) {
+    this.termStreamBuffer += data;
+    if (!this.termStreamTimer) {
+      this.termStreamTimer = setTimeout(() => {
+        if (this.termStreamBuffer) {
+          this.workerWs.sendTerminalData(this.termStreamBuffer);
+          this.termStreamBuffer = "";
+        }
+        this.termStreamTimer = null;
+      }, TERM_STREAM_INTERVAL_MS);
+    }
+  }
+  // ─── Shutdown ───────────────────────────────────
+  async shutdown() {
+    await this.bridge.endSession();
+    this.ptyManager?.kill();
+    this.ptyManager = null;
+    this.workerWs.disconnect();
+    if (this.termStreamTimer) {
+      clearTimeout(this.termStreamTimer);
+      this.termStreamTimer = null;
+    }
+  }
+}
+process.stdout?.on?.("error", () => {
+});
+process.stderr?.on?.("error", () => {
+});
+process.on("uncaughtException", (err) => {
+  if (err.message === "write EPIPE") return;
+  try {
+    console.error("[uncaught]", err);
+  } catch {
+  }
+});
+function log(...args) {
+  try {
+    console.log(...args);
+  } catch {
+  }
+}
+let mainWindow = null;
+const orchestrator = new Orchestrator(
+  getSettingsDir(),
+  {
+    onPtyData: (data) => mainWindow?.webContents.send("pty:data", data),
+    onPtyExit: (code) => mainWindow?.webContents.send("pty:exit", code),
+    onWorkerStatus: (status) => mainWindow?.webContents.send("worker:status", status),
+    onWorkerMessage: (message) => mainWindow?.webContents.send("worker:message", message),
+    onWorkerRegistered: (data) => mainWindow?.webContents.send("worker:registered", data),
+    onCwdChanged: () => mainWindow?.webContents.send("app:cwdChanged")
+  }
+);
+function createWindow() {
+  mainWindow = new electron.BrowserWindow({
+    width: 1400,
+    height: 900,
+    minWidth: 600,
+    minHeight: 400,
+    title: "ctlsurf-worker",
+    titleBarStyle: "hiddenInset",
+    icon: path.join(__dirname, "../../resources/icon.png"),
+    webPreferences: {
+      preload: path.join(__dirname, "../preload/index.js"),
+      contextIsolation: true,
+      nodeIntegration: false,
+      webviewTag: true
+    }
+  });
+  if (process.env.ELECTRON_RENDERER_URL) {
+    mainWindow.loadURL(process.env.ELECTRON_RENDERER_URL);
+  } else {
+    mainWindow.loadFile(path.join(__dirname, "../renderer/index.html"));
+  }
+  mainWindow.on("closed", () => {
+    mainWindow = null;
+  });
+}
+electron.ipcMain.handle("pty:spawn", async (_event, agent, cwd) => {
+  await orchestrator.spawnAgent(agent, cwd);
+  return { ok: true };
+});
+electron.ipcMain.handle("pty:write", (_event, data) => {
+  orchestrator.writePty(data);
+});
+electron.ipcMain.handle("pty:resize", (_event, cols, rows) => {
+  orchestrator.resizePty(cols, rows);
+});
+electron.ipcMain.handle("pty:kill", async () => {
+  await orchestrator.killAgent();
+});
+electron.ipcMain.handle("agents:list", () => getBuiltinAgents());
+electron.ipcMain.handle("agents:default", () => getDefaultAgent());
+electron.ipcMain.handle("app:homePath", () => electron.app.getPath("home"));
+electron.ipcMain.handle("app:cwd", () => process.env.CTLSURF_WORKER_CWD || process.cwd());
+electron.ipcMain.handle("app:browseCwd", async () => {
+  if (!mainWindow) return null;
+  const result = await electron.dialog.showOpenDialog(mainWindow, {
+    properties: ["openDirectory"],
+    title: "Select project directory",
+    defaultPath: orchestrator.cwd || process.env.HOME || "/"
+  });
+  if (result.canceled || !result.filePaths[0]) return null;
+  return result.filePaths[0];
+});
+electron.ipcMain.handle("fs:readDir", async (_event, dirPath) => {
+  try {
+    const entries = await fs.promises.readdir(dirPath, { withFileTypes: true });
+    return entries.filter((e) => !e.name.startsWith(".")).map((e) => ({
+      name: e.name,
+      path: path.join(dirPath, e.name),
+      isDirectory: e.isDirectory()
+    })).sort((a, b) => {
+      if (a.isDirectory !== b.isDirectory) return a.isDirectory ? -1 : 1;
+      return a.name.localeCompare(b.name);
+    });
+  } catch {
+    return [];
+  }
+});
+electron.ipcMain.handle("fs:readFile", async (_event, filePath) => {
+  try {
+    const content = await fs.promises.readFile(filePath, "utf-8");
+    return { ok: true, content };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+});
+electron.ipcMain.handle("fs:writeFile", async (_event, filePath, content) => {
+  try {
+    await fs.promises.writeFile(filePath, content, "utf-8");
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+});
+electron.ipcMain.handle("worker:getStatus", () => orchestrator.workerWs.status);
+electron.ipcMain.handle("worker:getWorkerId", () => orchestrator.workerWs.currentWorkerId);
+electron.ipcMain.handle("worker:createProject", async () => {
+  const currentCwd = orchestrator.cwd;
+  if (!currentCwd || !orchestrator.ctlsurfApi.getApiKey()) {
+    return { ok: false, error: "No cwd or API key" };
+  }
+  try {
+    const folderName = currentCwd.split("/").filter(Boolean).pop() || "project";
+    const folder = await orchestrator.ctlsurfApi.createFolder({
+      name: folderName,
+      root_path: currentCwd
+    });
+    await orchestrator.ctlsurfApi.createPage({
+      title: folderName,
+      folder_id: folder.id,
+      cwd: currentCwd,
+      tags: ["project"]
+    });
+    if (orchestrator.agent) {
+      orchestrator.connectWorkerWs(orchestrator.agent, currentCwd);
+    }
+    log(`[worker] Created project: ${folderName} (${folder.id})`);
+    return { ok: true, folder_id: folder.id };
+  } catch (err) {
+    log("[worker] Failed to create project:", err.message);
+    return { ok: false, error: err.message };
+  }
+});
+electron.ipcMain.handle("worker:getWebviewInfo", async () => {
+  const profile = orchestrator.getActiveProfile();
+  const baseUrl = profile.baseUrl || process.env.CTLSURF_BASE_URL || "https://app.ctlsurf.com";
+  const frontendUrl = baseUrl.includes("localhost:8000") ? baseUrl.replace(":8000", ":88") : baseUrl;
+  if (!orchestrator.ctlsurfApi.getApiKey()) {
+    return { frontendUrl: `${frontendUrl}?embed=1`, authenticated: false };
+  }
+  try {
+    const { code } = await orchestrator.ctlsurfApi.getAuthCode();
+    let pageUrl = `${frontendUrl}?embed=1&_code=${encodeURIComponent(code)}`;
+    const currentCwd = orchestrator.cwd;
+    if (currentCwd) {
+      try {
+        let folder = null;
+        try {
+          folder = await orchestrator.ctlsurfApi.findFolderByPath(currentCwd);
+        } catch {
+        }
+        if (!folder) {
+          try {
+            const { execSync } = require("child_process");
+            const gitRemote = execSync("git remote get-url origin", { cwd: currentCwd, encoding: "utf-8" }).trim();
+            if (gitRemote) {
+              folder = await orchestrator.ctlsurfApi.findFolderByGitRemote(gitRemote);
+            }
+          } catch {
+          }
+        }
+        if (folder?.id) {
+          const pages = await orchestrator.ctlsurfApi.getFolderPages(folder.id);
+          const rootPage = pages?.find((p) => !p.parent_id);
+          if (rootPage?.id) {
+            pageUrl = `${frontendUrl}/page/${rootPage.id}?embed=1&_code=${encodeURIComponent(code)}`;
+          }
+        }
+      } catch {
+      }
+    }
+    return { frontendUrl, pageUrl, authenticated: true };
+  } catch (err) {
+    log("[worker] Failed to exchange tokens:", err.message);
+    return { frontendUrl: `${frontendUrl}?embed=1`, authenticated: false };
+  }
+});
+electron.ipcMain.handle("profiles:list", () => orchestrator.listProfiles());
+electron.ipcMain.handle("profiles:get", (_event, id) => orchestrator.getProfile(id));
+electron.ipcMain.handle("profiles:save", (_event, id, data) => {
+  orchestrator.saveProfile(id, data);
+  return { ok: true };
+});
+electron.ipcMain.handle("profiles:switch", (_event, id) => orchestrator.switchProfile(id));
+electron.ipcMain.handle("profiles:delete", (_event, id) => orchestrator.deleteProfile(id));
+electron.ipcMain.handle("settings:get", (_event, key) => {
+  const profile = orchestrator.getActiveProfile();
+  if (key === "ctlsurfApiKey") return profile.apiKey ? "***configured***" : null;
+  if (key === "ctlsurfBaseUrl") return profile.baseUrl || null;
+  if (key === "ctlsurfDataspacePageId") return profile.dataspacePageId || null;
+  return null;
+});
+electron.ipcMain.handle("settings:set", (_event, key, value) => {
+  const settings = orchestrator.settingsData;
+  const profile = settings.profiles[settings.activeProfile];
+  if (!profile) return { ok: false };
+  if (key === "ctlsurfApiKey") profile.apiKey = value;
+  else if (key === "ctlsurfBaseUrl") profile.baseUrl = value;
+  else if (key === "ctlsurfDataspacePageId") profile.dataspacePageId = value;
+  orchestrator.saveSettings();
+  orchestrator.applyProfile(profile);
+  if (key === "ctlsurfApiKey" && orchestrator.agent && orchestrator.cwd) {
+    orchestrator.workerWs.disconnect();
+    orchestrator.connectWorkerWs(orchestrator.agent, orchestrator.cwd);
+  }
+  return { ok: true };
+});
+electron.ipcMain.handle("settings:getAll", () => {
+  const profile = orchestrator.getActiveProfile();
+  return {
+    ctlsurfApiKey: profile.apiKey ? "***configured***" : null,
+    ctlsurfDataspacePageId: profile.dataspacePageId || null,
+    activeProfile: orchestrator.settingsData.activeProfile
+  };
+});
+electron.app.whenReady().then(() => {
+  if (process.platform === "darwin" && electron.app.dock) {
+    const iconPath = path.join(__dirname, "../../resources/icon.png");
+    try {
+      const { nativeImage } = require("electron");
+      electron.app.dock.setIcon(nativeImage.createFromPath(iconPath));
+    } catch {
+    }
+  }
+  orchestrator.loadSettings();
+  createWindow();
+});
+electron.app.on("window-all-closed", () => {
+  orchestrator.shutdown();
+  electron.app.quit();
+});
+electron.app.on("activate", () => {
+  if (electron.BrowserWindow.getAllWindows().length === 0) {
+    createWindow();
+  }
+});