@phenx-inc/ctlsurf 0.11.0 → 0.12.0

package/out/renderer/assets/{liquid-BrrN4uul.js → liquid-COSMe9Uf.js}

@@ -1,4 +1,4 @@
-import { l as languages } from "./index-BDlCPzCG.js";
+import { l as languages } from "./index-kkG56aKv.js";
 const EMPTY_ELEMENTS = [
   "area",
   "base",

package/out/renderer/assets/{lspLanguageFeatures-Bhdn2Eqy.js → lspLanguageFeatures-CXGfrtzl.js}

@@ -1,4 +1,4 @@
-import { R as Range$1, l as languages, e as editor, U as Uri, M as MarkerSeverity } from "./index-BDlCPzCG.js";
+import { R as Range$1, l as languages, e as editor, U as Uri, M as MarkerSeverity } from "./index-kkG56aKv.js";
 var DocumentUri;
 (function(DocumentUri2) {
   function is(value) {

package/out/renderer/assets/{mdx-DJo-gax4.js → mdx-RfS44T-L.js}

@@ -1,4 +1,4 @@
-import { l as languages } from "./index-BDlCPzCG.js";
+import { l as languages } from "./index-kkG56aKv.js";
 const conf = {
   comments: {
     blockComment: ["{/*", "*/}"]

package/out/renderer/assets/{python-DYHeg5b2.js → python-DFSWKHUu.js}

@@ -1,4 +1,4 @@
-import { l as languages } from "./index-BDlCPzCG.js";
+import { l as languages } from "./index-kkG56aKv.js";
 const conf = {
   comments: {
     lineComment: "#",

package/out/renderer/assets/{razor-Cqcks14K.js → razor-DtH2_uvo.js}

@@ -1,4 +1,4 @@
-import { l as languages } from "./index-BDlCPzCG.js";
+import { l as languages } from "./index-kkG56aKv.js";
 const EMPTY_ELEMENTS = [
   "area",
   "base",

package/out/renderer/assets/{tsMode-YTLgCayh.js → tsMode-BYIQ-S9Z.js}

@@ -1,4 +1,4 @@
-import { c as createWebWorker, e as editor, U as Uri, a as MarkerTag, M as MarkerSeverity, l as languages, t as typescriptDefaults, R as Range } from "./index-BDlCPzCG.js";
+import { c as createWebWorker, e as editor, U as Uri, a as MarkerTag, M as MarkerSeverity, l as languages, t as typescriptDefaults, R as Range } from "./index-kkG56aKv.js";
 class WorkerManager {
   constructor(_modeId, _defaults) {
     this._modeId = _modeId;

package/out/renderer/assets/{typescript-oxBn_Vcw.js → typescript-HhQUr1Rb.js}

@@ -1,4 +1,4 @@
-import { l as languages } from "./index-BDlCPzCG.js";
+import { l as languages } from "./index-kkG56aKv.js";
 const conf = {
   wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
   comments: {

package/out/renderer/assets/{xml-BEqGMCTc.js → xml-KuhgdKfD.js}

@@ -1,4 +1,4 @@
-import { l as languages } from "./index-BDlCPzCG.js";
+import { l as languages } from "./index-kkG56aKv.js";
 const conf = {
   comments: {
     blockComment: ["<!--", "-->"]

package/out/renderer/assets/{yaml-BGSrk5HC.js → yaml-W_kzCFH7.js}

@@ -1,4 +1,4 @@
-import { l as languages } from "./index-BDlCPzCG.js";
+import { l as languages } from "./index-kkG56aKv.js";
 const conf = {
   comments: {
     lineComment: "#"

package/out/renderer/index.html

@@ -49,8 +49,8 @@
       color: #565f89;
     }
   </style>
-  <script type="module" crossorigin src="./assets/index-BDlCPzCG.js"></script>
-  <link rel="stylesheet" crossorigin href="./assets/index-CGHeDwZa.css">
+  <script type="module" crossorigin src="./assets/index-kkG56aKv.js"></script>
+  <link rel="stylesheet" crossorigin href="./assets/index-BL9njXIL.css">
 </head>
 <body>
   <div id="boot-splash">

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phenx-inc/ctlsurf",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "Agent-agnostic terminal and desktop app for ctlsurf — run Claude Code, Codex, or any coding agent with live session logging and remote control",
   "main": "out/main/index.js",
   "bin": {

package/src/main/agents.ts

@@ -76,6 +76,14 @@ export function getDefaultAgent(): AgentConfig {
   return getAvailableAgents()[0]
 }
 
+// A remote agent runs over SSH (see ssh.ts). Its byte stream still flows
+// through the PTY — so the always-on agent-state monitor drives the dock
+// indicator — but its session files live on the remote box, so it must stay out
+// of local-only plumbing (transcript tailing, the ctlsurf worker socket).
+export function isRemoteAgent(agent: AgentConfig): boolean {
+  return agent.id.startsWith('remote-')
+}
+
 export function isCodingAgent(agent: AgentConfig): boolean {
-  return agent.id !== 'shell'
+  return agent.id !== 'shell' && !isRemoteAgent(agent)
 }

package/src/main/ctlsurfApi.ts

@@ -90,6 +90,13 @@ export class CtlsurfApi {
     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(): Promise<Array<{ id: string; name: string; root_path?: string; git_remote?: string }>> {
+    const folders = await this.request('GET', '/folders')
+    return Array.isArray(folders) ? folders : []
+  }
+
   // ─── Workers ────────────────────────────────────────
 
   async getAuthCode(): Promise<{ code: string }> {

package/src/main/index.ts

@@ -25,6 +25,9 @@ import { AgentConfig, getDefaultAgent, getAvailableAgents } from './agents'
 import { getSettingsDir } from './settingsDir'
 import { Orchestrator } from './orchestrator'
 import { AttentionController } from './agentState'
+import { listSshHosts, getRecentHosts, addRecentHost, probeRemote, buildRemoteAgent, type RemoteAction } from './ssh'
+
+const SETTINGS_DIR = getSettingsDir(true)
 
 let mainWindow: BrowserWindow | null = null
 
@@ -201,7 +204,7 @@ function stopAttention(): void {
 // ─── Orchestrator (shared logic) ──────────────────
 
 const orchestrator = new Orchestrator(
-  getSettingsDir(true),
+  SETTINGS_DIR,
   {
     onPtyData: (tabId, data) => mainWindow?.webContents.send('pty:data', tabId, data),
     onPtyExit: (tabId, code) => mainWindow?.webContents.send('pty:exit', tabId, code),
@@ -298,6 +301,56 @@ ipcMain.handle('pty:setActiveTab', (_event, tabId: string) => {
 ipcMain.handle('agents:list', () => getAvailableAgents())
 ipcMain.handle('agents:default', () => getDefaultAgent())
 
+// ─── Remote (SSH) ─────────────────────────────────
+
+// Hosts to offer: recently-used targets first, then ~/.ssh/config aliases.
+ipcMain.handle('ssh:listHosts', () => ({
+  configHosts: listSshHosts(),
+  recents: getRecentHosts(SETTINGS_DIR),
+}))
+
+// Non-interactive reachability + tmux probe (key-auth hosts only).
+ipcMain.handle('ssh:probe', (_event, target: string) => probeRemote(target))
+
+// Build the ssh-backed AgentConfig for a chosen connect action.
+ipcMain.handle('ssh:buildAgent', (_event, target: string, action: RemoteAction, agentCmd?: string) =>
+  buildRemoteAgent({ target, action, agentCmd }),
+)
+
+// Remember a target as most-recently-used (no secrets stored — just the host).
+ipcMain.handle('ssh:addRecent', (_event, target: string) => {
+  addRecentHost(SETTINGS_DIR, target)
+  return { ok: true }
+})
+
+// Stash an in-app password for the next remote spawn to `target`. Held only in
+// memory (auto-expires), injected once into ssh's prompt, then dropped.
+ipcMain.handle('ssh:setPassword', (_event, target: string, password: string) => {
+  orchestrator.setPendingSshPassword(target, password)
+  return { ok: true }
+})
+
+// ─── ctlsurf project selection (for remote sessions) ──
+
+// List existing ctlsurf projects (folders) to pick from.
+ipcMain.handle('ctlsurf:listProjects', async () => {
+  if (!orchestrator.ctlsurfApi.getApiKey()) return { ok: false, projects: [], error: 'No ctlsurf API key configured' }
+  try {
+    const folders = await orchestrator.ctlsurfApi.listFolders()
+    const projects = folders
+      .filter((f) => f && f.id && f.root_path)
+      .map((f) => ({ id: f.id, name: f.name || '(unnamed)', root_path: f.root_path as string }))
+    return { ok: true, projects }
+  } catch (err: any) {
+    return { ok: false, projects: [], error: err?.message || 'Failed to list projects' }
+  }
+})
+
+// Bind the active (remote) tab to a chosen project by its root_path.
+ipcMain.handle('ctlsurf:bindProject', (_event, rootPath: string) =>
+  orchestrator.bindActiveTabToProject(rootPath),
+)
+
 ipcMain.handle('app:homePath', () => app.getPath('home'))
 ipcMain.handle('app:cwd', () => process.env.CTLSURF_WORKER_CWD || process.cwd())
 ipcMain.handle('app:projectName', () => orchestrator.projectName)
@@ -442,7 +495,8 @@ ipcMain.handle('worker:getWebviewInfo', async () => {
   try {
     const { code } = await orchestrator.ctlsurfApi.getAuthCode()
     let pageUrl = `${frontendUrl}?embed=1&_code=${encodeURIComponent(code)}`
-    const currentCwd = orchestrator.cwd
+    // Prefer the active tab's bound project (remote sessions), else the local cwd.
+    const currentCwd = orchestrator.getActiveTabProjectPath() || orchestrator.cwd
 
     if (currentCwd) {
       try {
@@ -548,7 +602,8 @@ ipcMain.handle('tracking:set', async (_event, enabled: boolean) => {
 // ─── Tickets IPC ──────────────────────────────────
 
 ipcMain.handle('tickets:project', () => {
-  const cwd = orchestrator.getActiveTabCwd()
+  // Use the bound project path for remote sessions, else the local cwd.
+  const cwd = orchestrator.getActiveTabProjectPath()
   return { cwd, name: cwd ? cwd.split('/').filter(Boolean).pop() || cwd : null }
 })
 ipcMain.handle('tickets:add', async (_event, input: {

package/src/main/orchestrator.ts

@@ -3,7 +3,8 @@ import fs from 'fs'
 import os from 'os'
 
 import { PtyManager } from './pty'
-import { AgentConfig, isCodingAgent } from './agents'
+import { AgentConfig, isCodingAgent, isRemoteAgent } from './agents'
+import { stripAnsiSeq, isPasswordPrompt } from './ssh'
 import { CtlsurfApi } from './ctlsurfApi'
 import { ConversationBridge } from './bridge'
 import { TranscriptTailer, supportsTranscriptLogging, readLatestAssistantReply } from './transcripts'
@@ -62,6 +63,10 @@ interface TabState {
   ptyManager: PtyManager
   agent: AgentConfig
   cwd: string
+  // For remote sessions bound to a ctlsurf project: the project's root_path,
+  // used in place of the (meaningless) local cwd for project-scoped work like
+  // tickets. Set by bindActiveTabToProject.
+  projectRootPath?: string
   termStreamBuffer: string
   termStreamTimer: ReturnType<typeof setTimeout> | null
 }
@@ -108,6 +113,10 @@ export class Orchestrator {
   private currentProjectName: string | null = null
   private transcriptTailer: TranscriptTailer | null = null
   private readonly stateMonitor: AgentStateMonitor
+  // 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.
+  private readonly pendingSshPasswords = new Map<string, string>()
+  private readonly pendingSshPasswordTimers = new Map<string, ReturnType<typeof setTimeout>>()
 
   constructor(settingsDir: string, events: OrchestratorEvents) {
     this.settingsDir = settingsDir
@@ -455,6 +464,50 @@ export class Orchestrator {
 
   // ─── 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: string, password: string): void {
+    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)
+    }, 120_000))
+  }
+
+  private consumePendingSshPassword(target: string): string | undefined {
+    const pw = this.pendingSshPasswords.get(target)
+    if (pw === undefined) return undefined
+    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.
+  private armPasswordInjector(ptyManager: PtyManager, password: string): void {
+    let pw: string | null = password
+    let tail = ''
+    const giveUp = setTimeout(() => { pw = null; tail = '' }, 30_000)
+    ptyManager.onData((data: string) => {
+      if (pw === null) return
+      tail = (tail + stripAnsiSeq(data)).slice(-200)
+      if (isPasswordPrompt(tail)) {
+        log('[ssh] password prompt detected — injecting in-app password (one-shot)')
+        ptyManager.write(pw + '\r')
+        pw = null
+        tail = ''
+        clearTimeout(giveUp)
+      }
+    })
+  }
+
   async spawnAgent(tabId: string, agent: AgentConfig, cwd: string, opts?: { trackTime?: boolean }): Promise<void> {
     // Kill existing PTY on this tab if any
     const existing = this.tabs.get(tabId)
@@ -479,6 +532,18 @@ export class Orchestrator {
     // exactly when the dock indicator is most useful.
     this.stateMonitor.trackTab(tabId, agent.id, cwd)
 
+    // Remote (SSH) tab with an in-app password waiting: feed it to ssh's prompt
+    // once, directly over the PTY. The password is consumed here (removed from
+    // the pending map) and dropped after injection — never logged or persisted.
+    if (isRemoteAgent(agent)) {
+      const target = agent.args[1] // args are ['-t', target, ...]
+      const pw = target ? this.consumePendingSshPassword(target) : undefined
+      if (pw) {
+        log(`[ssh] remote spawn for ${target}: in-app password armed (will inject at prompt)`)
+        this.armPasswordInjector(ptyManager, pw)
+      }
+    }
+
     ptyManager.onData((data: string) => {
       this.events.onPtyData(tabId, data)
       this.timeTracker.recordActivity(tabId)
@@ -607,8 +672,19 @@ export class Orchestrator {
     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(): string | null {
+    if (!this.activeTabId) return null
+    const tab = this.tabs.get(this.activeTabId)
+    if (!tab) return null
+    return tab.projectRootPath ?? tab.cwd
+  }
+
   async addTicketForActiveTab(input: TicketInput): Promise<{ ok: boolean; error?: string }> {
-    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' }
@@ -617,7 +693,7 @@ export class Orchestrator {
   }
 
   async updateTicketForActiveTab(rowId: string, input: TicketInput): Promise<{ ok: boolean; error?: string }> {
-    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' }
@@ -626,7 +702,7 @@ export class Orchestrator {
   }
 
   async listTicketsForActiveTab(): Promise<{ ok: boolean; tickets: import('./ticketStore').Ticket[]; error?: string }> {
-    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' }
@@ -636,6 +712,31 @@ export class Orchestrator {
 
   // ─── 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: string): { ok: boolean; error?: string } {
+    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}`)
+    // Remember the binding so project-scoped work (tickets) targets the chosen
+    // project instead of the remote tab's local cwd.
+    tab.projectRootPath = rootPath
+    this.stopNoProjectPolling()
+    this.workerWs.disconnect()
+    this.connectWorkerWs(tab.agent, rootPath)
+    // Tell the renderer the active project changed so the tickets + ctlsurf
+    // panels re-query against the bound project (they refresh on this event).
+    this.events.onCwdChanged()
+    return { ok: true }
+  }
+
   connectWorkerWs(agent: AgentConfig, cwd: string): void {
     const profile = this.getActiveProfile()
     const apiKey = profile.apiKey || process.env.CTLSURF_API_KEY