@phenx-inc/ctlsurf 0.11.0 → 0.12.1

package/out/headless/index.mjs

@@ -5471,7 +5471,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "@phenx-inc/ctlsurf",
-      version: "0.11.0",
+      version: "0.12.1",
       description: "Agent-agnostic terminal and desktop app for ctlsurf \u2014 run Claude Code, Codex, or any coding agent with live session logging and remote control",
       main: "out/main/index.js",
       bin: {
@@ -5673,8 +5673,20 @@ function getAvailableAgents() {
   const shell = all.filter((a) => !isCodingAgent(a));
   return [...coding, ...shell];
 }
+function isRemoteAgent(agent) {
+  return agent.id.startsWith("remote-");
+}
 function isCodingAgent(agent) {
-  return agent.id !== "shell";
+  return agent.id !== "shell" && !isRemoteAgent(agent);
+}
+
+// src/main/ssh.ts
+function stripAnsiSeq(s) {
+  return s.replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, "");
+}
+var PASSWORD_PROMPT_RE = /(?:password|passphrase)[^\n]*:\s*$/i;
+function isPasswordPrompt(tail) {
+  return PASSWORD_PROMPT_RE.test(tail);
 }
 
 // src/main/ctlsurfApi.ts
@@ -5738,6 +5750,12 @@ var CtlsurfApi = class {
   async createFolder(params) {
     return this.request("POST", "/folders", params);
   }
+  // All folders (projects) the API key can see. Used to let a remote session
+  // pick which ctlsurf project to bind to.
+  async listFolders() {
+    const folders = await this.request("GET", "/folders");
+    return Array.isArray(folders) ? folders : [];
+  }
   // ─── Workers ────────────────────────────────────────
   async getAuthCode() {
     return this.request("POST", "/workers/token-exchange");
@@ -7448,6 +7466,10 @@ var Orchestrator = class {
   currentProjectName = null;
   transcriptTailer = null;
   stateMonitor;
+  // One-shot SSH passwords entered in-app, keyed by target. Held only in memory
+  // until the next remote spawn for that target consumes them — never persisted.
+  pendingSshPasswords = /* @__PURE__ */ new Map();
+  pendingSshPasswordTimers = /* @__PURE__ */ new Map();
   constructor(settingsDir, events) {
     this.settingsDir = settingsDir;
     this.events = events;
@@ -7743,6 +7765,53 @@ var Orchestrator = class {
     return { ok: true };
   }
   // ─── PTY & Agent (multi-tab) ─────────────────────
+  // Stash an in-app SSH password for the next remote spawn to `target`. Kept
+  // only in memory and auto-expired so a typed-but-unused password doesn't
+  // linger. Never written to disk or logged.
+  setPendingSshPassword(target, password) {
+    if (!target || !password) return;
+    const prev = this.pendingSshPasswordTimers.get(target);
+    if (prev) clearTimeout(prev);
+    this.pendingSshPasswords.set(target, password);
+    this.pendingSshPasswordTimers.set(target, setTimeout(() => {
+      this.pendingSshPasswords.delete(target);
+      this.pendingSshPasswordTimers.delete(target);
+    }, 12e4));
+  }
+  consumePendingSshPassword(target) {
+    const pw = this.pendingSshPasswords.get(target);
+    if (pw === void 0) return void 0;
+    this.pendingSshPasswords.delete(target);
+    const timer = this.pendingSshPasswordTimers.get(target);
+    if (timer) {
+      clearTimeout(timer);
+      this.pendingSshPasswordTimers.delete(target);
+    }
+    return pw;
+  }
+  // Watch a freshly-spawned ssh PTY for its password/passphrase prompt and write
+  // the password once. We write straight to the PTY (not through writePty) so it
+  // never reaches the bridge/chat-logging path; ssh keeps echo off, so it never
+  // renders to the terminal or scrollback either.
+  armPasswordInjector(ptyManager, password) {
+    let pw = password;
+    let tail = "";
+    const giveUp = setTimeout(() => {
+      pw = null;
+      tail = "";
+    }, 3e4);
+    ptyManager.onData((data) => {
+      if (pw === null) return;
+      tail = (tail + stripAnsiSeq(data)).slice(-200);
+      if (isPasswordPrompt(tail)) {
+        log("[ssh] password prompt detected \u2014 injecting in-app password (one-shot)");
+        ptyManager.write(pw + "\r");
+        pw = null;
+        tail = "";
+        clearTimeout(giveUp);
+      }
+    });
+  }
   async spawnAgent(tabId, agent, cwd, opts) {
     const existing = this.tabs.get(tabId);
     if (existing) {
@@ -7761,6 +7830,14 @@ var Orchestrator = class {
     const tab = { ptyManager, agent, cwd, termStreamBuffer: "", termStreamTimer: null };
     this.tabs.set(tabId, tab);
     this.stateMonitor.trackTab(tabId, agent.id, cwd);
+    if (isRemoteAgent(agent)) {
+      const target = agent.args[1];
+      const pw = target ? this.consumePendingSshPassword(target) : void 0;
+      if (pw) {
+        log(`[ssh] remote spawn for ${target}: in-app password armed (will inject at prompt)`);
+        this.armPasswordInjector(ptyManager, pw);
+      }
+    }
     ptyManager.onData((data) => {
       this.events.onPtyData(tabId, data);
       this.timeTracker.recordActivity(tabId);
@@ -7834,12 +7911,16 @@ var Orchestrator = class {
     }
   }
   setActiveTab(tabId) {
+    const prevProjectPath = this.getActiveTabProjectPath();
     this.activeTabId = tabId;
     const tab = this.tabs.get(tabId);
     if (tab) {
       this.currentAgent = tab.agent;
       this.currentCwd = tab.cwd;
     }
+    if (this.getActiveTabProjectPath() !== prevProjectPath) {
+      this.events.onCwdChanged();
+    }
   }
   getTabIds() {
     return [...this.tabs.keys()];
@@ -7872,8 +7953,18 @@ var Orchestrator = class {
     if (!this.activeTabId) return null;
     return this.tabs.get(this.activeTabId)?.cwd ?? null;
   }
+  /**
+   * Path used to resolve the active tab's ctlsurf project. For a remote session
+   * bound to a project this is the project's root_path; otherwise the local cwd.
+   */
+  getActiveTabProjectPath() {
+    if (!this.activeTabId) return null;
+    const tab = this.tabs.get(this.activeTabId);
+    if (!tab) return null;
+    return tab.projectRootPath ?? tab.cwd;
+  }
   async addTicketForActiveTab(input) {
-    const cwd = this.getActiveTabCwd();
+    const cwd = this.getActiveTabProjectPath();
     if (!cwd) return { ok: false, error: "No active terminal tab" };
     if (!this.ctlsurfApi.getApiKey()) {
       return { ok: false, error: "ctlsurf API key not configured" };
@@ -7881,7 +7972,7 @@ var Orchestrator = class {
     return this.ticketStore.addTicket(cwd, input);
   }
   async updateTicketForActiveTab(rowId, input) {
-    const cwd = this.getActiveTabCwd();
+    const cwd = this.getActiveTabProjectPath();
     if (!cwd) return { ok: false, error: "No active terminal tab" };
     if (!this.ctlsurfApi.getApiKey()) {
       return { ok: false, error: "ctlsurf API key not configured" };
@@ -7889,7 +7980,7 @@ var Orchestrator = class {
     return this.ticketStore.updateTicket(cwd, rowId, input);
   }
   async listTicketsForActiveTab() {
-    const cwd = this.getActiveTabCwd();
+    const cwd = this.getActiveTabProjectPath();
     if (!cwd) return { ok: false, tickets: [], error: "No active terminal tab" };
     if (!this.ctlsurfApi.getApiKey()) {
       return { ok: false, tickets: [], error: "ctlsurf API key not configured" };
@@ -7897,6 +7988,25 @@ var Orchestrator = class {
     return this.ticketStore.listTickets(cwd);
   }
   // ─── Worker WebSocket ───────────────────────────
+  // Bind the active tab (typically a remote SSH session, whose local cwd is
+  // meaningless) to a chosen ctlsurf project. We register the worker WS using
+  // the project's root_path so the backend resolves that folder — the same
+  // mechanism create-project relies on. This lights up chat logging, tickets,
+  // remote-control, and the project header/panel for the remote session.
+  bindActiveTabToProject(rootPath) {
+    if (!rootPath) return { ok: false, error: "No project path" };
+    if (!this.activeTabId) return { ok: false, error: "No active tab" };
+    const tab = this.tabs.get(this.activeTabId);
+    if (!tab) return { ok: false, error: "No active tab" };
+    if (!this.ctlsurfApi.getApiKey()) return { ok: false, error: "No ctlsurf API key configured" };
+    log(`[ctlsurf] Binding tab agent="${tab.agent.name}" to project root_path=${rootPath}`);
+    tab.projectRootPath = rootPath;
+    this.stopNoProjectPolling();
+    this.workerWs.disconnect();
+    this.connectWorkerWs(tab.agent, rootPath);
+    this.events.onCwdChanged();
+    return { ok: true };
+  }
   connectWorkerWs(agent, cwd) {
     const profile = this.getActiveProfile();
     const apiKey = profile.apiKey || process.env.CTLSURF_API_KEY;