kimaki 1.2.0 → 1.3.0

package/src/thread-reducer.ts

@@ -55,6 +55,7 @@ import {
 import { closePermission, hydratePermissions, showPermission, STATUS, type PendingPermission } from './permissions.ts'
 import { closeForm, formatAnswer, hydrateForms, showForm, withAnswer, type PendingForm } from './questions.ts'
 import { cancelQueued, deliverQueued, enqueueInput, hydrateQueue, promoteQueued, queuedItems, type PendingInput } from './queue.ts'
+import { MESSAGE_TOOL } from './system-prompt.ts'
 
 export type Turn = {
   startedAt: number
@@ -64,6 +65,14 @@ export type Turn = {
   tokens: number
   // `kimaki sleep` ran in this turn: the session wakes later, so the footer is silent.
   slept: boolean
+  // Message mode (Prefs.messageTool): a send_message call was shown in this turn.
+  messaged: boolean
+  // Message mode: the last hidden text, shown at the end if the turn sent no message.
+  unsent: string | null
+}
+
+function newTurn(at: number): Turn {
+  return { startedAt: at, model: null, agent: null, tokens: 0, slept: false, messaged: false, unsent: null }
 }
 
 export type Child = {
@@ -186,6 +195,8 @@ export type Prefs = {
   verbosity: Verbosity
   // "providerID/modelID" -> context window size in tokens.
   contextLimits: Readonly<Record<string, number>>
+  // `kimaki --message-tool`: Discord hides root plain text (kept for the TUI), only send_message shows.
+  messageTool: boolean
 }
 
 const RETRY_NOTICE_INTERVAL_MS = 10_000
@@ -281,6 +292,9 @@ function contextPercent({ turn, prefs }: { turn: Draft<Turn>; prefs: Prefs }): n
 
 // The footer closing the answer of `turn` at `at`.
 function emitFooter({ draft, prefs, emit, turn, at, notify }: Context & { turn: Draft<Turn>; at: number; notify: boolean }) {
+  // Message mode: a model that never called send_message would leave the user in silence.
+  if (!turn.messaged && turn.unsent) emit({ type: 'markdown', text: turn.unsent, blankLineBefore: draft.lastKind === 'tool' })
+  turn.unsent = null
   // No model step ran (a compaction-only execution): nothing to summarize.
   if (!turn.model) return
   // A child still runs: the answer comes later.
@@ -346,11 +360,11 @@ function applyRoot(context: Context & { event: V2Event }) {
       emit({ type: 'send', text: asSubtext(`Working directory changed to ${event.data.location.directory}`) })
       return
     case 'session.execution.started':
-      draft.turn ??= { startedAt: event.created, model: null, agent: null, tokens: 0, slept: false }
+      draft.turn ??= newTurn(event.created)
       return
     case 'session.step.started': {
       const model = { providerID: event.data.model.providerID, id: event.data.model.id }
-      draft.turn ??= { startedAt: event.created, model: null, agent: null, tokens: 0, slept: false }
+      draft.turn ??= newTurn(event.created)
       draft.turn.model = model
       draft.turn.agent = event.data.agent
       if (draft.bannerPending) emit({ type: 'send', text: formatBanner({ model: event.data.model, agent: event.data.agent }) })
@@ -373,6 +387,10 @@ function applyRoot(context: Context & { event: V2Event }) {
     case 'session.text.ended': {
       const text = event.data.text.trim()
       if (!text) return
+      if (prefs.messageTool && draft.turn) {
+        draft.turn.unsent = text
+        return
+      }
       emit({ type: 'markdown', text, blankLineBefore: draft.lastKind === 'tool' })
       draft.lastKind = 'text'
       return
@@ -434,6 +452,7 @@ function applyRoot(context: Context & { event: V2Event }) {
         emitFooter({ ...context, turn: draft.turn, at: event.created, notify: false })
         draft.turn.startedAt = event.created
         draft.turn.slept = false
+        draft.turn.messaged = false
         draft.lastKind = null
       }
       return deliverQueued({ draft, emit, inboxID: event.data.inboxID })
@@ -494,6 +513,15 @@ function applyTool(context: Context & { event: V2Event; label: string | undefine
         if (reused) Object.assign(reused, { ...call, agent: call.agent || reused.agent })
       }
       draft.tools[key] = tool
+      // The plugin offers send_message to root sessions only (MESSAGE_TOOL).
+      if (name === MESSAGE_TOOL && label === undefined) {
+        const text = stringInput(input, 'text').trim()
+        if (draft.turn) draft.turn.messaged = true
+        if (!text) return
+        context.emit({ type: 'markdown', text, blankLineBefore: draft.lastKind === 'tool' })
+        draft.lastKind = 'text'
+        return
+      }
       if (render && isToolVisible({ name, input }, prefs.verbosity)) toolLine(context, formatToolLine({ name, input }, { label }))
       return
     }
@@ -613,7 +641,7 @@ function applyKimaki({ draft, event, prefs, emit }: Context & { event: KimakiEve
       const active = new Set(event.activeSessionIds)
       for (const [id, child] of Object.entries(draft.children)) child.running = active.has(id)
       if (!active.has(draft.sessionId)) draft.turn = null
-      else draft.turn ??= { startedAt: event.at, model: null, agent: null, tokens: 0, slept: false }
+      else draft.turn ??= newTurn(event.at)
       // Nothing runs: tool calls whose end was missed while disconnected are over.
       if (!isBusy(draft)) draft.tools = {}
       for (const session of event.sessions) {
@@ -645,9 +673,13 @@ export function replayEffects({
   const blocks = messages.flatMap((message): Block[] => {
     if (message.type !== 'assistant') return []
     return message.content.flatMap((part): Block[] => {
-      if (part.type === 'text') return part.text.trim() ? [{ kind: 'text', text: part.text.trim() }] : []
+      if (part.type === 'text') return part.text.trim() && !prefs.messageTool ? [{ kind: 'text', text: part.text.trim() }] : []
       if (part.type !== 'tool' || part.state.status === 'streaming') return []
       const { input, metadata } = part.state
+      if (part.name === MESSAGE_TOOL) {
+        const text = stringInput(input, 'text').trim()
+        return text ? [{ kind: 'text', text }] : []
+      }
       const isExecute = part.name === 'execute'
       const lines = [{ name: part.name, input }, ...(isExecute ? executeCalls(metadata) : [])]
         .filter((call) => isToolVisible(call, prefs.verbosity))

package/src/tunnel.test.ts

@@ -0,0 +1,39 @@
+import { expect, test } from 'vitest'
+import { detectPortFromText, routeName } from './tunnel.ts'
+
+test('detects the dev server port and skips noise lines', () => {
+  const vite = '\u001b[33mPort 5173 is in use, trying another one...\u001b[39m\n  ➜  Local:   \u001b[36mhttp://localhost:\u001b[1m5174\u001b[22m/\u001b[39m\n'
+  expect({
+    vite: detectPortFromText(vite),
+    next: detectPortFromText('   - Local:        http://127.0.0.1:3000'),
+    bare: detectPortFromText('Server running at 0.0.0.0:4321'),
+    inspector: detectPortFromText('Debugger listening on ws://127.0.0.1:9229/abc\nready on http://localhost:4173'),
+    outOfRange: detectPortFromText('listening on localhost:70000'),
+    portOnly: detectPortFromText('Port 5173 is in use'),
+  }).toMatchInlineSnapshot(`
+    {
+      "bare": 4321,
+      "inspector": 4173,
+      "next": 3000,
+      "outOfRange": null,
+      "portOnly": null,
+      "vite": 5174,
+    }
+  `)
+})
+
+test('route name: explicit, then tuistory session, then random', () => {
+  expect({
+    explicit: routeName({ name: 'docs', tuistorySessionId: 'abc123' }),
+    invalid: String(routeName({ name: 'Bad_Name' })),
+    tuistory: routeName({ tuistorySessionId: 'ABC123' }),
+    random: String(routeName({})).length,
+  }).toMatchInlineSnapshot(`
+    {
+      "explicit": "docs",
+      "invalid": "Error: Invalid tunnel ID "Bad_Name": use lowercase letters, digits and dashes",
+      "random": 16,
+      "tuistory": "abc123",
+    }
+  `)
+})

package/src/tunnel.ts

@@ -0,0 +1,209 @@
+// `kimaki tunnel`: run a command, find the local port it listens on, and expose
+// it at https://<route>.<id>.opentunnel.xyz. TLS ends in this process, so the
+// relay never sees plaintext. The tunnel identity is the default opentunnel
+// profile in $XDG_DATA_HOME/opentunnel, shared with the opentunnel CLI.
+
+import crypto from 'node:crypto'
+import { execFile, spawn, type ChildProcess } from 'node:child_process'
+import net from 'node:net'
+import { setTimeout as sleep } from 'node:timers/promises'
+import { promisify, stripVTControlCharacters } from 'node:util'
+import { create as createOpenTunnel, type OpenTunnelConnection } from '@opentunnel/client'
+
+const execFileAsync = promisify(execFile)
+
+const ROUTE_NAME = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/
+const PORT_WAIT_MS = 30_000
+const ATTACH_TIMEOUT_MS = 60_000
+const CHILD_KILL_GRACE_MS = 5_000
+
+// Only lines with host:port, so "Port 5173 is in use" does not match.
+const LOCAL_PORT_PATTERN = /(?:https?:\/\/)?(?:localhost|127\.0\.0\.1|0\.0\.0\.0|\[::\]):(\d{1,5})/i
+const IGNORED_LINE_PATTERNS = [/\bdebugger (?:listening|attached)\b/i, /\bdevtools listening\b/i]
+
+export function detectPortFromText(text: string): number | null {
+  // Vite colors the port separately, so strip ANSI before matching.
+  for (const line of stripVTControlCharacters(text).split('\n')) {
+    if (IGNORED_LINE_PATTERNS.some((pattern) => pattern.test(line))) continue
+    const port = Number(line.match(LOCAL_PORT_PATTERN)?.[1])
+    if (port >= 1 && port <= 65_535) return port
+  }
+  return null
+}
+
+// Explicit name, then the tuistory session ID (stable URL across restarts of one session), then random.
+export function routeName({ name, tuistorySessionId }: { name?: string; tuistorySessionId?: string }): string | Error {
+  if (name) return ROUTE_NAME.test(name) ? name : new Error(`Invalid tunnel ID ${JSON.stringify(name)}: use lowercase letters, digits and dashes`)
+  const fromSession = tuistorySessionId?.toLowerCase()
+  if (fromSession && ROUTE_NAME.test(fromSession)) return fromSession
+  return crypto.randomBytes(8).toString('hex')
+}
+
+function isPortInUse({ port, host }: { port: number; host: string }): Promise<boolean> {
+  return new Promise((resolve) => {
+    const socket = net.connect({ port, host })
+    socket.once('connect', () => { socket.destroy(); resolve(true) })
+    socket.once('error', () => { socket.destroy(); resolve(false) })
+  })
+}
+
+async function waitForPort({ port, host, signal }: { port: number; host: string; signal: AbortSignal }): Promise<void | Error> {
+  while (!(await isPortInUse({ port, host }))) {
+    if (signal.aborted) return new Error(`Timed out waiting for ${host}:${port} to accept connections`)
+    await sleep(300)
+  }
+}
+
+async function listeningPids(port: number): Promise<number[]> {
+  const { stdout } = await execFileAsync('lsof', ['-ti', `tcp:${port}`, '-sTCP:LISTEN'], { timeout: 5_000 }).catch(() => ({ stdout: '' }))
+  return stdout.split('\n').map(Number).filter((pid) => Number.isInteger(pid) && pid > 0)
+}
+
+async function killProcessOnPort({ port, host }: { port: number; host: string }): Promise<void | Error> {
+  for (const signal of ['SIGTERM', 'SIGKILL'] as const) {
+    for (const pid of await listeningPids(port)) {
+      try { process.kill(pid, signal) } catch {}
+    }
+    for (let waited = 0; waited < 3_000; waited += 200) {
+      if (!(await isPortInUse({ port, host }))) return
+      await sleep(200)
+    }
+  }
+  return new Error(`Port ${port} is still in use after --kill`)
+}
+
+function detectPortFromOutput({ child, signal }: { child: ChildProcess; signal: AbortSignal }): Promise<number | Error> {
+  return new Promise((resolve) => {
+    let buffer = ''
+    const finish = (result: number | Error) => {
+      child.stdout?.off('data', onData)
+      child.stderr?.off('data', onData)
+      child.off('exit', onExit)
+      signal.removeEventListener('abort', onAbort)
+      resolve(result)
+    }
+    const onData = (chunk: Buffer) => {
+      buffer = (buffer + chunk.toString()).slice(-8_000)
+      const port = detectPortFromText(buffer)
+      if (port) finish(port)
+    }
+    const onExit = (code: number | null) => finish(new Error(`Command exited with code ${code} before printing a localhost URL. Pass --port`))
+    const onAbort = () => finish(new Error(`No localhost URL in the command output after ${PORT_WAIT_MS / 1000}s. Pass --port`))
+    child.stdout?.on('data', onData)
+    child.stderr?.on('data', onData)
+    child.once('exit', onExit)
+    signal.addEventListener('abort', onAbort, { once: true })
+  })
+}
+
+function killChild(child: ChildProcess | undefined, signal: NodeJS.Signals = 'SIGTERM'): Promise<void> {
+  if (!child || child.exitCode !== null || child.signalCode !== null) return Promise.resolve()
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => { child.kill('SIGKILL'); resolve() }, CHILD_KILL_GRACE_MS)
+    child.once('exit', () => { clearTimeout(timer); resolve() })
+    child.kill(signal)
+  })
+}
+
+const log = (line: string) => process.stderr.write(`${line}\n`)
+
+export async function runTunnel(options: {
+  port?: number
+  command?: string[]
+  name?: string
+  host?: string
+  kill?: boolean
+}): Promise<void | Error> {
+  const host = options.host ?? 'localhost'
+  const route = routeName({ name: options.name, tuistorySessionId: process.env['TUISTORY_SESSION_ID'] })
+  if (route instanceof Error) return route
+  if (options.kill && !options.port) return new Error('--kill needs --port')
+
+  if (options.port && options.kill) {
+    const killed = await killProcessOnPort({ port: options.port, host })
+    if (killed instanceof Error) return killed
+  } else if (options.port && options.command && (await isPortInUse({ port: options.port, host }))) {
+    return new Error(`Port ${options.port} is already in use. Pass --kill to stop the process on it first`)
+  }
+
+  const client = createOpenTunnel()
+  const existing = await client.tunnel.get().catch(() => undefined)
+  if (!existing) log('Creating the opentunnel.xyz tunnel of this machine (waits for a certificate, up to a minute)...')
+  const identity = await client.tunnel.ensure().catch((cause: unknown) => new Error('Could not create the opentunnel tunnel', { cause }))
+  if (identity instanceof Error) return identity
+  const url = `https://${route}.${identity.hostname}`
+
+  let child: ChildProcess | undefined
+  let connection: OpenTunnelConnection | undefined
+  // Set before we kill the child ourselves, so its exit does not end the process first.
+  let stopping = false
+  const shutdown = async (signal: NodeJS.Signals) => {
+    if (stopping) return
+    stopping = true
+    log('Shutting down...')
+    await connection?.close().catch(() => undefined)
+    await killChild(child, signal)
+    process.exit(0)
+  }
+  for (const signal of ['SIGINT', 'SIGTERM', 'SIGHUP'] as const) process.once(signal, () => void shutdown(signal))
+
+  if (options.command) {
+    const [cmd, ...args] = options.command
+    child = spawn(cmd!, args, {
+      stdio: ['inherit', 'pipe', 'pipe'],
+      env: {
+        ...process.env,
+        ...(options.port && { PORT: String(options.port) }),
+        KIMAKI_TUNNEL_URL: url,
+        // Old name from traforo, kept so existing app configs still work.
+        TRAFORO_URL: url,
+        // wrangler dev passes parent env vars as worker bindings, so workers can read KIMAKI_TUNNEL_URL.
+        CLOUDFLARE_INCLUDE_PROCESS_ENV: 'true',
+        FORCE_COLOR: '1',
+        VITE_CLS: 'false',
+        NEXT_TELEMETRY_DISABLED: '1',
+      },
+    })
+    child.stdout?.pipe(process.stdout)
+    child.stderr?.pipe(process.stderr)
+    child.on('error', (error) => { log(`Failed to start command: ${error.message}`); process.exit(1) })
+    child.on('exit', (code, signal) => {
+      if (stopping) return
+      log(`Command exited with ${signal ?? `code ${code}`}`)
+      process.exit(code ?? 1)
+    })
+  }
+
+  const fail = async (error: Error) => { stopping = true; await killChild(child); return error }
+
+  let port = options.port
+  const portSignal = AbortSignal.timeout(PORT_WAIT_MS)
+  if (!port && child) {
+    const detected = await detectPortFromOutput({ child, signal: portSignal })
+    if (detected instanceof Error) return fail(detected)
+    port = detected
+  }
+  if (!port) return fail(new Error('Could not find the local port. Pass --port'))
+  const ready = await waitForPort({ port, host, signal: portSignal })
+  if (ready instanceof Error) return fail(ready)
+
+  // connect retries route_conflict forever, so a route held by another process would hang here.
+  const connecting = client.tunnel.connect({ routes: { [route]: `${host}:${port}` } })
+  const timeout = sleep(ATTACH_TIMEOUT_MS, null, { ref: false })
+  const attached = await Promise.race([connecting, timeout]).catch((cause: unknown) => new Error('Could not connect the tunnel', { cause }))
+  if (attached instanceof Error) return fail(attached)
+  if (!attached) return fail(new Error(`Tunnel did not attach in ${ATTACH_TIMEOUT_MS / 1000}s. Another process may use the tunnel ID ${route}`))
+  connection = attached
+
+  process.stdout.write(`\nLocal:  http://${host}:${port}\nTunnel: ${url}\n\n`)
+
+  void (async () => {
+    for await (const event of attached.events) {
+      if (event.type === 'disconnected') log(`Tunnel disconnected: ${event.reason}`)
+      if (event.type === 'connected') log('Tunnel connected')
+    }
+  })()
+
+  const closed = await attached.closed.then(() => undefined, (cause: unknown) => new Error('Tunnel stopped', { cause }))
+  return fail(closed ?? new Error('Tunnel stopped'))
+}