@phenx-inc/ctlsurf 0.1.0

package/out/headless/index.mjs

@@ -0,0 +1,1364 @@
+#!/usr/bin/env node
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// node_modules/electron/index.js
+var require_electron = __commonJS({
+  "node_modules/electron/index.js"(exports, module) {
+    var fs2 = __require("fs");
+    var path3 = __require("path");
+    var pathFile = path3.join(__dirname, "path.txt");
+    function getElectronPath() {
+      let executablePath;
+      if (fs2.existsSync(pathFile)) {
+        executablePath = fs2.readFileSync(pathFile, "utf-8");
+      }
+      if (process.env.ELECTRON_OVERRIDE_DIST_PATH) {
+        return path3.join(process.env.ELECTRON_OVERRIDE_DIST_PATH, executablePath || "electron");
+      }
+      if (executablePath) {
+        return path3.join(__dirname, "dist", executablePath);
+      } else {
+        throw new Error("Electron failed to install correctly, please delete node_modules/electron and try installing again");
+      }
+    }
+    module.exports = getElectronPath();
+  }
+});
+
+// src/main/orchestrator.ts
+import path from "path";
+import fs from "fs";
+import os2 from "os";
+
+// src/main/pty.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var pty = require2("node-pty");
+var PtyManager = class {
+  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);
+  }
+};
+
+// src/main/agents.ts
+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 isCodingAgent(agent) {
+  return agent.id !== "shell";
+}
+
+// src/main/ctlsurfApi.ts
+var CTLSURF_BASE_URL = "https://app.ctlsurf.com/api";
+var CtlsurfApi = class {
+  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, path3, body) {
+    const url = `${this.baseUrl}${path3}`;
+    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} ${path3}: ${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 }
+    });
+  }
+};
+
+// src/main/bridge.ts
+var ConversationBridge = class {
+  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} \u2014 ${timestamp} \u2014 ${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, "");
+}
+
+// src/main/workerWs.ts
+import os from "os";
+import crypto from "crypto";
+function log(...args) {
+  try {
+    console.log(...args);
+  } catch {
+  }
+}
+var HEARTBEAT_INTERVAL_MS = 3e4;
+var RECONNECT_DELAY_MS = 5e3;
+var MAX_RECONNECT_DELAY_MS = 6e4;
+var WorkerWsClient = class {
+  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("[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("[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(`[worker-ws] Connecting to ${url.replace(/token=.*/, "token=***")}...`);
+    try {
+      this.ws = new WebSocket(url);
+    } catch (err) {
+      log("[worker-ws] Failed to create WebSocket:", err);
+      this.scheduleReconnect();
+      return;
+    }
+    this.ws.onopen = () => {
+      log("[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("[worker-ws] Failed to parse message:", err);
+      }
+    };
+    this.ws.onclose = (event) => {
+      log(`[worker-ws] Disconnected: ${event.code} ${event.reason}`);
+      this.ws = null;
+      this.clearHeartbeat();
+      this.setStatus("disconnected");
+      if (this.shouldReconnect) {
+        this.scheduleReconnect();
+      }
+    };
+    this.ws.onerror = () => {
+      log("[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("[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;
+    }
+  }
+};
+
+// src/main/orchestrator.ts
+function log2(...args) {
+  try {
+    console.log(...args);
+  } catch {
+  }
+}
+var DEFAULT_PROFILES = {
+  production: {
+    name: "Production",
+    apiKey: "",
+    baseUrl: "https://app.ctlsurf.com",
+    dataspacePageId: ""
+  }
+};
+var TERM_STREAM_INTERVAL_MS = 50;
+var Orchestrator = class {
+  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) => {
+        log2(`[worker-ws] Status: ${status}`);
+        events.onWorkerStatus(status);
+      },
+      onMessage: (message) => {
+        log2(`[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) => {
+        log2(`[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);
+    log2(`[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();
+          log2("[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) {
+      log2("[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) {
+      log2("[worker-ws] No API key, skipping WS connect");
+      return;
+    }
+    this.workerWs.connect({
+      machine: os2.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;
+    }
+  }
+};
+
+// src/main/settingsDir.ts
+import path2 from "path";
+import os3 from "os";
+function getSettingsDir(useElectron) {
+  if (useElectron) {
+    const { app } = require_electron();
+    return app.getPath("userData");
+  }
+  if (process.platform === "darwin") {
+    return path2.join(os3.homedir(), "Library", "Application Support", "ctlsurf-worker");
+  }
+  return path2.join(
+    process.env.XDG_CONFIG_HOME || path2.join(os3.homedir(), ".config"),
+    "ctlsurf-worker"
+  );
+}
+
+// src/main/tui.ts
+var ESC = "\x1B";
+var CSI = `${ESC}[`;
+var BG_BAR = `${CSI}48;2;22;22;30m`;
+var FG_TITLE = `${CSI}38;2;192;202;245m`;
+var FG_DIM = `${CSI}38;2;86;95;137m`;
+var FG_ACCENT = `${CSI}38;2;122;162;247m`;
+var FG_GREEN = `${CSI}38;2;158;206;106m`;
+var FG_RED = `${CSI}38;2;247;118;142m`;
+var FG_YELLOW = `${CSI}38;2;224;175;104m`;
+var FG_WHITE = `${CSI}38;2;169;177;214m`;
+var BG_MODAL = `${CSI}48;2;31;35;53m`;
+var BG_SELECTED = `${CSI}48;2;42;43;61m`;
+var RESET = `${CSI}0m`;
+var Tui = class {
+  rows = 0;
+  cols = 0;
+  state = {
+    agentName: "",
+    cwd: "",
+    wsStatus: "disconnected",
+    workerId: null,
+    mode: "terminal"
+  };
+  constructor() {
+    this.rows = process.stdout.rows || 24;
+    this.cols = process.stdout.columns || 80;
+  }
+  /**
+   * Initialize the TUI: alternate screen, hide cursor reporting, set scroll region
+   */
+  init() {
+    this.write(`${CSI}?1049h`);
+    this.setScrollRegion();
+    this.moveToPtyArea();
+    this.drawTitleBar();
+    this.drawStatusBar();
+  }
+  /**
+   * Restore terminal to normal state
+   */
+  destroy() {
+    this.write(`${CSI}r`);
+    this.write(`${CSI}?1049l`);
+    this.write(`${CSI}?25h`);
+  }
+  /**
+   * Handle terminal resize
+   */
+  resize(cols, rows) {
+    this.cols = cols;
+    this.rows = rows;
+    this.setScrollRegion();
+    this.drawTitleBar();
+    this.drawStatusBar();
+    this.moveToPtyArea();
+  }
+  /**
+   * Get the PTY dimensions (main area minus title + status bars)
+   */
+  getPtySize() {
+    return {
+      cols: this.cols,
+      rows: Math.max(1, this.rows - 2)
+    };
+  }
+  /**
+   * Update state and redraw bars
+   */
+  update(partial) {
+    Object.assign(this.state, partial);
+    this.write(`${CSI}s`);
+    this.drawTitleBar();
+    this.drawStatusBar();
+    this.write(`${CSI}u`);
+  }
+  /**
+   * Write PTY output to the scroll region.
+   * Cursor is assumed to be in the PTY area already.
+   */
+  writePtyData(data) {
+    this.write(data);
+  }
+  /**
+   * Update the terminal window/tab title via OSC escape sequence.
+   * Works in passthrough mode (no chrome) — doesn't conflict with the agent's TUI.
+   */
+  setTerminalTitle(title) {
+    this.write(`${ESC}]0;${title}\x07`);
+  }
+  /**
+   * Build a title string from current state for the terminal tab.
+   */
+  updateTerminalTitle() {
+    const { agentName, wsStatus, cwd } = this.state;
+    const displayCwd = this.shortenPath(cwd);
+    const statusIcon = {
+      connected: "\u25CF",
+      connecting: "\u25CB",
+      disconnected: "\u25CB",
+      pending_approval: "\u25CB",
+      no_project: "\u25CB"
+    }[wsStatus] || "\u25CB";
+    const statusLabel = {
+      connected: "Connected",
+      connecting: "Connecting...",
+      disconnected: "Disconnected",
+      pending_approval: "Pending",
+      no_project: "No Project"
+    }[wsStatus] || wsStatus;
+    this.setTerminalTitle(`ctlsurf \xB7 ${agentName} \xB7 ${statusIcon} ${statusLabel} \xB7 ${displayCwd}`);
+  }
+  /**
+   * Show an interactive agent picker modal.
+   * Returns a promise that resolves with the selected agent index.
+   */
+  showAgentPicker(agents) {
+    return new Promise((resolve) => {
+      let selected = 0;
+      const modalWidth = 44;
+      const modalHeight = agents.length + 4;
+      const startCol = Math.max(1, Math.floor((this.cols - modalWidth) / 2));
+      const startRow = Math.max(1, Math.floor((this.rows - modalHeight) / 2));
+      this.write(`${CSI}?1049h`);
+      this.write(`${CSI}?25l`);
+      const drawModal = () => {
+        const topBorder = "\u250C" + "\u2500".repeat(modalWidth - 2) + "\u2510";
+        const botBorder = "\u2514" + "\u2500".repeat(modalWidth - 2) + "\u2518";
+        const emptyLine = "\u2502" + " ".repeat(modalWidth - 2) + "\u2502";
+        for (let r = 0; r < this.rows; r++) {
+          this.write(`${CSI}${r + 1};1H${BG_BAR}${CSI}2K${RESET}`);
+        }
+        const brand = "ctlsurf";
+        const brandCol = Math.max(1, Math.floor((this.cols - brand.length) / 2));
+        this.write(`${CSI}${startRow - 2};${brandCol}H${FG_ACCENT}${brand}${RESET}`);
+        this.write(`${CSI}${startRow};${startCol}H${BG_MODAL}${FG_DIM}${topBorder}${RESET}`);
+        const title = " Select Agent";
+        const titlePad = " ".repeat(Math.max(0, modalWidth - 2 - title.length));
+        this.write(`${CSI}${startRow + 1};${startCol}H${BG_MODAL}${FG_DIM}\u2502${RESET}${BG_MODAL}${FG_TITLE}${title}${titlePad}${FG_DIM}\u2502${RESET}`);
+        const sep = "\u251C" + "\u2500".repeat(modalWidth - 2) + "\u2524";
+        this.write(`${CSI}${startRow + 2};${startCol}H${BG_MODAL}${FG_DIM}${sep}${RESET}`);
+        for (let i = 0; i < agents.length; i++) {
+          const agent = agents[i];
+          const row = startRow + 3 + i;
+          const isSelected = i === selected;
+          const bg = isSelected ? BG_SELECTED : BG_MODAL;
+          const pointer = isSelected ? `${FG_ACCENT}\u25B8 ` : "  ";
+          const nameFg = isSelected ? FG_ACCENT : FG_WHITE;
+          const descFg = FG_DIM;
+          const nameStr = agent.name;
+          const descStr = agent.description ? ` ${FG_DIM}\u2014 ${agent.description.slice(0, 20)}` : "";
+          const content = `${pointer}${nameFg}${nameStr}${descStr}`;
+          const contentLen = (isSelected ? 2 : 2) + nameStr.length + (agent.description ? 3 + Math.min(20, agent.description.length) : 0);
+          const pad = " ".repeat(Math.max(0, modalWidth - 2 - contentLen));
+          this.write(`${CSI}${row};${startCol}H${bg}${FG_DIM}\u2502${RESET}${bg}${content}${pad}${RESET}${BG_MODAL}${FG_DIM}\u2502${RESET}`);
+        }
+        const botRow = startRow + 3 + agents.length;
+        this.write(`${CSI}${botRow};${startCol}H${BG_MODAL}${FG_DIM}${botBorder}${RESET}`);
+        const hint = "\u2191\u2193 navigate \xB7 Enter select \xB7 q quit";
+        const hintCol = Math.max(1, Math.floor((this.cols - hint.length) / 2));
+        this.write(`${CSI}${botRow + 2};${hintCol}H${FG_DIM}${hint}${RESET}`);
+      };
+      drawModal();
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+      }
+      process.stdin.resume();
+      const onKey = (data) => {
+        const key = data.toString();
+        if (key === "\x1B[A" || key === "k") {
+          selected = (selected - 1 + agents.length) % agents.length;
+          drawModal();
+        } else if (key === "\x1B[B" || key === "j") {
+          selected = (selected + 1) % agents.length;
+          drawModal();
+        } else if (key === "\r" || key === "\n") {
+          cleanup();
+          resolve(selected);
+        } else if (key === "q" || key === "\x1B" || key === "") {
+          cleanup();
+          this.write(`${CSI}?25h`);
+          this.write(`${CSI}?1049l`);
+          process.exit(0);
+        }
+      };
+      const cleanup = () => {
+        process.stdin.removeListener("data", onKey);
+        this.write(`${CSI}?25h`);
+      };
+      process.stdin.on("data", onKey);
+    });
+  }
+  // ─── Internal ───────────────────────────────────
+  write(data) {
+    try {
+      process.stdout.write(data);
+    } catch {
+    }
+  }
+  setScrollRegion() {
+    this.write(`${CSI}2;${this.rows - 1}r`);
+  }
+  moveToPtyArea() {
+    this.write(`${CSI}2;1H`);
+  }
+  drawTitleBar() {
+    const { agentName, cwd, wsStatus } = this.state;
+    this.write(`${CSI}1;1H`);
+    this.write(`${BG_BAR}${CSI}2K`);
+    const displayCwd = this.shortenPath(cwd);
+    const statusColor = {
+      connected: FG_GREEN,
+      connecting: FG_YELLOW,
+      disconnected: FG_RED,
+      pending_approval: FG_YELLOW,
+      no_project: FG_DIM
+    }[wsStatus] || FG_DIM;
+    const statusLabel = {
+      connected: "Connected",
+      connecting: "Connecting...",
+      disconnected: "Disconnected",
+      pending_approval: "Pending",
+      no_project: "No Project"
+    }[wsStatus] || wsStatus;
+    const wsIndicator = `${statusColor}\u25CF ${statusLabel}${RESET}${BG_BAR}`;
+    const left = ` ${FG_ACCENT}ctlsurf${RESET}${BG_BAR} ${FG_DIM}\u2502${RESET}${BG_BAR} ${FG_TITLE}${agentName || "starting..."}${RESET}${BG_BAR} ${FG_DIM}\u2502${RESET}${BG_BAR} ${FG_DIM}${displayCwd}${RESET}${BG_BAR}`;
+    const right = `${wsIndicator} ${RESET}${BG_BAR}`;
+    this.write(left);
+    const pad = Math.max(0, this.cols - this.visibleLen(left) - this.visibleLen(right));
+    this.write(" ".repeat(pad));
+    this.write(right);
+    this.write(RESET);
+  }
+  drawStatusBar() {
+    const { wsStatus, workerId, cwd } = this.state;
+    this.write(`${CSI}${this.rows};1H`);
+    this.write(`${BG_BAR}${CSI}2K`);
+    const statusColor = {
+      connected: FG_GREEN,
+      connecting: FG_YELLOW,
+      disconnected: FG_RED,
+      pending_approval: FG_YELLOW,
+      no_project: FG_DIM
+    }[wsStatus] || FG_DIM;
+    const statusDot = `${statusColor}\u25CF${RESET}${BG_BAR}`;
+    const statusLabel = {
+      connected: "Connected",
+      connecting: "Connecting...",
+      disconnected: "Disconnected",
+      pending_approval: "Pending Approval",
+      no_project: "No Project"
+    }[wsStatus] || wsStatus;
+    const displayCwd = this.shortenPath(cwd);
+    const left = ` ${statusDot} ${FG_DIM}${statusLabel}${RESET}${BG_BAR}`;
+    const right = `${FG_DIM}Ctrl+\\ exit${RESET}${BG_BAR} ${FG_DIM}${displayCwd} ${RESET}${BG_BAR}`;
+    this.write(left);
+    const pad = Math.max(0, this.cols - this.visibleLen(left) - this.visibleLen(right));
+    this.write(" ".repeat(pad));
+    this.write(right);
+    this.write(RESET);
+  }
+  shortenPath(p) {
+    if (!p) return "";
+    const home = process.env.HOME || "";
+    if (home && p.startsWith(home)) {
+      return "~" + p.slice(home.length);
+    }
+    return p;
+  }
+  visibleLen(s) {
+    return s.replace(/\x1b\[[^m]*m/g, "").length;
+  }
+};
+
+// src/main/headless.ts
+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 parseArgs(argv) {
+  const args = {
+    agent: null,
+    cwd: process.env.CTLSURF_WORKER_CWD || process.cwd(),
+    apiKey: null,
+    baseUrl: null,
+    profile: null
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    const next = argv[i + 1];
+    switch (arg) {
+      case "--agent":
+        args.agent = next;
+        i++;
+        break;
+      case "--cwd":
+        args.cwd = next;
+        i++;
+        break;
+      case "--api-key":
+        args.apiKey = next;
+        i++;
+        break;
+      case "--base-url":
+        args.baseUrl = next;
+        i++;
+        break;
+      case "--profile":
+        args.profile = next;
+        i++;
+        break;
+      case "--terminal":
+        break;
+      case "--desktop":
+        break;
+    }
+  }
+  return args;
+}
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const settingsDir = getSettingsDir(false);
+  const tui = new Tui();
+  const agents = getBuiltinAgents();
+  let agent;
+  if (args.agent) {
+    const found = agents.find((a) => a.id === args.agent);
+    agent = found || {
+      id: args.agent,
+      name: args.agent,
+      command: args.agent,
+      args: [],
+      description: `Custom agent: ${args.agent}`
+    };
+  } else {
+    const selectedIdx = await tui.showAgentPicker(agents);
+    agent = agents[selectedIdx];
+  }
+  tui.update({
+    agentName: agent.name,
+    cwd: args.cwd,
+    mode: "terminal"
+  });
+  tui.init();
+  const orchestrator = new Orchestrator(settingsDir, {
+    onPtyData: (data) => {
+      tui.writePtyData(data);
+    },
+    onPtyExit: (code) => {
+      tui.destroy();
+      console.log(`Agent exited with code ${code}`);
+      orchestrator.shutdown().then(() => process.exit(code));
+    },
+    onWorkerStatus: (status) => {
+      tui.update({ wsStatus: status });
+    },
+    onWorkerMessage: () => {
+    },
+    onWorkerRegistered: () => {
+      tui.update({ wsStatus: "connected" });
+    },
+    onCwdChanged: () => {
+      tui.update({ cwd: orchestrator.cwd || "" });
+    }
+  });
+  orchestrator.loadSettings();
+  if (args.profile) orchestrator.switchProfile(args.profile);
+  if (args.apiKey) orchestrator.overrideApiKey(args.apiKey);
+  if (args.baseUrl) orchestrator.overrideBaseUrl(args.baseUrl);
+  const ptySize = tui.getPtySize();
+  await orchestrator.spawnAgent(agent, args.cwd);
+  orchestrator.resizePty(ptySize.cols, ptySize.rows);
+  if (isCodingAgent(agent)) {
+    setTimeout(() => {
+      orchestrator.writePty("hello\r");
+    }, 1e3);
+  }
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on("data", (data) => {
+      const str = data.toString();
+      if (str === "") {
+        shutdown();
+        return;
+      }
+      orchestrator.writePty(str);
+    });
+  }
+  process.stdout.on("resize", () => {
+    const cols = process.stdout.columns || 80;
+    const rows = process.stdout.rows || 24;
+    tui.resize(cols, rows);
+    const size = tui.getPtySize();
+    orchestrator.resizePty(size.cols, size.rows);
+  });
+  const shutdown = async () => {
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(false);
+    }
+    tui.destroy();
+    await orchestrator.shutdown();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+main().catch((err) => {
+  process.stdout.write("\x1B[?1049l");
+  console.error("Fatal error:", err);
+  process.exit(1);
+});
+//# sourceMappingURL=index.mjs.map