typeclaw 0.1.1 → 0.1.3

package/src/hostd/daemon.ts

@@ -7,6 +7,8 @@ import type { Socket, UnixSocketListener } from 'bun'
 import type { PortForward } from '@/config'
 import { defaultDockerExec, type DockerExec } from '@/container'
 import type { PortForwardEvent } from '@/portbroker'
+import { kakaoChannelBlockSchema } from '@/secrets/schema'
+import { SecretsBackend } from '@/secrets/storage'
 
 import { isDaemonReachable } from './client'
 import { ensureDirs, registrationFilePath, registrationsDir, socketPath } from './paths'
@@ -16,6 +18,7 @@ import type {
   Request,
   Response as RpcResponse,
   RestartResult,
+  SecretsPatchResult,
   ShutdownResult,
   StatusResult,
   VersionResult,
@@ -351,6 +354,26 @@ export async function startDaemon(opts: DaemonOptions = {}): Promise<Daemon> {
     return { ok: true, result }
   }
 
+  const handleSecretsPatch = async (req: {
+    containerName: string
+    patch: { channels: { kakaotalk: unknown } }
+  }): Promise<RpcResponse> =>
+    runSerially(req.containerName, async () => {
+      const cwd = cwds.get(req.containerName)
+      if (!cwd) return { ok: false, reason: `not registered: ${req.containerName}` }
+      const parsed = kakaoChannelBlockSchema.safeParse(req.patch?.channels?.kakaotalk)
+      if (!parsed.success) {
+        return { ok: false, reason: parsed.error.issues.map((issue) => issue.message).join('; ') }
+      }
+      const backend = new SecretsBackend(join(cwd, 'secrets.json'))
+      await backend.updateChannelsAsync(async (channels) => ({
+        result: undefined,
+        next: { ...channels, kakaotalk: parsed.data },
+      }))
+      const result: SecretsPatchResult = { containerName: req.containerName, patched: true }
+      return { ok: true, result }
+    })
+
   const handleHttpInfo = (): RpcResponse => {
     const result: HttpInfoResult = { port: httpPort }
     return { ok: true, result }
@@ -392,6 +415,8 @@ export async function startDaemon(opts: DaemonOptions = {}): Promise<Daemon> {
         return handleStatus(req)
       case 'restart':
         return handleRestart(req)
+      case 'secrets-patch':
+        return handleSecretsPatch(req)
       case 'http-info':
         return handleHttpInfo()
       case 'version':
@@ -454,13 +479,13 @@ export async function startDaemon(opts: DaemonOptions = {}): Promise<Daemon> {
     } catch {
       return json({ ok: false, reason: 'invalid request json' }, 400)
     }
-    if (rpc.kind !== 'restart') {
-      return json({ ok: false, reason: 'http transport only supports restart' }, 403)
+    if (rpc.kind !== 'restart' && rpc.kind !== 'secrets-patch') {
+      return json({ ok: false, reason: 'http transport only supports restart and secrets-patch' }, 403)
     }
     if (restartTokens.get(rpc.containerName) !== token) {
       return json({ ok: false, reason: 'invalid restart token' }, 403)
     }
-    return json(await handleRestart(rpc))
+    return json(rpc.kind === 'restart' ? await handleRestart(rpc) : await handleSecretsPatch(rpc))
   }
 
   const httpHostname = opts.httpHost ?? '0.0.0.0'

package/src/hostd/protocol.ts

@@ -1,4 +1,5 @@
 import type { PortForward } from '@/config'
+import type { KakaoChannelBlock } from '@/secrets/schema'
 
 export type Request =
   | {
@@ -14,6 +15,7 @@ export type Request =
   | { kind: 'list' }
   | { kind: 'status'; containerName: string }
   | { kind: 'restart'; containerName: string; build?: boolean }
+  | { kind: 'secrets-patch'; containerName: string; patch: { channels: { kakaotalk: KakaoChannelBlock } } }
   | { kind: 'http-info' }
   | { kind: 'version' }
   | { kind: 'shutdown' }
@@ -35,6 +37,11 @@ export type RestartResult = {
   scheduled: true
 }
 
+export type SecretsPatchResult = {
+  containerName: string
+  patched: true
+}
+
 export type HttpInfoResult = {
   port: number
 }

package/src/init/auto-upgrade.ts

@@ -0,0 +1,368 @@
+import { existsSync, readFileSync } from 'node:fs'
+import { readFile, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+
+import { resolveScaffoldVersion } from './cli-version'
+
+const PACKAGE_FILE = 'package.json'
+const TYPECLAW = 'typeclaw'
+
+// Two semver quirks drive every branch in this module:
+//
+// 1. Pre-1.0 caret: `^0.1.0` resolves to `>=0.1.0 <0.2.0`. A CLI bump from
+//    0.1.x to 0.2.0 falls OUT of the agent's range, so we must rewrite the
+//    spec for those crossings.
+//
+// 2. `bun install` honors the lockfile: when the lockfile entry already
+//    satisfies the declared spec, `bun install` is a no-op even if a newer
+//    in-range version exists upstream. To actually upgrade an in-range dep
+//    we MUST use `bun update <pkg> --latest`. See src/init/run-bun-install.ts.
+//
+// The decision matrix anchors on the INSTALLED version (the truth), not the
+// declared range floor (a promise the agent may not yet have kept).
+
+export type AutoUpgradeOutcome =
+  | { kind: 'skipped-dev-mode' }
+  | { kind: 'skipped-no-dep' }
+  | { kind: 'skipped-non-release-spec'; declared: string }
+  | { kind: 'skipped-already-running' }
+  | { kind: 'up-to-date'; installedVersion: string }
+  | { kind: 'exact-pin-respected'; declared: string; cliVersion: string }
+  | { kind: 'spec-rewritten'; from: string; to: string; cliVersion: string }
+  | { kind: 'reinstall-needed'; from: string; to: string }
+
+export type AutoUpgradeOptions = {
+  cwd: string
+  // Test seam: lets tests simulate dev-mode (null) and arbitrary release
+  // versions without depending on the test runner's actual CLI version.
+  scaffoldVersion?: string | null
+}
+
+export async function autoUpgradeTypeclawDep(options: AutoUpgradeOptions): Promise<AutoUpgradeOutcome> {
+  const { cwd } = options
+  const scaffold = options.scaffoldVersion !== undefined ? options.scaffoldVersion : resolveScaffoldVersion()
+  if (scaffold === null) return { kind: 'skipped-dev-mode' }
+
+  const cliVersion = stripCaret(scaffold)
+  if (cliVersion === null) return { kind: 'skipped-dev-mode' }
+
+  const pkg = await readAgentPackageJson(cwd)
+  if (pkg === null) return { kind: 'skipped-no-dep' }
+
+  const declared = pkg.parsed.dependencies?.[TYPECLAW]
+  if (typeof declared !== 'string') return { kind: 'skipped-no-dep' }
+
+  const declaredKind = classifyDepSpec(declared)
+  if (declaredKind.kind === 'non-release') {
+    return { kind: 'skipped-non-release-spec', declared }
+  }
+
+  const installed = readInstalledTypeclawVersion(cwd)
+
+  // "Upgrade only, never downgrade" — anchored on the INSTALLED version
+  // (the truth), with the declared range floor used ONLY when nothing is
+  // installed yet (best proxy for "what would land if bun install ran").
+  //
+  // Anchoring on `installed` first closes the half-applied-rewrite hole:
+  // a previous start may have written ^0.2.0 to package.json but failed
+  // its install, leaving node_modules at 0.1.x. The declared floor would
+  // wrongly say "up-to-date"; the installed version correctly says "retry."
+  if (installed !== null && compareReleaseVersions(installed, cliVersion) >= 0) {
+    return { kind: 'up-to-date', installedVersion: installed }
+  }
+  if (installed === null && declaredKind.kind !== 'exact') {
+    const declaredFloor = formatTriple(declaredKind.version)
+    if (compareReleaseVersions(declaredFloor, cliVersion) >= 0) {
+      return { kind: 'up-to-date', installedVersion: declaredFloor }
+    }
+  }
+
+  if (declaredKind.kind === 'exact') {
+    const declaredVersion = formatTriple(declaredKind.version)
+    // Exact pin matches CLI but installed is stale (or missing): we still
+    // need to install. The user wrote the right spec — they just haven't
+    // materialized it yet. Return reinstall-needed; caller will run
+    // `bun update typeclaw --latest` against that exact spec.
+    if (declaredVersion === cliVersion) {
+      return { kind: 'reinstall-needed', from: installed ?? '<missing>', to: cliVersion }
+    }
+    // Exact pin diverges from CLI. User intent wins; we warn but never
+    // rewrite. If installed is ALSO ahead of CLI (e.g. exact pin 0.1.5,
+    // CLI 0.1.2), the up-to-date check above already returned.
+    return { kind: 'exact-pin-respected', declared, cliVersion }
+  }
+
+  if (!rangeSatisfies(declaredKind, cliVersion)) {
+    const newSpec = `^${cliVersion}`
+    await writeDepSpec(cwd, pkg.raw, pkg.parsed, newSpec)
+    return { kind: 'spec-rewritten', from: declared, to: newSpec, cliVersion }
+  }
+
+  // Declared range includes CLI. Three sub-cases:
+  //   - installed === null: fresh agent, nothing on disk yet. ensureDeps
+  //     will install for the missing-dep reason; nothing for us to add.
+  //   - installed > CLI but in range: we already returned up-to-date above.
+  //   - installed < CLI: force an upgrade via `bun update typeclaw --latest`.
+  if (installed === null) {
+    return { kind: 'up-to-date', installedVersion: cliVersion }
+  }
+  return { kind: 'reinstall-needed', from: installed, to: cliVersion }
+}
+
+export function outcomeForcesInstall(outcome: AutoUpgradeOutcome): boolean {
+  return outcome.kind === 'spec-rewritten' || outcome.kind === 'reinstall-needed'
+}
+
+// The version we expect to find in node_modules/typeclaw after the
+// auto-upgrade-triggered install completes. Callers use this to verify
+// the install actually moved the on-disk version (not just resolved the
+// lockfile). Returns null when no install was forced — verification is
+// skipped on no-op outcomes.
+export function expectedInstalledAfterUpgrade(outcome: AutoUpgradeOutcome): string | null {
+  if (outcome.kind === 'spec-rewritten') return outcome.cliVersion
+  if (outcome.kind === 'reinstall-needed') return outcome.to
+  return null
+}
+
+export function describeAutoUpgrade(outcome: AutoUpgradeOutcome): string {
+  switch (outcome.kind) {
+    case 'spec-rewritten':
+      return `Upgrading agent typeclaw ${outcome.from} → ${outcome.to} to match CLI`
+    case 'reinstall-needed':
+      return `Upgrading agent typeclaw ${outcome.from} → ${outcome.to} to match CLI`
+    case 'exact-pin-respected':
+      return `Agent typeclaw is exact-pinned to ${outcome.declared}; CLI is ${outcome.cliVersion}. Not upgrading (remove the exact pin to allow auto-upgrade).`
+    default:
+      return ''
+  }
+}
+
+export function readInstalledTypeclawVersionFromAgent(cwd: string): string | null {
+  return readInstalledTypeclawVersion(cwd)
+}
+
+type ParsedPackage = {
+  raw: string
+  parsed: { dependencies?: Record<string, string> } & Record<string, unknown>
+}
+
+async function readAgentPackageJson(cwd: string): Promise<ParsedPackage | null> {
+  const path = join(cwd, PACKAGE_FILE)
+  if (!existsSync(path)) return null
+  let raw: string
+  try {
+    raw = await readFile(path, 'utf8')
+  } catch {
+    return null
+  }
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(raw)
+  } catch {
+    return null
+  }
+  if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) return null
+  return { raw, parsed: parsed as ParsedPackage['parsed'] }
+}
+
+function readInstalledTypeclawVersion(cwd: string): string | null {
+  const path = join(cwd, 'node_modules', TYPECLAW, PACKAGE_FILE)
+  if (!existsSync(path)) return null
+  let raw: string
+  try {
+    raw = readFileSync(path, 'utf8')
+  } catch {
+    return null
+  }
+  try {
+    const parsed = JSON.parse(raw) as { version?: string }
+    if (typeof parsed.version === 'string' && isReleaseVersion(parsed.version)) return parsed.version
+  } catch {}
+  return null
+}
+
+type DepSpecKind =
+  | { kind: 'exact'; version: [number, number, number]; raw: string }
+  | { kind: 'caret'; version: [number, number, number] }
+  | { kind: 'tilde'; version: [number, number, number] }
+  | { kind: 'non-release' }
+
+function classifyDepSpec(spec: string): DepSpecKind {
+  const trimmed = spec.trim()
+  const exactMatch = trimmed.match(/^=?(\d+)\.(\d+)\.(\d+)$/)
+  if (exactMatch) {
+    const [, a, b, c] = exactMatch
+    return { kind: 'exact', version: parseTriple(a!, b!, c!), raw: trimmed }
+  }
+  const caretMatch = trimmed.match(/^\^(\d+)\.(\d+)\.(\d+)$/)
+  if (caretMatch) {
+    const [, a, b, c] = caretMatch
+    return { kind: 'caret', version: parseTriple(a!, b!, c!) }
+  }
+  const tildeMatch = trimmed.match(/^~(\d+)\.(\d+)\.(\d+)$/)
+  if (tildeMatch) {
+    const [, a, b, c] = tildeMatch
+    return { kind: 'tilde', version: parseTriple(a!, b!, c!) }
+  }
+  return { kind: 'non-release' }
+}
+
+function parseTriple(a: string, b: string, c: string): [number, number, number] {
+  return [Number.parseInt(a, 10), Number.parseInt(b, 10), Number.parseInt(c, 10)]
+}
+
+function formatTriple(v: [number, number, number]): string {
+  return `${v[0]}.${v[1]}.${v[2]}`
+}
+
+// npm/bun caret+tilde semantics, narrowed to plain X.Y.Z bases:
+//   ^0.1.2 → >=0.1.2 <0.2.0   (pre-1.0 caret pins minor — the bug we fix)
+//   ^1.2.3 → >=1.2.3 <2.0.0
+//   ~0.1.2 → >=0.1.2 <0.2.0
+//   ~1.2.3 → >=1.2.3 <1.3.0
+function rangeSatisfies(range: Exclude<DepSpecKind, { kind: 'exact' | 'non-release' }>, version: string): boolean {
+  const v = parseVersion(version)
+  if (v === null) return false
+  const [base, ceiling] = rangeBounds(range)
+  return compareTriples(v, base) >= 0 && compareTriples(v, ceiling) < 0
+}
+
+function rangeBounds(
+  range: Exclude<DepSpecKind, { kind: 'exact' | 'non-release' }>,
+): [[number, number, number], [number, number, number]] {
+  const [maj, min, pat] = range.version
+  if (range.kind === 'caret') {
+    if (maj > 0)
+      return [
+        [maj, min, pat],
+        [maj + 1, 0, 0],
+      ]
+    if (min > 0)
+      return [
+        [maj, min, pat],
+        [maj, min + 1, 0],
+      ]
+    return [
+      [maj, min, pat],
+      [maj, min, pat + 1],
+    ]
+  }
+  return [
+    [maj, min, pat],
+    [maj, min + 1, 0],
+  ]
+}
+
+function parseVersion(version: string): [number, number, number] | null {
+  const m = version.match(/^(\d+)\.(\d+)\.(\d+)$/)
+  if (!m) return null
+  const [, a, b, c] = m
+  return parseTriple(a!, b!, c!)
+}
+
+function compareTriples(a: [number, number, number], b: [number, number, number]): number {
+  for (let i = 0; i < 3; i++) {
+    const ai = a[i]!
+    const bi = b[i]!
+    if (ai !== bi) return ai - bi
+  }
+  return 0
+}
+
+function compareReleaseVersions(a: string, b: string): number {
+  const av = parseVersion(a)
+  const bv = parseVersion(b)
+  if (av === null || bv === null) return 0
+  return compareTriples(av, bv)
+}
+
+function stripCaret(scaffold: string): string | null {
+  const m = scaffold.match(/^\^?(\d+\.\d+\.\d+)$/)
+  return m ? (m[1] ?? null) : null
+}
+
+function isReleaseVersion(version: string): boolean {
+  return /^\d+\.\d+\.\d+$/.test(version)
+}
+
+async function writeDepSpec(cwd: string, raw: string, parsed: ParsedPackage['parsed'], newSpec: string): Promise<void> {
+  // Scoped edit: replace the typeclaw spec ONLY inside the dependencies
+  // object. The previous implementation used `raw.replace(/"typeclaw":.../)`
+  // unscoped, which would silently rewrite devDependencies.typeclaw if it
+  // appeared before dependencies.typeclaw in the file (the original spec
+  // never moves). We slice the dependencies object's textual range, edit
+  // inside it, then splice back to preserve whitespace, key order, and
+  // trailing newline. If the slice fails (unusual JSON shape), fall back
+  // to a full JSON round-trip — formatting churn is acceptable; silently
+  // updating the wrong key is not.
+  const scoped = sliceDependenciesRange(raw, parsed)
+  if (scoped !== null) {
+    const { start, end } = scoped
+    const block = raw.slice(start, end)
+    const replaced = block.replace(
+      /("typeclaw"\s*:\s*)"[^"]+"/,
+      (_m, prefix: string) => `${prefix}${JSON.stringify(newSpec)}`,
+    )
+    if (replaced !== block) {
+      await writeFile(join(cwd, PACKAGE_FILE), `${raw.slice(0, start)}${replaced}${raw.slice(end)}`)
+      return
+    }
+  }
+  const deps = { ...parsed.dependencies, [TYPECLAW]: newSpec }
+  const next = { ...parsed, dependencies: deps }
+  const indent = detectIndent(raw)
+  await writeFile(join(cwd, PACKAGE_FILE), `${JSON.stringify(next, null, indent)}\n`)
+}
+
+// Returns the [start, end) byte range of the "dependencies" object's value
+// in `raw`, or null if it can't be located unambiguously. Uses a brace-
+// counting tokenizer that respects string literals so a `dependencies` key
+// inside a string value (e.g. inside a `description`) cannot fool it.
+function sliceDependenciesRange(raw: string, parsed: ParsedPackage['parsed']): { start: number; end: number } | null {
+  if (parsed.dependencies === undefined || parsed.dependencies === null) return null
+  const keyMatch = raw.match(/"dependencies"\s*:\s*\{/)
+  if (!keyMatch || keyMatch.index === undefined) return null
+  const startOfOpenBrace = keyMatch.index + keyMatch[0].length - 1
+  const closeBrace = findMatchingCloseBrace(raw, startOfOpenBrace)
+  if (closeBrace === null) return null
+  return { start: startOfOpenBrace, end: closeBrace + 1 }
+}
+
+function findMatchingCloseBrace(raw: string, openIndex: number): number | null {
+  let depth = 0
+  let inString = false
+  let escape = false
+  for (let i = openIndex; i < raw.length; i++) {
+    const ch = raw[i]
+    if (escape) {
+      escape = false
+      continue
+    }
+    if (inString) {
+      if (ch === '\\') escape = true
+      else if (ch === '"') inString = false
+      continue
+    }
+    if (ch === '"') {
+      inString = true
+      continue
+    }
+    if (ch === '{') depth++
+    else if (ch === '}') {
+      depth--
+      if (depth === 0) return i
+    }
+  }
+  return null
+}
+
+function detectIndent(raw: string): number | string {
+  // Default to 2 — matches `JSON.stringify(_, _, 2)` behavior and the
+  // project's existing scaffold style. Only override when we can see a
+  // clear non-2 indent on the first indented line.
+  const match = raw.match(/\n([\t ]+)\S/)
+  if (!match) return 2
+  const sample = match[1]!
+  if (sample.startsWith('\t')) return '\t'
+  return sample.length
+}

package/src/init/cli-version.ts

@@ -0,0 +1,81 @@
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+// Single source of truth for "what version of typeclaw is this agent on,
+// and where does that mean we should pin the base image / write the dep
+// spec." Sync I/O at module load — relative paths are stable in both a dev
+// checkout and a real install, so the parent-walk an earlier draft used
+// was unnecessary side effect. See AGENTS.md "Rules of thumb" for the
+// install-vs-dev distinction this module encodes.
+
+export const GHCR_BASE_IMAGE_REPO = 'ghcr.io/typeclaw/typeclaw-base'
+
+const CLI_PACKAGE_JSON_PATH = join(import.meta.dir, '..', '..', 'package.json')
+
+const cliPkg = JSON.parse(readFileSync(CLI_PACKAGE_JSON_PATH, 'utf8')) as { name?: string; version?: string }
+if (cliPkg.name !== 'typeclaw' || typeof cliPkg.version !== 'string') {
+  throw new Error(`Expected typeclaw package.json at ${CLI_PACKAGE_JSON_PATH}, got name=${cliPkg.name}`)
+}
+
+export const CLI_VERSION = cliPkg.version
+
+const NODE_MODULES_SEGMENT = `${join('/', 'node_modules', '/')}`
+
+function isInstalledCli(): boolean {
+  return CLI_PACKAGE_JSON_PATH.includes(NODE_MODULES_SEGMENT)
+}
+
+// `^X.Y.Z` when the invoking CLI is itself an installed copy of typeclaw
+// (suitable for writing into a freshly-scaffolded agent's package.json),
+// `null` when the CLI is running from the source repo (caller falls back
+// to `file:` so the agent tracks the local checkout).
+export function resolveScaffoldVersion(): string | null {
+  if (!isInstalledCli()) return null
+  return `^${CLI_VERSION}`
+}
+
+// The version of typeclaw the AGENT will actually run inside the container.
+// Prefers `<agent>/node_modules/typeclaw/package.json#version` because that
+// is what the bind-mount exposes to the container at /agent/node_modules,
+// and we want the base image's CLI version to match the runtime's. Falls
+// back to parsing the agent's `dependencies.typeclaw` spec for fresh inits
+// where `bun install` hasn't run yet, and to `null` when neither maps to
+// a release version (dev mode, ranges, dist-tags, etc.).
+export function resolveBaseImageVersion(agentDir: string): string | null {
+  return readInstalledTypeclawVersion(agentDir) ?? readVersionFromDepSpec(agentDir)
+}
+
+function readInstalledTypeclawVersion(agentDir: string): string | null {
+  try {
+    const raw = readFileSync(join(agentDir, 'node_modules', 'typeclaw', 'package.json'), 'utf8')
+    const parsed = JSON.parse(raw) as { version?: string }
+    if (typeof parsed.version === 'string' && isReleaseVersion(parsed.version)) return parsed.version
+  } catch {}
+  return null
+}
+
+function readVersionFromDepSpec(agentDir: string): string | null {
+  try {
+    const raw = readFileSync(join(agentDir, 'package.json'), 'utf8')
+    const parsed = JSON.parse(raw) as { dependencies?: Record<string, string> }
+    const spec = parsed.dependencies?.typeclaw
+    if (typeof spec !== 'string') return null
+    return extractReleaseVersionFromSpec(spec)
+  } catch {
+    return null
+  }
+}
+
+// Accept only specs that name an exact release version we can map 1:1 to a
+// GHCR tag (`X.Y.Z`, `^X.Y.Z`, `~X.Y.Z`, `=X.Y.Z`). Reject ranges, `latest`,
+// `*`, dist-tags, `workspace:` / `git:` / `portal:` / `npm:` aliases. Being
+// strict here delays versioned pinning rather than silently picking the
+// wrong tag — the installed-typeclaw check above is the primary path.
+function extractReleaseVersionFromSpec(spec: string): string | null {
+  const match = spec.trim().match(/^[\^~=]?(\d+\.\d+\.\d+)$/)
+  return match ? (match[1] ?? null) : null
+}
+
+function isReleaseVersion(version: string): boolean {
+  return /^\d+\.\d+\.\d+$/.test(version)
+}