typeclaw 0.10.0 → 0.11.1

package/src/cli/prompt-pem.ts

@@ -0,0 +1,113 @@
+import { readFile } from 'node:fs/promises'
+import { createInterface, type Interface } from 'node:readline'
+
+import { log } from '@clack/prompts'
+
+const BEGIN_MARKER = '-----BEGIN'
+const END_MARKER_RE = /^-----END [A-Z0-9 ]*PRIVATE KEY-----\s*$/
+const END_MARKER_INLINE_RE = /-----END [A-Z0-9 ]*PRIVATE KEY-----/
+
+export const CANCEL_SYMBOL = Symbol('cancel')
+
+export type ReadLineFn = () => Promise<string | typeof CANCEL_SYMBOL>
+
+export async function promptPrivateKeyPem(message: string): Promise<string | typeof CANCEL_SYMBOL> {
+  log.step(message)
+  log.message('Paste the PEM (including BEGIN/END lines), a path to a .pem file, or an escaped PEM.')
+
+  const reader = createStdinLineReader()
+  try {
+    const raw = await readPrivateKeyFromLines(reader.next)
+    if (raw === CANCEL_SYMBOL) return CANCEL_SYMBOL
+    return await resolvePrivateKeyInput(raw)
+  } finally {
+    reader.close()
+  }
+}
+
+/**
+ * Read a PEM block (or single-line value) using `readLine`.
+ *
+ * A line starting with `-----BEGIN` switches into block mode, accumulating
+ * until a line matches `-----END ... PRIVATE KEY-----`. Otherwise the first
+ * non-empty line is returned verbatim (path or escaped PEM). Leading blank
+ * lines are skipped so a stray Enter does not abort the prompt.
+ */
+export async function readPrivateKeyFromLines(readLine: ReadLineFn): Promise<string | typeof CANCEL_SYMBOL> {
+  let first: string
+  while (true) {
+    const line = await readLine()
+    if (line === CANCEL_SYMBOL) return CANCEL_SYMBOL
+    if (line.trim().length > 0) {
+      first = line
+      break
+    }
+  }
+
+  if (!first.trimStart().startsWith(BEGIN_MARKER)) return first.trim()
+
+  // Escaped-PEM pasted as one line (contains both BEGIN and END markers and
+  // no real newlines) bypasses block mode entirely.
+  if (END_MARKER_INLINE_RE.test(first)) return first.trim()
+
+  const lines: string[] = [first.trimEnd()]
+  while (true) {
+    const line = await readLine()
+    if (line === CANCEL_SYMBOL) return CANCEL_SYMBOL
+    const trimmed = line.trimEnd()
+    lines.push(trimmed)
+    if (END_MARKER_RE.test(trimmed)) break
+  }
+  return `${lines.join('\n')}\n`
+}
+
+export async function resolvePrivateKeyInput(input: string): Promise<string> {
+  const unescaped = input.includes('\\n') && !input.includes('\n') ? input.replace(/\\n/g, '\n') : input
+  if (unescaped.includes('-----BEGIN') && unescaped.includes('PRIVATE KEY-----')) return unescaped
+  return await readFile(input, 'utf8')
+}
+
+type StdinLineReader = {
+  next: ReadLineFn
+  close: () => void
+}
+
+function createStdinLineReader(): StdinLineReader {
+  return createReadlineLineReader(process.stdin)
+}
+
+export function createReadlineLineReader(input: NodeJS.ReadableStream): StdinLineReader {
+  const rl: Interface = createInterface({ input, terminal: false })
+  const queue: string[] = []
+  const waiters: ((value: string | typeof CANCEL_SYMBOL) => void)[] = []
+  let closed = false
+
+  rl.on('line', (line) => {
+    const waiter = waiters.shift()
+    if (waiter) waiter(line)
+    else queue.push(line)
+  })
+  rl.on('close', () => {
+    closed = true
+    for (const w of waiters.splice(0)) w(CANCEL_SYMBOL)
+  })
+
+  const next: ReadLineFn = () =>
+    new Promise((resolve) => {
+      const queued = queue.shift()
+      if (queued !== undefined) {
+        resolve(queued)
+        return
+      }
+      if (closed) {
+        resolve(CANCEL_SYMBOL)
+        return
+      }
+      waiters.push(resolve)
+    })
+
+  return {
+    next,
+    close: () => rl.close(),
+  }
+}

package/src/cli/run.ts

@@ -49,21 +49,40 @@ export const run = defineCommand({
       initialPrompt: args.prompt,
     })
 
-    const onSignal = () => {
-      stop()
-      process.exit(0)
+    const exit = (code: number): void => {
+      process.exit(code)
+    }
+    const onSignal = (): void => {
+      void shutdown({ stop, exit })
     }
     process.once('SIGINT', onSignal)
     process.once('SIGTERM', onSignal)
 
     if (tuiPromise) {
       await tuiPromise
-      stop()
-      process.exit(0)
+      await shutdown({ stop, exit })
     }
   },
 })
 
+// Awaits `stop()` BEFORE exiting so async teardown side-effects (channel
+// adapter teardown, in particular GitHub webhook deregistration) actually
+// complete. The previous code called `stop()` without awaiting and then
+// `process.exit(0)` synchronously, so the in-process DELETE /repos/.../hooks/
+// requests never went out and webhooks survived `typeclaw stop` (which
+// `docker stop`s the container → SIGTERM).
+export async function shutdown(deps: {
+  stop: () => void | Promise<void>
+  exit: (code: number) => void
+}): Promise<void> {
+  try {
+    await deps.stop()
+    deps.exit(0)
+  } catch {
+    deps.exit(1)
+  }
+}
+
 function resolveAttachTui({
   tui,
   noTui,

package/src/cli/tui.ts

@@ -25,16 +25,40 @@ export const tui = defineCommand({
     },
   },
   async run({ args }) {
-    const url = args.url ?? (await defaultUrl())
-    const tui = createTui({
-      url,
-      ...(args.prompt !== undefined ? { initialPrompt: args.prompt } : {}),
-      expectedVersion: CLI_VERSION,
-      onVersionMismatch: (info) => {
-        process.stderr.write(`${formatVersionMismatchWarning(info)}\n`)
-      },
-    })
-    await tui.run()
+    const resolveUrl: () => Promise<string> = args.url !== undefined ? async () => args.url as string : defaultUrl
+
+    let initialPrompt: string | undefined = args.prompt
+    let attempt = 0
+    const RECONNECT_MAX_ATTEMPTS = 30
+    const RECONNECT_BACKOFF_MS = 1_000
+
+    while (true) {
+      const url = await resolveUrl()
+      const tui = createTui({
+        url,
+        ...(initialPrompt !== undefined ? { initialPrompt } : {}),
+        expectedVersion: CLI_VERSION,
+        onVersionMismatch: (info) => {
+          process.stderr.write(`${formatVersionMismatchWarning(info)}\n`)
+        },
+      })
+      const outcome = await tui.run()
+      if (!outcome.lostConnection) return
+      // The TUI lost its WS post-handshake (container restart, network blip,
+      // hostd hiccup). Re-resolve the URL because the host port can change
+      // across container lifecycles (see resolveHostPort), then reconnect.
+      // The initial prompt is intentionally cleared after the first cycle:
+      // on a reconnect, the agent is resuming the same session — replaying
+      // the prompt would re-send it to the LLM.
+      initialPrompt = undefined
+      attempt += 1
+      if (attempt > RECONNECT_MAX_ATTEMPTS) {
+        console.error(errorLine(`disconnected; gave up after ${RECONNECT_MAX_ATTEMPTS} reconnect attempts`))
+        process.exit(1)
+      }
+      process.stderr.write(`reconnecting (attempt ${attempt}/${RECONNECT_MAX_ATTEMPTS})...\n`)
+      await new Promise((resolve) => setTimeout(resolve, RECONNECT_BACKOFF_MS))
+    }
   },
 })