typeclaw 0.9.1 → 0.10.0

package/src/cli/logs.ts

@@ -1,6 +1,6 @@
 import { defineCommand } from 'citty'
 
-import { logs } from '@/container'
+import { logs, parseTailValue } from '@/container'
 import { findAgentDir } from '@/init'
 
 import { c, errorLine } from './ui'
@@ -17,17 +17,32 @@ export const logsCommand = defineCommand({
       description: 'stream new log output as it arrives',
       default: false,
     },
+    tail: {
+      type: 'string',
+      alias: 'n',
+      description: 'number of lines to show from the end of the logs (non-negative integer or "all")',
+    },
   },
   async run({ args }) {
     const cwd = findAgentDir(process.cwd()) ?? process.cwd()
 
+    let tail: string | undefined
+    if (args.tail !== undefined) {
+      const parsed = parseTailValue(args.tail)
+      if (!parsed.ok) {
+        console.error(errorLine(parsed.reason))
+        process.exit(2)
+      }
+      tail = parsed.value
+    }
+
     if (args.follow) {
       console.log(c.cyan('Streaming container logs...'))
     } else {
       console.log(c.dim('Showing container logs.'))
     }
 
-    const result = await logs({ cwd, follow: args.follow })
+    const result = await logs({ cwd, follow: args.follow, tail })
     if (!result.ok) {
       console.error(errorLine(result.reason))
       process.exit(1)

package/src/cli/role.ts

@@ -11,7 +11,7 @@ const claimSub = defineCommand({
   meta: {
     name: 'claim',
     description:
-      'claim a channel identity (Slack/Discord/etc.) for a role on this agent. Sends a code via the host CLI; you DM that code back to the bot to prove control of the channel account.',
+      'claim a channel identity (Slack/Discord/etc.) for a role on this agent. Sends a code via the host CLI; you send that code back to the bot from any chat (DM, group, channel) to prove control of the channel account. The resulting match rule grants the role to your author identity across every chat on that platform.',
   },
   args: {
     as: {
@@ -57,7 +57,7 @@ const claimSub = defineCommand({
         s.stop('Ready.')
         const expiresInSec = Math.max(0, Math.round((payload.expiresAt - Date.now()) / 1000))
         const lines = [
-          `Send this message to your bot as a DM:`,
+          `Send this message to your bot from any chat (DM, group, or channel):`,
           '',
           `  ${c.bold(payload.code)}`,
           '',

package/src/compose/logs.ts

@@ -1,4 +1,4 @@
-import { containerExists } from '@/container'
+import { buildDockerLogsCmd, containerExists } from '@/container'
 import { supportsColor } from '@/container/log-colors'
 import { makeLogTimestampReformatter, type TimestampReformatter } from '@/container/log-timestamps'
 import { getBun } from '@/container/shared'
@@ -8,6 +8,7 @@ import { discoverAgents, type AgentEntry } from './discover'
 export type ComposeLogsOptions = {
   rootCwd: string
   follow: boolean
+  tail?: string
   out?: NodeJS.WritableStream
   err?: NodeJS.WritableStream
   signal?: AbortSignal
@@ -66,6 +67,7 @@ export function makeLinePrefixer(
 export async function composeLogs({
   rootCwd,
   follow,
+  tail,
   out = process.stdout,
   err = process.stderr,
   signal,
@@ -93,9 +95,11 @@ export async function composeLogs({
   const useColor = supportsColor(out)
 
   const procs = attached.map((agent) => {
-    const cmd = follow
-      ? ['docker', 'logs', '--timestamps', '-f', agent.containerName]
-      : ['docker', 'logs', '--timestamps', agent.containerName]
+    const cmd = buildDockerLogsCmd({
+      containerName: agent.containerName,
+      follow,
+      ...(tail !== undefined ? { tail } : {}),
+    })
     const proc = bun.spawn({ cmd, stdout: 'pipe', stderr: 'pipe' })
     return { agent, proc }
   })

package/src/config/config.ts

@@ -121,6 +121,14 @@ const dockerfileObjectSchema = z.object({
   // time, not via version pins like apt. Default `false`; the bundled
   // `typeclaw-claude-code` skill prompts the user to opt in.
   claudeCode: z.boolean().default(false),
+  // `codexCli` is boolean-only (not an apt feature toggle): the upstream
+  // installer is the npm package `@openai/codex` which we install globally
+  // via `bun install -g`. Default `false`; the bundled `typeclaw-codex-cli`
+  // skill prompts the user to opt in. Mirrors the `claudeCode` toggle for
+  // OpenAI's Codex CLI (https://github.com/openai/codex) — same shape, same
+  // restart-required semantics, separate hook scripts (Codex uses
+  // hooks.json with a different event matcher than Claude Code).
+  codexCli: z.boolean().default(false),
   append: z.array(dockerfileLineSchema).default([]),
 })
 

package/src/config/providers.ts

@@ -465,6 +465,24 @@ export function providerForModelRef(ref: KnownModelRef): KnownProviderId {
   throw new Error(`Unknown provider in model ref: ${ref}`)
 }
 
+// Per-provider default for pi-coding-agent's `thinkingLevel` knob. Returning
+// `undefined` defers to the SDK default (`medium`); returning a level pins it
+// to that value at session-creation time.
+//
+// OpenAI-family providers (`openai`, `openai-codex`) pin to `low`: GPT-5.x at
+// `medium` pads reasoning tokens on routine tool-driven turns (code edits,
+// channel replies, cron prompts) with no observable quality delta on this
+// codebase's workloads. Applies to every session that resolves to a GPT model
+// regardless of profile, so the saving is uniform.
+//
+// Anthropic, GLM, and Kimi don't share the padding behavior, so they keep the
+// SDK default.
+export function defaultThinkingLevelForRef(ref: KnownModelRef): 'low' | undefined {
+  const providerId = providerForModelRef(ref)
+  if (providerId === 'openai' || providerId === 'openai-codex') return 'low'
+  return undefined
+}
+
 // `as const satisfies` narrows each entry's `auth` to a tuple of its specific
 // literal values, which makes `provider.auth.includes('oauth')` fail to
 // compile on api-key-only entries (because TS thinks the array can never

package/src/container/index.ts

@@ -1,4 +1,4 @@
-export { logs, planLogs, type LogsPlan, type LogsResult } from './logs'
+export { buildDockerLogsCmd, logs, parseTailValue, planLogs, type LogsPlan, type LogsResult } from './logs'
 export { CONTAINER_PORT, TUI_TOKEN_LABEL, findFreePort, resolveHostPort, resolveTuiToken } from './port'
 export {
   requireContainerRunning,

package/src/container/logs.ts

@@ -5,6 +5,7 @@ import { containerExists, containerNameFromCwd, getBun } from './shared'
 export type LogsPlan = {
   containerName: string
   follow: boolean
+  tail?: string
 }
 
 export type LogsResult = { ok: true; containerName: string; exitCode: number } | { ok: false; reason: string }
@@ -12,6 +13,10 @@ export type LogsResult = { ok: true; containerName: string; exitCode: number } |
 export type LogsOptions = {
   cwd: string
   follow: boolean
+  // Forwarded to `docker logs --tail <value>`. Accepts a non-negative
+  // integer string or the sentinel `"all"`. When undefined, no `--tail`
+  // arg is added and docker's default ("all") applies.
+  tail?: string
   out?: NodeJS.WritableStream
   err?: NodeJS.WritableStream
   signal?: AbortSignal
@@ -23,6 +28,7 @@ export type LogsOptions = {
 export async function logs({
   cwd,
   follow,
+  tail,
   out = process.stdout,
   err = process.stderr,
   signal,
@@ -31,18 +37,14 @@ export async function logs({
   const bun = getBun()
   if (!bun) return { ok: false, reason: 'bun runtime not available' }
 
-  const { containerName } = planLogs(cwd, { follow })
+  const plan = planLogs(cwd, { follow, tail })
 
   try {
-    if (!(await containerExists(containerName))) {
-      return { ok: false, reason: `Container ${containerName} not found. Run \`typeclaw start\` first.` }
+    if (!(await containerExists(plan.containerName))) {
+      return { ok: false, reason: `Container ${plan.containerName} not found. Run \`typeclaw start\` first.` }
     }
 
-    const cmd = ['docker', 'logs', '--timestamps']
-    if (follow) cmd.push('-f')
-    cmd.push(containerName)
-
-    const proc = bun.spawn({ cmd, cwd, stdout: 'pipe', stderr: 'pipe' })
+    const proc = bun.spawn({ cmd: buildDockerLogsCmd(plan), cwd, stdout: 'pipe', stderr: 'pipe' })
 
     const onAbort = (): void => {
       try {
@@ -62,14 +64,39 @@ export async function logs({
     const exitCode = await proc.exited
     signal?.removeEventListener('abort', onAbort)
 
-    return { ok: true, containerName, exitCode }
+    return { ok: true, containerName: plan.containerName, exitCode }
   } catch (error) {
     return { ok: false, reason: error instanceof Error ? error.message : String(error) }
   }
 }
 
-export function planLogs(cwd: string, { follow }: { follow: boolean }): LogsPlan {
-  return { containerName: containerNameFromCwd(cwd), follow }
+export function planLogs(cwd: string, { follow, tail }: { follow: boolean; tail?: string }): LogsPlan {
+  return { containerName: containerNameFromCwd(cwd), follow, ...(tail !== undefined ? { tail } : {}) }
+}
+
+// Validate user-supplied `--tail` value. Mirrors `docker logs --tail`'s
+// accepted shape: either the sentinel `"all"` (case-insensitive) or a
+// non-negative integer.
+export function parseTailValue(raw: string): { ok: true; value: string } | { ok: false; reason: string } {
+  const trimmed = raw.trim()
+  if (trimmed.length === 0) return { ok: false, reason: '--tail requires a value (a non-negative integer or "all")' }
+  if (trimmed.toLowerCase() === 'all') return { ok: true, value: 'all' }
+  // Reject leading +, leading zeros (other than "0"), signs, decimals, and
+  // scientific notation up front so the user gets a clear error instead of
+  // docker's terse "invalid value" later.
+  if (!/^(?:0|[1-9]\d*)$/.test(trimmed)) {
+    return { ok: false, reason: `--tail expects a non-negative integer or "all", got ${JSON.stringify(raw)}` }
+  }
+  return { ok: true, value: trimmed }
+}
+
+// Exported so `compose/logs.ts` builds the exact same `docker logs` argv shape.
+export function buildDockerLogsCmd(plan: LogsPlan): string[] {
+  const cmd = ['docker', 'logs', '--timestamps']
+  if (plan.tail !== undefined) cmd.push('--tail', plan.tail)
+  if (plan.follow) cmd.push('-f')
+  cmd.push(plan.containerName)
+  return cmd
 }
 
 // Exported for `compose/logs.ts` so the multi-agent path reuses the same

package/src/cron/bridge.ts

@@ -1,10 +1,14 @@
-import { resolveHostPort, resolveTuiToken } from '@/container'
+import { CONTAINER_PORT, resolveHostPort, resolveTuiToken } from '@/container'
 import type { ClientMessage, CronListEntryPayload, ServerMessage } from '@/shared'
 
 export type CronListBridgeOptions = {
   cwd: string
   url?: string
   timeoutMs?: number
+  // Injected for tests so the in-container short-circuit can be exercised
+  // without polluting process.env. Production callers omit this and the
+  // bridge reads from process.env directly.
+  env?: NodeJS.ProcessEnv
 }
 
 export type CronListBridgeResult =
@@ -34,9 +38,7 @@ async function dial(opts: CronListBridgeOptions): Promise<DialResult> {
   let url = opts.url
   if (url === undefined) {
     try {
-      const port = await resolveHostPort({ cwd: opts.cwd })
-      const token = await resolveTuiToken({ cwd: opts.cwd })
-      url = buildBridgeUrl(port, token)
+      url = resolveInContainerUrl(opts.env ?? process.env) ?? (await resolveHostUrl(opts.cwd))
     } catch (err) {
       return { kind: 'unreachable', reason: err instanceof Error ? err.message : String(err) }
     }
@@ -115,6 +117,25 @@ async function awaitReply(ws: WebSocket, timeoutMs: number, requestId: string):
   })
 }
 
+// In-container short-circuit: when typeclaw runs `docker run`, it sets
+// TYPECLAW_CONTAINER_NAME (always) and TYPECLAW_TUI_TOKEN (when configured).
+// Inside the container, docker is not on $PATH, so the host-side discovery
+// path (resolveHostPort/resolveTuiToken — both shell out to `docker`) fails
+// with "docker: command not found". We don't need docker here: the agent's
+// WS server is listening on CONTAINER_PORT on the container's loopback, and
+// the token is already in our env. Skip docker entirely and dial directly.
+export function resolveInContainerUrl(env: NodeJS.ProcessEnv): string | null {
+  if (env.TYPECLAW_CONTAINER_NAME === undefined) return null
+  const token = env.TYPECLAW_TUI_TOKEN ?? ''
+  return buildBridgeUrl(CONTAINER_PORT, token !== '' ? token : null)
+}
+
+async function resolveHostUrl(cwd: string): Promise<string> {
+  const port = await resolveHostPort({ cwd })
+  const token = await resolveTuiToken({ cwd })
+  return buildBridgeUrl(port, token)
+}
+
 function buildBridgeUrl(port: number, token: string | null): string {
   const url = new URL(`ws://127.0.0.1:${port}`)
   if (token !== null) url.searchParams.set('token', token)

package/src/hostd/daemon.ts

@@ -69,7 +69,7 @@ export type RestartPreflight = (input: {
 }) => Promise<RpcResponse | null>
 
 export type PortbrokerCallbacks = {
-  start: (input: PortbrokerStartInput) => void
+  start: (input: PortbrokerStartInput) => Promise<void>
   stop: (containerName: string, reason: 'deregistered' | 'broker-stopped') => Promise<void>
   // Returns ports the broker is currently exposing on the host for this
   // container. Empty array when the container is unregistered, when the broker
@@ -157,8 +157,10 @@ function isValidRestoredPayload(value: unknown, expectedName: string): value is
 }
 
 async function restorePersistedRegistrations(
-  apply: (payload: RestoredPayload) => void,
+  apply: (payload: RestoredPayload) => Promise<void>,
   log: (event: DaemonLogEvent | SupervisorLogEvent) => void,
+  probe: (name: string) => Promise<'alive' | 'gone' | 'unknown'>,
+  removeFile: (name: string) => Promise<void>,
 ): Promise<void> {
   let entries: string[]
   try {
@@ -181,7 +183,23 @@ async function restorePersistedRegistrations(
       log({ kind: 'registration-skipped', containerName: expectedName, reason: 'schema mismatch' })
       continue
     }
-    apply(parsed)
+    // Probe before reviving. A registration file for a container that no
+    // longer exists is a leftover from a daemon that died ungracefully
+    // (crash, `kill -9`, OS reboot) before deregister could clean up.
+    // Reviving its broker would create a stale T_old broker that races a
+    // subsequent `register` call's T_new broker — see portbroker-manager.ts
+    // start() for the swap-race description. `unknown` (docker probe call
+    // failed) errs toward restore: the existing GC tick will tear down the
+    // registration if the container is genuinely gone, and we'd rather pay
+    // one swap-race attempt than tear down a live registration on a flaky
+    // `docker ps`.
+    const status = await probe(expectedName)
+    if (status === 'gone') {
+      await removeFile(expectedName)
+      log({ kind: 'registration-skipped', containerName: expectedName, reason: 'container not running' })
+      continue
+    }
+    await apply(parsed)
   }
 }
 
@@ -267,7 +285,7 @@ export async function startDaemon(opts: DaemonOptions = {}): Promise<Daemon> {
     } catch {}
   }
 
-  const applyRegistration = (payload: RegisterPayload): void => {
+  const applyRegistration = async (payload: RegisterPayload): Promise<void> => {
     const alreadyRegistered = cwds.has(payload.containerName)
     cwds.set(payload.containerName, payload.cwd)
     if (payload.restartToken) restartTokens.set(payload.containerName, payload.restartToken)
@@ -281,7 +299,7 @@ export async function startDaemon(opts: DaemonOptions = {}): Promise<Daemon> {
       payload.portForward !== undefined &&
       payload.brokerToken !== undefined
     ) {
-      opts.portbroker.start({
+      await opts.portbroker.start({
         containerName: payload.containerName,
         cwd: payload.cwd,
         policy: payload.portForward,
@@ -308,7 +326,7 @@ export async function startDaemon(opts: DaemonOptions = {}): Promise<Daemon> {
           reason: `failed to persist registration: ${error instanceof Error ? error.message : String(error)}`,
         }
       }
-      applyRegistration(req)
+      await applyRegistration(req)
       return { ok: true }
     })
   }
@@ -528,12 +546,31 @@ export async function startDaemon(opts: DaemonOptions = {}): Promise<Daemon> {
   httpPort = httpServer.port ?? 0
   log({ kind: 'daemon-http-listening', host: httpHostname, port: httpPort })
 
+  // GC tick distinguishes "container confirmed gone" from "docker call failed":
+  // a `docker ps` blip should not deregister a live container registration, so
+  // we require gcMissesToDeregister consecutive confirmed absences. Boot-time
+  // restore reuses the same probe but with a stricter policy — see
+  // restorePersistedRegistrations.
+  const probeContainerAlive = async (name: string): Promise<'alive' | 'gone' | 'unknown'> => {
+    try {
+      const result = await exec(['ps', '-a', '--filter', `name=^${name}$`, '--format', '{{.Names}}'])
+      if (result.exitCode !== 0) return 'unknown'
+      const names = result.stdout
+        .trim()
+        .split('\n')
+        .filter((s) => s.length > 0)
+      return names.includes(name) ? 'alive' : 'gone'
+    } catch {
+      return 'unknown'
+    }
+  }
+
   // Boot-time restore: replay every persisted registration into the in-memory
   // maps and revive portbroker for it. Runs before Bun.listen so the socket
   // is never accepting RPCs against a half-restored registry. A bad file
   // (parse error, schema mismatch) is logged-and-skipped — one corrupt
   // registration must not gate every other container's recovery.
-  await restorePersistedRegistrations(applyRegistration, log)
+  await restorePersistedRegistrations(applyRegistration, log, probeContainerAlive, removeRegistrationFile)
 
   const listener: UnixSocketListener<ServerState> = Bun.listen<ServerState>({
     unix: path,
@@ -550,23 +587,6 @@ export async function startDaemon(opts: DaemonOptions = {}): Promise<Daemon> {
   await chmod(path, 0o600).catch(() => {})
   log({ kind: 'daemon-listening', socket: path })
 
-  // GC tick distinguishes "container confirmed gone" from "docker call failed":
-  // a `docker ps` blip should not deregister a live container registration, so
-  // we require gcMissesToDeregister consecutive confirmed absences.
-  const probeContainerAlive = async (name: string): Promise<'alive' | 'gone' | 'unknown'> => {
-    try {
-      const result = await exec(['ps', '-a', '--filter', `name=^${name}$`, '--format', '{{.Names}}'])
-      if (result.exitCode !== 0) return 'unknown'
-      const names = result.stdout
-        .trim()
-        .split('\n')
-        .filter((s) => s.length > 0)
-      return names.includes(name) ? 'alive' : 'gone'
-    } catch {
-      return 'unknown'
-    }
-  }
-
   const runGc = async (): Promise<void> => {
     for (const name of Array.from(cwds.keys())) {
       const status = await probeContainerAlive(name)

package/src/hostd/portbroker-manager.ts

@@ -26,15 +26,31 @@ export function createPortbrokerManager(opts: PortbrokerManagerOptions = {}): Po
   const brokerFactory = opts.createBrokerFor ?? createBroker
 
   return {
-    start(input: PortbrokerStartInput) {
+    // start() awaits the previous broker's stop before constructing the new
+    // one. The fire-and-forget shape this replaced let a stale T_old broker
+    // win the race to send broker-hello against a brand-new container that
+    // expects T_new, producing a one-shot `auth-failed: token mismatch`
+    // broadcast at every re-register that arrived while the old broker was
+    // still mid-stop. The race window was narrow but reproducible across
+    // hostd-respawn-after-ungraceful-death + typeclaw restart, because the
+    // restored T_old broker is alive for the duration of the register RPC.
+    // Awaiting collapses the window to zero — by the time the T_new broker's
+    // first connect() fires, the T_old broker has set stopped=true, cleared
+    // its reconnect timer, and closed its WS.
+    async start(input: PortbrokerStartInput) {
       const existing = brokers.get(input.containerName)
       if (existing) {
-        void existing.stop().catch(() => {})
+        brokers.delete(input.containerName)
+        try {
+          await existing.stop()
+        } catch {}
       }
       const existingTailscale = tailscaleManagers.get(input.containerName)
       if (existingTailscale) {
         tailscaleManagers.delete(input.containerName)
-        void existingTailscale.stopAll().catch(() => {})
+        try {
+          await existingTailscale.stopAll()
+        } catch {}
       }
       const tailscale = createTailscaleServeManager({
         containerName: input.containerName,