typeclaw 0.1.3 → 0.1.5

package/src/init/index.ts

@@ -3,10 +3,16 @@ import { mkdir, readFile, writeFile } from 'node:fs/promises'
 import { basename, dirname, join, relative, resolve } from 'node:path'
 import { fileURLToPath } from 'node:url'
 
-import { config, configSchema, type Config } from '@/config'
-import { DEFAULT_MODEL_REF, KNOWN_PROVIDERS, providerForModelRef, type KnownModelRef } from '@/config/providers'
+import { config, configSchema, migrateLegacyConfigShape, type Config } from '@/config'
+import {
+  DEFAULT_MODEL_REF,
+  KNOWN_PROVIDERS,
+  providerForModelRef,
+  type KnownModelRef,
+  type KnownProviderId,
+} from '@/config/providers'
 import { checkDockerAvailable, type DockerAvailability, type DockerExec, start } from '@/container'
-import { type Channels, type Secret, SecretsBackend } from '@/secrets'
+import { createSecretsStoreForAgent, type Channels, type Secret, SecretsBackend } from '@/secrets'
 import { createTui } from '@/tui'
 
 import { resolveBaseImageVersion, resolveScaffoldVersion } from './cli-version'
@@ -23,7 +29,6 @@ export { GITKEEP_FILE, PACKAGES_DIR } from './paths'
 
 const CONFIG_FILE = 'typeclaw.json'
 const CRON_FILE = 'cron.json'
-const SECRETS_FILE = '.env'
 const PACKAGE_FILE = 'package.json'
 
 const MARKDOWN_FILES = ['AGENTS.md', 'IDENTITY.md', 'SOUL.md', 'USER.md'] as const
@@ -269,10 +274,10 @@ export async function defaultRunHatching({
     // the preferred port, otherwise we'd connect to the wrong service.
     const hostPort = launch.hostPort
 
-    await waitForAgentFn(`http://localhost:${hostPort}`, { timeoutMs: 30_000 })
+    await waitForAgentFn(`http://127.0.0.1:${hostPort}`, { timeoutMs: 30_000 })
 
     const tui = tuiFactory({
-      url: `ws://localhost:${hostPort}`,
+      url: buildTuiUrl(hostPort, launch.tuiToken),
       initialPrompt: HATCHING_PROMPT,
     })
     await tui.run()
@@ -282,6 +287,12 @@ export async function defaultRunHatching({
   }
 }
 
+function buildTuiUrl(hostPort: number, token: string | null): string {
+  const url = new URL(`ws://127.0.0.1:${hostPort}`)
+  if (token !== null) url.searchParams.set('token', token)
+  return url.toString()
+}
+
 // Probe the server's plain HTTP fallback (non-upgrade requests get a 200 with
 // body "typeclaw agent") instead of opening a WebSocket. Opening a WS here
 // would trigger createSession on the server and burn an LLM session just to
@@ -484,7 +495,7 @@ export async function writeDockerAssets(root: string): Promise<DockerAssetsResul
     const typeclawConfig = await readTypeclawConfig(root)
     await writeFile(
       join(root, DOCKERFILE),
-      buildDockerfile(typeclawConfig.dockerfile, { baseImageVersion: resolveBaseImageVersion(root) }),
+      buildDockerfile(typeclawConfig.docker.file, { baseImageVersion: resolveBaseImageVersion(root) }),
       { flag: 'wx' },
     ).catch(ignoreExists)
 
@@ -502,7 +513,7 @@ async function readPackageJson(root: string): Promise<{ name?: string; dependenc
 async function readTypeclawConfig(root: string): Promise<Config> {
   try {
     const raw = await readFile(join(root, CONFIG_FILE), 'utf8')
-    return configSchema.parse(JSON.parse(raw))
+    return configSchema.parse(migrateLegacyConfigShape(JSON.parse(raw)).json)
   } catch (error) {
     if ((error as NodeJS.ErrnoException).code === 'ENOENT') return configSchema.parse({})
     throw error
@@ -558,15 +569,10 @@ export async function initGitRepo(cwd: string): Promise<GitInitResult> {
   }
 }
 
-// Writes the LLM provider's API key to `.env` (under its provider-specific
-// env var, e.g. OPENAI_API_KEY or FIREWORKS_API_KEY) and the channel adapter
-// tokens to `secrets.json#channels`. Two stores on purpose: api-keys land in
-// `.env` to match the `--env-file .env` boot contract (env-wins: `auth.ts`
-// reads the value at runtime via `setRuntimeApiKey` and never persists it to
-// `secrets.json`, see `src/agent/auth.ts`); channel tokens skip the .env hop
-// entirely and land in `secrets.json#channels` as `{ value }` Secrets that
-// `hydrateChannelEnvFromSecrets` injects into `process.env` only when the
-// canonical env var is unset, see `src/secrets/hydrate.ts`.
+// Writes LLM provider API keys to `secrets.json#providers` and channel adapter
+// tokens to `secrets.json#channels`. Both paths go through the structured
+// v2 secrets envelope so reruns can reuse existing values without depending on
+// host-stage env files.
 export async function writeSecrets(
   root: string,
   {
@@ -578,9 +584,7 @@ export async function writeSecrets(
     telegramBotToken,
   }: {
     model?: KnownModelRef
-    // Omitted on the OAuth path — credentials live in secrets.json instead.
-    // The .env file still gets written (empty) so post-init callers that
-    // read it don't ENOENT-crash.
+    // Omitted on the OAuth path — credentials live in secrets.json via the OAuth runner.
     apiKey?: string
     discordBotToken?: string
     slackBotToken?: string
@@ -590,12 +594,9 @@ export async function writeSecrets(
 ): Promise<void> {
   const providerId = providerForModelRef(model)
   const apiKeyEnv = KNOWN_PROVIDERS[providerId].apiKeyEnv
-  const lines: string[] = []
   if (apiKey !== undefined && apiKeyEnv !== null) {
-    lines.push(`${apiKeyEnv}=${apiKey}`)
+    createSecretsStoreForAgent(join(root, 'secrets.json')).set(providerId, { type: 'api_key', key: apiKey })
   }
-  const body = lines.length > 0 ? `${lines.join('\n')}\n` : ''
-  await writeFile(join(root, SECRETS_FILE), body)
 
   const channelTokens: Record<string, Record<string, Secret>> = {}
   if (discordBotToken !== undefined && discordBotToken !== '') {
@@ -623,6 +624,12 @@ export async function writeSecrets(
   backend.writeChannelsSync(merged)
 }
 
+export async function readExistingProviderApiKey(root: string, providerId: KnownProviderId): Promise<string | null> {
+  const provider = KNOWN_PROVIDERS[providerId]
+  if (provider.apiKeyEnv === null) return null
+  return new SecretsBackend(join(root, 'secrets.json')).tryReadProviderApiKeySync(providerId)
+}
+
 function isObjectRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null && !Array.isArray(value)
 }

package/src/reload/client.ts

@@ -16,22 +16,36 @@ export async function requestReload({
   timeoutMs = DEFAULT_TIMEOUT_MS,
 }: RequestReloadOptions): Promise<ReloadResult[]> {
   const ws = new WebSocket(url)
+  const displayUrl = redactUrl(url)
 
   await new Promise<void>((resolve, reject) => {
+    let timer: ReturnType<typeof setTimeout> | undefined
     const onOpen = () => {
       cleanup()
       resolve()
     }
     const onError = (err: unknown) => {
       cleanup()
-      reject(err instanceof Error ? err : new Error(`failed to connect to ${url}`))
+      reject(new Error(`failed to connect to ${displayUrl}: ${err instanceof Error ? err.message : String(err)}`))
+    }
+    const onClose = () => {
+      cleanup()
+      reject(new Error(`connection to ${displayUrl} closed before opening`))
     }
     const cleanup = () => {
+      if (timer !== undefined) clearTimeout(timer)
       ws.removeEventListener('open', onOpen)
       ws.removeEventListener('error', onError)
+      ws.removeEventListener('close', onClose)
     }
+    timer = setTimeout(() => {
+      cleanup()
+      ws.close()
+      reject(new Error(`timed out connecting to ${displayUrl} after ${timeoutMs}ms`))
+    }, timeoutMs)
     ws.addEventListener('open', onOpen, { once: true })
     ws.addEventListener('error', onError, { once: true })
+    ws.addEventListener('close', onClose, { once: true })
   })
 
   try {
@@ -57,3 +71,13 @@ export async function requestReload({
     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/run/index.ts

@@ -87,6 +87,8 @@ export async function startAgent({
   // which is what we want, since there is no host daemon to honor it anyway.
   const containerName = process.env.TYPECLAW_CONTAINER_NAME
   const containerNameOpt = containerName !== undefined ? { containerName } : {}
+  const tuiToken = process.env.TYPECLAW_TUI_TOKEN
+  const tuiTokenOpt = tuiToken !== undefined && tuiToken !== '' ? { tuiToken } : {}
   reloadRegistry.register(createConfigReloadable({ cwd }))
 
   const pluginConfigsByName = loadPluginConfigsSync(cwd)
@@ -312,6 +314,7 @@ export async function startAgent({
     agentDir: cwd,
     pluginRuntime,
     ...containerNameOpt,
+    ...tuiTokenOpt,
     ...containerBrokerOpt,
   }).start()
 
@@ -343,7 +346,9 @@ export async function startAgent({
     }
   }
 
-  const url = `ws://localhost:${server.port}`
+  const serverPort = server.port
+  if (serverPort === undefined) throw new Error('server did not report a listening port')
+  const url = buildLocalTuiUrl(serverPort, tuiTokenOpt.tuiToken ?? null)
   const tui = createTui({ url, initialPrompt })
   const tuiPromise = tui.run()
   return {
@@ -361,6 +366,13 @@ export async function startAgent({
   }
 }
 
+function buildLocalTuiUrl(port: number, token: string | null): string {
+  if (token === null) return `ws://localhost:${port}`
+  const url = new URL(`ws://localhost:${port}`)
+  url.searchParams.set('token', token)
+  return url.toString()
+}
+
 async function disposeMaterializedSkills(pluginRuntime: PluginRuntime): Promise<void> {
   const pending = pluginRuntime.drainPendingDisposal()
   const current = pluginRuntime.get().materializedSkills

package/src/secrets/storage.ts

@@ -160,6 +160,21 @@ export class SecretsBackend implements AuthStorageBackend {
     }
   }
 
+  tryReadProviderApiKeySync(providerId: string, env: NodeJS.ProcessEnv = process.env): string | null {
+    if (!existsSync(this.secretsPath)) return null
+    let release: (() => void) | undefined
+    try {
+      release = this.acquireSyncLockWithRetry()
+      const credential = this.readEnvelope().providers[providerId]
+      if (credential?.type !== 'api_key') return null
+      const resolved =
+        resolveSecret(credential.key, providerKeyDefaultEnv(providerId), env) ?? credential.key.value ?? ''
+      return resolved.trim() !== '' ? resolved : null
+    } finally {
+      release?.()
+    }
+  }
+
   writeChannelsSync(next: Channels): void {
     this.ensureParentDir()
     this.ensureFileExists()

package/src/server/index.ts

@@ -31,6 +31,7 @@ export type ServerOptions = {
   agentDir?: string
   pluginRuntime?: PluginRuntime
   containerName?: string
+  tuiToken?: string
   // Optional in-process portbroker handler. When provided, requests to the
   // /portbroker WS path are routed to it instead of being treated as TUI
   // sessions. Omit to keep TUI-only behavior (used by tests + non-container
@@ -82,6 +83,7 @@ export function createServer({
   agentDir,
   pluginRuntime,
   containerName,
+  tuiToken,
   containerBroker,
 }: ServerOptions) {
   const sessionStates = new WeakMap<Ws, SessionState>()
@@ -97,6 +99,9 @@ export function createServer({
           if (server.upgrade(req, { data })) return
           return new Response('upgrade failed', { status: 400 })
         }
+        if (isWebSocketUpgrade(req) && tuiToken !== undefined && url.searchParams.get('token') !== tuiToken) {
+          return new Response('unauthorized', { status: 401 })
+        }
         const sessionId = crypto.randomUUID()
         const data: TuiWsData = { kind: 'tui', sessionId }
         if (server.upgrade(req, { data })) return
@@ -109,73 +114,80 @@ export function createServer({
             return
           }
           const ws = rawWs as Ws
-          const sessionManager = sessionFactory?.createPersisted()
-          const sessionFileId = sessionManager?.getSessionId() ?? ws.data.sessionId
-          // Snapshot the runtime once so the entire session lifecycle for this
-          // ws connection sees one consistent generation of registry+hooks. A
-          // reload landing mid-connection swaps the live pointer; this session
-          // keeps using the snapshot it was created with until close.
-          const runtimeSnapshot = pluginRuntime?.get()
-          const pluginsWiring =
-            runtimeSnapshot !== undefined && agentDir !== undefined
-              ? {
-                  registry: runtimeSnapshot.registry,
-                  hooks: runtimeSnapshot.hooks,
-                  sessionId: sessionFileId,
-                  agentDir,
-                }
-              : undefined
-          const origin: SessionOrigin = { kind: 'tui', sessionId: sessionFileId }
-          const result = await createSession({
-            reloadRegistry,
-            sessionManager,
-            origin,
-            ...(stream ? { stream } : {}),
-            ...(channelRouter ? { channelRouter } : {}),
-            ...(pluginsWiring ? { plugins: pluginsWiring } : {}),
-            ...(containerName !== undefined ? { containerName } : {}),
-          })
-          const session = 'session' in result ? result.session : result
-          const dispose = 'session' in result && result.dispose ? result.dispose : async () => {}
-
-          const state: SessionState = {
-            session,
-            sessionFileId,
-            origin,
-            sessionManager,
-            drainQueue: [],
-            draining: false,
-            unsubBroadcast: null,
-            unsubPrompts: null,
-            runtimeSnapshot: runtimeSnapshot ?? null,
-            dispose,
-          }
-          sessionStates.set(ws, state)
+          try {
+            const sessionManager = sessionFactory?.createPersisted()
+            const sessionFileId = sessionManager?.getSessionId() ?? ws.data.sessionId
+            // Snapshot the runtime once so the entire session lifecycle for this
+            // ws connection sees one consistent generation of registry+hooks. A
+            // reload landing mid-connection swaps the live pointer; this session
+            // keeps using the snapshot it was created with until close.
+            const runtimeSnapshot = pluginRuntime?.get()
+            const pluginsWiring =
+              runtimeSnapshot !== undefined && agentDir !== undefined
+                ? {
+                    registry: runtimeSnapshot.registry,
+                    hooks: runtimeSnapshot.hooks,
+                    sessionId: sessionFileId,
+                    agentDir,
+                  }
+                : undefined
+            const origin: SessionOrigin = { kind: 'tui', sessionId: sessionFileId }
+            const result = await createSession({
+              reloadRegistry,
+              sessionManager,
+              origin,
+              ...(stream ? { stream } : {}),
+              ...(channelRouter ? { channelRouter } : {}),
+              ...(pluginsWiring ? { plugins: pluginsWiring } : {}),
+              ...(containerName !== undefined ? { containerName } : {}),
+            })
+            const session = 'session' in result ? result.session : result
+            const dispose = 'session' in result && result.dispose ? result.dispose : async () => {}
+
+            const state: SessionState = {
+              session,
+              sessionFileId,
+              origin,
+              sessionManager,
+              drainQueue: [],
+              draining: false,
+              unsubBroadcast: null,
+              unsubPrompts: null,
+              runtimeSnapshot: runtimeSnapshot ?? null,
+              dispose,
+            }
+            sessionStates.set(ws, state)
 
-          if (runtimeSnapshot !== undefined && agentDir !== undefined) {
-            await runtimeSnapshot.hooks.runSessionStart({ sessionId: sessionFileId, agentDir })
-          }
+            if (runtimeSnapshot !== undefined && agentDir !== undefined) {
+              await runtimeSnapshot.hooks.runSessionStart({ sessionId: sessionFileId, agentDir })
+            }
 
-          forwardSessionEvents(ws, session)
-
-          if (stream) {
-            state.unsubPrompts = stream.subscribe({ target: { kind: 'session', sessionId: sessionFileId } }, (msg) =>
-              enqueuePrompt(ws, state, msg, agentDir),
-            )
-
-            state.unsubBroadcast = stream.subscribe({ target: { kind: 'broadcast' } }, (msg) => {
-              const payload: ServerMessage = {
-                type: 'notification',
-                payload: msg.payload,
-                ...(msg.replyTo !== undefined ? { replyTo: msg.replyTo } : {}),
-                ...(msg.meta !== undefined ? { meta: msg.meta } : {}),
-              }
-              send(ws, payload)
-            })
-          }
+            forwardSessionEvents(ws, session)
 
-          send(ws, { type: 'connected', sessionId: sessionFileId })
-          console.log(`session ${sessionFileId}: open`)
+            if (stream) {
+              state.unsubPrompts = stream.subscribe({ target: { kind: 'session', sessionId: sessionFileId } }, (msg) =>
+                enqueuePrompt(ws, state, msg, agentDir),
+              )
+
+              state.unsubBroadcast = stream.subscribe({ target: { kind: 'broadcast' } }, (msg) => {
+                const payload: ServerMessage = {
+                  type: 'notification',
+                  payload: msg.payload,
+                  ...(msg.replyTo !== undefined ? { replyTo: msg.replyTo } : {}),
+                  ...(msg.meta !== undefined ? { meta: msg.meta } : {}),
+                }
+                send(ws, payload)
+              })
+            }
+
+            send(ws, { type: 'connected', sessionId: sessionFileId })
+            console.log(`session ${sessionFileId}: open`)
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err)
+            console.error(`session ${ws.data.sessionId}: open failed: ${message}`)
+            send(ws, { type: 'error', message })
+            ws.close()
+          }
         },
         async message(rawWs, raw) {
           if (rawWs.data.kind === 'portbroker') {
@@ -289,6 +301,10 @@ export function createServer({
   return { start }
 }
 
+function isWebSocketUpgrade(req: Request): boolean {
+  return req.headers.get('upgrade')?.toLowerCase() === 'websocket'
+}
+
 function forwardSessionEvents(ws: Ws, session: AgentSession): void {
   const toolStartedAt = new Map<string, number>()