@phenx-inc/ctlsurf 0.1.0

package/out/renderer/assets/yaml-DNWPIf1s.js

@@ -0,0 +1,200 @@
+import { l as languages } from "./index-pZmE1QXB.js";
+const conf = {
+  comments: {
+    lineComment: "#"
+  },
+  brackets: [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"]
+  ],
+  autoClosingPairs: [
+    { open: "{", close: "}" },
+    { open: "[", close: "]" },
+    { open: "(", close: ")" },
+    { open: '"', close: '"' },
+    { open: "'", close: "'" }
+  ],
+  surroundingPairs: [
+    { open: "{", close: "}" },
+    { open: "[", close: "]" },
+    { open: "(", close: ")" },
+    { open: '"', close: '"' },
+    { open: "'", close: "'" }
+  ],
+  folding: {
+    offSide: true
+  },
+  onEnterRules: [
+    {
+      beforeText: /:\s*$/,
+      action: {
+        indentAction: languages.IndentAction.Indent
+      }
+    }
+  ]
+};
+const language = {
+  tokenPostfix: ".yaml",
+  brackets: [
+    { token: "delimiter.bracket", open: "{", close: "}" },
+    { token: "delimiter.square", open: "[", close: "]" }
+  ],
+  keywords: ["true", "True", "TRUE", "false", "False", "FALSE", "null", "Null", "Null", "~"],
+  numberInteger: /(?:0|[+-]?[0-9]+)/,
+  numberFloat: /(?:0|[+-]?[0-9]+)(?:\.[0-9]+)?(?:e[-+][1-9][0-9]*)?/,
+  numberOctal: /0o[0-7]+/,
+  numberHex: /0x[0-9a-fA-F]+/,
+  numberInfinity: /[+-]?\.(?:inf|Inf|INF)/,
+  numberNaN: /\.(?:nan|Nan|NAN)/,
+  numberDate: /\d{4}-\d\d-\d\d([Tt ]\d\d:\d\d:\d\d(\.\d+)?(( ?[+-]\d\d?(:\d\d)?)|Z)?)?/,
+  escapes: /\\(?:[btnfr\\"']|[0-7][0-7]?|[0-3][0-7]{2})/,
+  tokenizer: {
+    root: [
+      { include: "@whitespace" },
+      { include: "@comment" },
+      // Directive
+      [/%[^ ]+.*$/, "meta.directive"],
+      // Document Markers
+      [/---/, "operators.directivesEnd"],
+      [/\.{3}/, "operators.documentEnd"],
+      // Block Structure Indicators
+      [/[-?:](?= )/, "operators"],
+      { include: "@anchor" },
+      { include: "@tagHandle" },
+      { include: "@flowCollections" },
+      { include: "@blockStyle" },
+      // Numbers
+      [/@numberInteger(?![ \t]*\S+)/, "number"],
+      [/@numberFloat(?![ \t]*\S+)/, "number.float"],
+      [/@numberOctal(?![ \t]*\S+)/, "number.octal"],
+      [/@numberHex(?![ \t]*\S+)/, "number.hex"],
+      [/@numberInfinity(?![ \t]*\S+)/, "number.infinity"],
+      [/@numberNaN(?![ \t]*\S+)/, "number.nan"],
+      [/@numberDate(?![ \t]*\S+)/, "number.date"],
+      // Key:Value pair
+      [/(".*?"|'.*?'|[^#'"]*?)([ \t]*)(:)( |$)/, ["type", "white", "operators", "white"]],
+      { include: "@flowScalars" },
+      // String nodes
+      [
+        /.+?(?=(\s+#|$))/,
+        {
+          cases: {
+            "@keywords": "keyword",
+            "@default": "string"
+          }
+        }
+      ]
+    ],
+    // Flow Collection: Flow Mapping
+    object: [
+      { include: "@whitespace" },
+      { include: "@comment" },
+      // Flow Mapping termination
+      [/\}/, "@brackets", "@pop"],
+      // Flow Mapping delimiter
+      [/,/, "delimiter.comma"],
+      // Flow Mapping Key:Value delimiter
+      [/:(?= )/, "operators"],
+      // Flow Mapping Key:Value key
+      [/(?:".*?"|'.*?'|[^,\{\[]+?)(?=: )/, "type"],
+      // Start Flow Style
+      { include: "@flowCollections" },
+      { include: "@flowScalars" },
+      // Scalar Data types
+      { include: "@tagHandle" },
+      { include: "@anchor" },
+      { include: "@flowNumber" },
+      // Other value (keyword or string)
+      [
+        /[^\},]+/,
+        {
+          cases: {
+            "@keywords": "keyword",
+            "@default": "string"
+          }
+        }
+      ]
+    ],
+    // Flow Collection: Flow Sequence
+    array: [
+      { include: "@whitespace" },
+      { include: "@comment" },
+      // Flow Sequence termination
+      [/\]/, "@brackets", "@pop"],
+      // Flow Sequence delimiter
+      [/,/, "delimiter.comma"],
+      // Start Flow Style
+      { include: "@flowCollections" },
+      { include: "@flowScalars" },
+      // Scalar Data types
+      { include: "@tagHandle" },
+      { include: "@anchor" },
+      { include: "@flowNumber" },
+      // Other value (keyword or string)
+      [
+        /[^\],]+/,
+        {
+          cases: {
+            "@keywords": "keyword",
+            "@default": "string"
+          }
+        }
+      ]
+    ],
+    // First line of a Block Style
+    multiString: [[/^( +).+$/, "string", "@multiStringContinued.$1"]],
+    // Further lines of a Block Style
+    //   Workaround for indentation detection
+    multiStringContinued: [
+      [
+        /^( *).+$/,
+        {
+          cases: {
+            "$1==$S2": "string",
+            "@default": { token: "@rematch", next: "@popall" }
+          }
+        }
+      ]
+    ],
+    whitespace: [[/[ \t\r\n]+/, "white"]],
+    // Only line comments
+    comment: [[/#.*$/, "comment"]],
+    // Start Flow Collections
+    flowCollections: [
+      [/\[/, "@brackets", "@array"],
+      [/\{/, "@brackets", "@object"]
+    ],
+    // Start Flow Scalars (quoted strings)
+    flowScalars: [
+      [/"([^"\\]|\\.)*$/, "string.invalid"],
+      [/'([^'\\]|\\.)*$/, "string.invalid"],
+      [/'[^']*'/, "string"],
+      [/"/, "string", "@doubleQuotedString"]
+    ],
+    doubleQuotedString: [
+      [/[^\\"]+/, "string"],
+      [/@escapes/, "string.escape"],
+      [/\\./, "string.escape.invalid"],
+      [/"/, "string", "@pop"]
+    ],
+    // Start Block Scalar
+    blockStyle: [[/[>|][0-9]*[+-]?$/, "operators", "@multiString"]],
+    // Numbers in Flow Collections (terminate with ,]})
+    flowNumber: [
+      [/@numberInteger(?=[ \t]*[,\]\}])/, "number"],
+      [/@numberFloat(?=[ \t]*[,\]\}])/, "number.float"],
+      [/@numberOctal(?=[ \t]*[,\]\}])/, "number.octal"],
+      [/@numberHex(?=[ \t]*[,\]\}])/, "number.hex"],
+      [/@numberInfinity(?=[ \t]*[,\]\}])/, "number.infinity"],
+      [/@numberNaN(?=[ \t]*[,\]\}])/, "number.nan"],
+      [/@numberDate(?=[ \t]*[,\]\}])/, "number.date"]
+    ],
+    tagHandle: [[/\![^ ]*/, "tag"]],
+    anchor: [[/[&*][^ ]+/, "namespace"]]
+  }
+};
+export {
+  conf,
+  language
+};

package/out/renderer/index.html

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>ctlsurf-worker</title>
+  <script type="module" crossorigin src="./assets/index-pZmE1QXB.js"></script>
+  <link rel="stylesheet" crossorigin href="./assets/index-CJ6RsQWP.css">
+</head>
+<body>
+  <div id="root"></div>
+</body>
+</html>

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@phenx-inc/ctlsurf",
+  "version": "0.1.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": {
+    "ctlsurf": "./bin/ctlsurf-worker.js",
+    "ctlsurf-worker": "./bin/ctlsurf-worker.js"
+  },
+  "files": [
+    "bin/",
+    "out/",
+    "resources/",
+    "src/",
+    "package.json",
+    "electron-vite.config.ts",
+    "tsconfig*.json"
+  ],
+  "scripts": {
+    "dev": "electron-vite dev",
+    "dev:terminal": "esbuild src/main/headless.ts --bundle --platform=node --target=node18 --format=esm --outfile=out/headless/index.mjs --external:node-pty --sourcemap && node out/headless/index.mjs",
+    "build": "electron-vite build && npm run build:headless",
+    "build:headless": "esbuild src/main/headless.ts --bundle --platform=node --target=node18 --format=esm --outfile=out/headless/index.mjs --external:node-pty --sourcemap",
+    "prepublishOnly": "npm run build",
+    "preview": "electron-vite preview",
+    "package": "electron-builder",
+    "postinstall": "node-gyp rebuild --directory=node_modules/node-pty 2>/dev/null || true"
+  },
+  "keywords": [
+    "ctlsurf",
+    "terminal",
+    "tui",
+    "coding-agent",
+    "claude-code",
+    "codex",
+    "electron",
+    "node-pty",
+    "xterm"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@monaco-editor/react": "^4.7.0",
+    "@xterm/addon-fit": "^0.10.0",
+    "@xterm/addon-web-links": "^0.11.0",
+    "@xterm/xterm": "^5.5.0",
+    "electron-store": "^10.0.0",
+    "esbuild": "^0.27.4",
+    "monaco-editor": "^0.55.1",
+    "node-pty": "^1.0.0"
+  },
+  "devDependencies": {
+    "@electron/rebuild": "^4.0.3",
+    "@types/node": "^22.15.0",
+    "@types/react": "^19.1.0",
+    "@types/react-dom": "^19.1.0",
+    "@vitejs/plugin-react": "^4.5.2",
+    "electron": "^35.0.0",
+    "electron-builder": "^25.1.8",
+    "electron-vite": "^3.1.0",
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0",
+    "typescript": "^5.8.3"
+  }
+}

package/src/main/agents.ts

@@ -0,0 +1,46 @@
+export interface AgentConfig {
+  id: string
+  name: string
+  command: string
+  args: string[]
+  description: string
+}
+
+function getShellCommand(): string {
+  if (process.platform === 'win32') return 'powershell.exe'
+  return process.env.SHELL || '/bin/zsh'
+}
+
+export function getBuiltinAgents(): AgentConfig[] {
+  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'
+    }
+  ]
+}
+
+export function getDefaultAgent(): AgentConfig {
+  return getBuiltinAgents()[0]
+}
+
+export function isCodingAgent(agent: AgentConfig): boolean {
+  return agent.id !== 'shell'
+}

package/src/main/bridge.ts

@@ -0,0 +1,180 @@
+import { CtlsurfApi } from './ctlsurfApi'
+
+/**
+ * Conversation Bridge
+ *
+ * Taps the pty output stream and logs chunks to a ctlsurf log block.
+ * Generic approach: buffers terminal output and flushes periodically.
+ */
+export class ConversationBridge {
+  private api: CtlsurfApi
+  private logBlockId: string | null = null
+  private pageId: string | null = null
+  private buffer: string = ''
+  private flushTimer: ReturnType<typeof setTimeout> | null = null
+  private flushIntervalMs: number = 3000 // flush every 3 seconds
+  private agentName: string = 'shell'
+  private sessionActive: boolean = false
+  private inputBuffer: string = ''
+
+  constructor(api: CtlsurfApi) {
+    this.api = api
+  }
+
+  /**
+   * Start a new logging session.
+   * Creates a log block on the given dataspace page.
+   */
+  async startSession(dataspacePageId: string, agentName: string, cwd: string): Promise<void> {
+    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 = 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: 1000
+        }
+      })
+      this.logBlockId = block.id
+      this.sessionActive = true
+
+      // Log session start
+      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: any) {
+      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: string): void {
+    if (!this.sessionActive) return
+
+    this.buffer += data
+
+    // Reset flush timer
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer)
+    }
+    this.flushTimer = setTimeout(() => this.flush(), this.flushIntervalMs)
+  }
+
+  /**
+   * Feed user input data into the bridge.
+   */
+  feedInput(data: string): void {
+    if (!this.sessionActive) return
+    this.inputBuffer += data
+
+    // Detect Enter key (newline) — flush the input as a user prompt
+    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.
+   */
+  private async flush(): Promise<void> {
+    if (!this.logBlockId || this.buffer.length === 0) return
+
+    const chunk = this.buffer
+    this.buffer = ''
+
+    // Strip ANSI escape codes for cleaner log entries
+    const cleaned = stripAnsi(chunk)
+    if (cleaned.trim().length === 0) return
+
+    try {
+      await this.api.appendLog(this.logBlockId, 'terminal_output', cleaned)
+    } catch (err: any) {
+      console.error(`[bridge] Failed to append log:`, err.message)
+    }
+  }
+
+  /**
+   * Log a specific entry immediately.
+   */
+  private async logEntry(action: string, message: string, data?: Record<string, unknown>): Promise<void> {
+    if (!this.logBlockId) return
+    try {
+      await this.api.appendLog(this.logBlockId, action, message, data)
+    } catch (err: any) {
+      console.error(`[bridge] Failed to log entry:`, err.message)
+    }
+  }
+
+  /**
+   * End the current session.
+   */
+  async endSession(exitCode?: number): Promise<void> {
+    if (!this.sessionActive || !this.logBlockId) return
+
+    // Flush remaining buffer
+    await this.flush()
+
+    try {
+      await this.api.appendLog(this.logBlockId, 'session_end', `Session ended (exit code: ${exitCode ?? 'unknown'})`, {
+        agent: this.agentName,
+        exitCode
+      })
+    } catch (err: any) {
+      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')
+  }
+}
+
+/**
+ * Strip ANSI escape codes from terminal output.
+ */
+function stripAnsi(str: string): string {
+  return str
+    // CSI sequences (e.g. \x1b[0m, \x1b[?2004h, \x1b[1;32m)
+    .replace(/\x1b\[[\x30-\x3f]*[\x20-\x2f]*[\x40-\x7e]/g, '')
+    // OSC sequences (e.g. \x1b]0;title\x07)
+    .replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, '')
+    // Other escape sequences (charset, keypad mode, etc.)
+    .replace(/\x1b[^[\]](.|$)/g, '')
+    // Remaining single ESC
+    .replace(/\x1b/g, '')
+    // Carriage returns
+    .replace(/\r/g, '')
+    // Control characters except newline/tab
+    // eslint-disable-next-line no-control-regex
+    .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, '')
+}

package/src/main/ctlsurfApi.ts

@@ -0,0 +1,142 @@
+const CTLSURF_BASE_URL = 'https://app.ctlsurf.com/api'
+
+export class CtlsurfApi {
+  private baseUrl: string
+  private apiKey: string | null = null
+
+  constructor(baseUrl?: string) {
+    this.baseUrl = baseUrl || CTLSURF_BASE_URL
+  }
+
+  setApiKey(key: string): void {
+    this.apiKey = key
+  }
+
+  setBaseUrl(url: string): void {
+    this.baseUrl = url.endsWith('/api') ? url : `${url}/api`
+  }
+
+  getApiKey(): string | null {
+    return this.apiKey
+  }
+
+  private headers(): Record<string, string> {
+    const h: Record<string, string> = { 'Content-Type': 'application/json' }
+    if (this.apiKey) {
+      h['Authorization'] = `Bearer ${this.apiKey}`
+    }
+    return h
+  }
+
+  private async request(method: string, path: string, body?: unknown): Promise<any> {
+    const url = `${this.baseUrl}${path}`
+    const opts: RequestInit = {
+      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} ${path}: ${res.status} ${text}`)
+    }
+    return res.json()
+  }
+
+  // ─── Pages ───────────────────────────────────────────
+
+  async createPage(params: {
+    title: string
+    type?: string
+    parent_id?: string
+    folder_id?: string
+    cwd?: string
+    tags?: string[]
+  }): Promise<any> {
+    return this.request('POST', '/pages', params)
+  }
+
+  async findPageByRootPath(rootPath: string): Promise<any> {
+    return this.request('POST', '/pages/find-by-root-path', { root_path: rootPath })
+  }
+
+  // ─── Blocks ──────────────────────────────────────────
+
+  async createBlock(pageId: string, params: {
+    type: string
+    title?: string
+    props?: Record<string, unknown>
+  }): Promise<any> {
+    return this.request('POST', `/blocks/page/${pageId}`, params)
+  }
+
+  async getBlock(blockId: string): Promise<any> {
+    return this.request('GET', `/blocks/${blockId}`)
+  }
+
+  async updateBlock(blockId: string, params: {
+    props?: Record<string, unknown>
+    title?: string
+  }): Promise<any> {
+    return this.request('PUT', `/blocks/${blockId}`, params)
+  }
+
+  // ─── Folders ────────────────────────────────────────
+
+  async createFolder(params: { name: string; root_path: string }): Promise<any> {
+    return this.request('POST', '/folders', params)
+  }
+
+  // ─── Workers ────────────────────────────────────────
+
+  async getAuthCode(): Promise<{ code: string }> {
+    return this.request('POST', '/workers/token-exchange')
+  }
+
+  async findFolderByPath(rootPath: string): Promise<any> {
+    return this.request('POST', '/folders/find-by-path', { root_path: rootPath })
+  }
+
+  async getFolderPages(folderId: string): Promise<any[]> {
+    const folder = await this.request('GET', `/folders/${folderId}`)
+    return folder?.pages || []
+  }
+
+  async findFolderByGitRemote(gitRemote: string): Promise<any> {
+    // Search folders by listing all and matching git_remote
+    const folders = await this.request('GET', '/folders')
+    return folders?.find((f: any) => f.git_remote === gitRemote || f.root_path === gitRemote) || null
+  }
+
+  // ─── Log convenience ─────────────────────────────────
+
+  async appendLog(blockId: string, action: string, message: string, data?: Record<string, unknown>): Promise<any> {
+    // Read-modify-write: get current entries, append, put back
+    const block = await this.getBlock(blockId)
+    const props = block.props || {}
+    const entries = Array.isArray(props.entries) ? [...props.entries] : []
+    const maxEntries = props.max_entries || 1000
+
+    const entry: Record<string, unknown> = {
+      _id: `log_${entries.length}`,
+      _timestamp: new Date().toISOString(),
+      action,
+      message
+    }
+    if (data) {
+      entry.data = data
+    }
+
+    entries.push(entry)
+
+    // Trim oldest if over max
+    const trimmed = entries.length > maxEntries ? entries.slice(-maxEntries) : entries
+
+    return this.updateBlock(blockId, {
+      props: { ...props, entries: trimmed }
+    })
+  }
+}

package/src/main/detectMode.ts

@@ -0,0 +1,17 @@
+export function detectMode(argv: string[]): 'gui' | 'terminal' {
+  if (argv.includes('--terminal')) return 'terminal'
+  if (argv.includes('--desktop')) return 'gui'
+
+  // SSH session → terminal
+  if (process.env.SSH_CONNECTION || process.env.SSH_TTY) return 'terminal'
+
+  // Docker / container → terminal
+  if (process.env.container || process.env.DOCKER_CONTAINER) return 'terminal'
+
+  // Linux: no display → terminal
+  if (process.platform === 'linux') {
+    if (!process.env.DISPLAY && !process.env.WAYLAND_DISPLAY) return 'terminal'
+  }
+
+  return 'gui'
+}