typeclaw 0.1.4 → 0.1.5

package/src/tui/client.ts

@@ -2,9 +2,19 @@ import type { ClientMessage, ServerMessage } from '@/shared'
 
 export type Client = Awaited<ReturnType<typeof createClient>>
 
-export async function createClient(url: string) {
+export type CreateClientOptions = {
+  timeoutMs?: number
+}
+
+const DEFAULT_CONNECT_TIMEOUT_MS = 30_000
+
+export async function createClient(url: string, { timeoutMs = DEFAULT_CONNECT_TIMEOUT_MS }: CreateClientOptions = {}) {
   const ws = new WebSocket(url)
+  const displayUrl = redactUrl(url)
   const listeners = new Set<(msg: ServerMessage) => void>()
+  const closeListeners = new Set<() => void>()
+  const errorListeners = new Set<(err: unknown) => void>()
+  let closed = false
   // Buffer messages that arrive before any listener is registered. In-process
   // connections (typeclaw run's local tui) deliver the first server frame
   // before the caller has a chance to attach onMessage.
@@ -20,12 +30,43 @@ export async function createClient(url: string) {
   })
 
   ws.addEventListener('close', () => {
+    closed = true
     listeners.clear()
+    for (const fn of closeListeners) fn()
+    closeListeners.clear()
+  })
+
+  ws.addEventListener('error', (err) => {
+    for (const fn of errorListeners) fn(err)
   })
 
   await new Promise<void>((resolve, reject) => {
-    ws.addEventListener('open', () => resolve(), { once: true })
-    ws.addEventListener('error', (err) => reject(err), { once: true })
+    const timer = setTimeout(() => {
+      cleanup()
+      ws.close()
+      reject(new Error(`timed out connecting to ${displayUrl} after ${timeoutMs}ms`))
+    }, timeoutMs)
+    const cleanup = () => {
+      clearTimeout(timer)
+      ws.removeEventListener('open', onOpen)
+      ws.removeEventListener('error', onError)
+      ws.removeEventListener('close', onClose)
+    }
+    const onOpen = () => {
+      cleanup()
+      resolve()
+    }
+    const onError = (err: unknown) => {
+      cleanup()
+      reject(err)
+    }
+    const onClose = () => {
+      cleanup()
+      reject(new Error(`connection to ${displayUrl} closed before opening`))
+    }
+    ws.addEventListener('open', onOpen, { once: true })
+    ws.addEventListener('error', onError, { once: true })
+    ws.addEventListener('close', onClose, { once: true })
   })
 
   return {
@@ -37,9 +78,29 @@ export async function createClient(url: string) {
       }
       return () => listeners.delete(fn)
     },
-    onClose: (fn: () => void) => ws.addEventListener('close', fn),
-    onError: (fn: (err: unknown) => void) => ws.addEventListener('error', fn),
+    onClose: (fn: () => void) => {
+      if (closed) {
+        queueMicrotask(fn)
+        return () => {}
+      }
+      closeListeners.add(fn)
+      return () => closeListeners.delete(fn)
+    },
+    onError: (fn: (err: unknown) => void) => {
+      errorListeners.add(fn)
+      return () => errorListeners.delete(fn)
+    },
     send: (msg: ClientMessage) => ws.send(JSON.stringify(msg)),
     close: () => ws.close(),
   }
 }
+
+function redactUrl(url: string): string {
+  try {
+    const parsed = new URL(url)
+    if (parsed.searchParams.has('token')) parsed.searchParams.set('token', '<redacted>')
+    return parsed.toString()
+  } catch {
+    return url
+  }
+}

package/src/tui/index.ts

@@ -7,11 +7,14 @@ import { colors, editorTheme, markdownTheme } from './theme'
 export type ClientFactory = (url: string) => Promise<Client>
 export type TerminalFactory = () => Terminal
 
+const DEFAULT_HANDSHAKE_TIMEOUT_MS = 30_000
+
 export type TuiOptions = {
   url: string
   initialPrompt?: string
   createClient?: ClientFactory
   createTerminal?: TerminalFactory
+  handshakeTimeoutMs?: number
   exit?: (code: number) => void
 }
 
@@ -20,13 +23,15 @@ export function createTui({
   initialPrompt,
   createClient = createClientDefault,
   createTerminal = () => new ProcessTerminal(),
+  handshakeTimeoutMs = DEFAULT_HANDSHAKE_TIMEOUT_MS,
   exit = process.exit.bind(process),
 }: TuiOptions) {
   async function run(): Promise<void> {
     const terminal = createTerminal()
     const tui = new TUI(terminal)
+    const displayUrl = redactUrl(url)
 
-    const status = new Text(colors.dim(`connecting to ${url}...`), 0, 0)
+    const status = new Text(colors.dim(`connecting to ${displayUrl}...`), 0, 0)
     tui.addChild(status)
     tui.start()
     tui.requestRender()
@@ -39,14 +44,13 @@ export function createTui({
       throw err
     })
 
-    const sessionId = await new Promise<string>((resolve) => {
-      let off: (() => void) | undefined
-      off = client.onMessage((msg) => {
-        if (msg.type === 'connected') {
-          off?.()
-          resolve(msg.sessionId)
-        }
-      })
+    const sessionId = await waitForConnected(client, displayUrl, handshakeTimeoutMs).catch((err) => {
+      status.setText(colors.red(`connection error: ${err instanceof Error ? err.message : String(err)}`))
+      tui.requestRender()
+      client.close()
+      tui.stop()
+      exit(1)
+      throw err
     })
     status.setText(colors.dim(`session: ${sessionId}`))
     tui.requestRender()
@@ -223,3 +227,51 @@ export function createTui({
 
   return { run }
 }
+
+function redactUrl(url: string): string {
+  try {
+    const parsed = new URL(url)
+    if (parsed.searchParams.has('token')) parsed.searchParams.set('token', '<redacted>')
+    return parsed.toString()
+  } catch {
+    return url
+  }
+}
+
+async function waitForConnected(client: Client, url: string, timeoutMs: number): Promise<string> {
+  return await new Promise<string>((resolve, reject) => {
+    const timer = setTimeout(() => {
+      cleanup()
+      reject(new Error(`timed out waiting for connected message from ${url} after ${timeoutMs}ms`))
+    }, timeoutMs)
+    const cleanupFns: Array<() => void> = []
+    const cleanup = () => {
+      clearTimeout(timer)
+      for (const fn of cleanupFns.splice(0)) fn()
+    }
+    cleanupFns.push(
+      client.onMessage((msg) => {
+        if (msg.type === 'connected') {
+          cleanup()
+          resolve(msg.sessionId)
+        }
+        if (msg.type === 'error') {
+          cleanup()
+          reject(new Error(msg.message))
+        }
+      }),
+    )
+    cleanupFns.push(
+      client.onClose(() => {
+        cleanup()
+        reject(new Error(`connection to ${url} closed before the session was ready`))
+      }),
+    )
+    cleanupFns.push(
+      client.onError((err) => {
+        cleanup()
+        reject(err instanceof Error ? err : new Error(`connection to ${url} failed`))
+      }),
+    )
+  })
+}

package/typeclaw.schema.json

@@ -731,76 +731,100 @@
         }
       }
     },
-    "dockerfile": {
+    "docker": {
       "default": {
-        "ffmpeg": false,
-        "gh": true,
-        "python": true,
-        "tmux": true,
-        "append": []
+        "file": {
+          "ffmpeg": false,
+          "gh": true,
+          "python": true,
+          "tmux": true,
+          "append": []
+        }
       },
       "type": "object",
       "properties": {
-        "ffmpeg": {
-          "default": false,
-          "anyOf": [
-            {
-              "type": "boolean"
+        "file": {
+          "default": {
+            "ffmpeg": false,
+            "gh": true,
+            "python": true,
+            "tmux": true,
+            "append": []
+          },
+          "type": "object",
+          "properties": {
+            "ffmpeg": {
+              "default": false,
+              "anyOf": [
+                {
+                  "type": "boolean"
+                },
+                {
+                  "type": "string",
+                  "minLength": 1
+                }
+              ]
             },
-            {
-              "type": "string",
-              "minLength": 1
-            }
-          ]
-        },
-        "gh": {
-          "default": true,
-          "anyOf": [
-            {
-              "type": "boolean"
+            "gh": {
+              "default": true,
+              "anyOf": [
+                {
+                  "type": "boolean"
+                },
+                {
+                  "type": "string",
+                  "minLength": 1
+                }
+              ]
             },
-            {
-              "type": "string",
-              "minLength": 1
-            }
-          ]
-        },
-        "python": {
-          "default": true,
-          "type": "boolean"
-        },
-        "tmux": {
-          "default": true,
-          "anyOf": [
-            {
+            "python": {
+              "default": true,
               "type": "boolean"
             },
-            {
-              "type": "string",
-              "minLength": 1
+            "tmux": {
+              "default": true,
+              "anyOf": [
+                {
+                  "type": "boolean"
+                },
+                {
+                  "type": "string",
+                  "minLength": 1
+                }
+              ]
+            },
+            "append": {
+              "default": [],
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
             }
-          ]
-        },
-        "append": {
-          "default": [],
-          "type": "array",
-          "items": {
-            "type": "string"
           }
         }
       }
     },
-    "gitignore": {
+    "git": {
       "default": {
-        "append": []
+        "ignore": {
+          "append": []
+        }
       },
       "type": "object",
       "properties": {
-        "append": {
-          "default": [],
-          "type": "array",
-          "items": {
-            "type": "string"
+        "ignore": {
+          "default": {
+            "append": []
+          },
+          "type": "object",
+          "properties": {
+            "append": {
+              "default": [],
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            }
           }
         }
       }