@defrex/autobuild 0.8.0

package/packages/core/src/config/live.ts

@@ -0,0 +1,255 @@
+import { parseConfig } from './load'
+import type { Config, TicketsConfig } from './schema'
+import { createRuntimeResolver, type RuntimeResolver } from '../ports/runner/routing'
+import type { RuntimeRegistry } from '../ports/runner/runtime'
+
+/** Exact repository artifact kind used for accepted dispatcher config revisions. */
+export const DISPATCHER_CONFIG_ARTIFACT = 'dispatcher-config'
+
+/**
+ * Explicit hot/restart classification for every strict root field. Open maps
+ * are classified at their owning table: their entries all share that table's
+ * behavior.
+ */
+export const CONFIG_RELOAD_CLASSIFICATION = {
+  baseBranch: 'hot',
+  capacity: 'hot',
+  forge: 'restart',
+  plugins: 'restart',
+  pr: 'hot',
+  workspace: {
+    provider: 'restart',
+    config: 'restart',
+  },
+  commands: 'hot',
+  verify: 'hot',
+  finalize: 'hot',
+  roles: 'hot',
+  policy: 'hot',
+  orchestrator: 'restart',
+  tickets: {
+    source: 'restart',
+    readyLabels: 'hot',
+    readyState: 'hot',
+    teamKey: 'restart',
+    claimedState: 'restart',
+    createState: 'restart',
+    triageState: 'hot',
+    proposalState: 'hot',
+    dir: 'restart',
+  },
+} as const satisfies {
+  [K in keyof Config]: K extends 'workspace'
+    ? { [P in keyof Config['workspace']]: 'hot' | 'restart' }
+    : K extends 'tickets'
+      ? { [P in keyof TicketsConfig]: 'hot' | 'restart' }
+      : 'hot' | 'restart'
+}
+
+export const RESTART_REQUIRED_CONFIG_PATHS = [
+  'forge',
+  'plugins',
+  'workspace.provider',
+  'workspace.config',
+  'orchestrator',
+  'tickets.source',
+  'tickets.teamKey',
+  'tickets.claimedState',
+  'tickets.createState',
+  'tickets.dir',
+] as const
+export type RestartRequiredConfigPath = (typeof RESTART_REQUIRED_CONFIG_PATHS)[number]
+
+function same(left: unknown, right: unknown): boolean {
+  return JSON.stringify(left) === JSON.stringify(right)
+}
+
+/** Paths whose candidate values cannot replace startup-constructed adapters. */
+export function restartRequiredChanges(
+  startup: Config,
+  candidate: Config,
+): RestartRequiredConfigPath[] {
+  const changed: RestartRequiredConfigPath[] = []
+  const compare = (
+    path: (typeof RESTART_REQUIRED_CONFIG_PATHS)[number],
+    a: unknown,
+    b: unknown,
+  ) => {
+    if (!same(a, b)) changed.push(path)
+  }
+  compare('forge', startup.forge, candidate.forge)
+  compare('plugins', startup.plugins, candidate.plugins)
+  compare('workspace.provider', startup.workspace.provider, candidate.workspace.provider)
+  compare('workspace.config', startup.workspace.config, candidate.workspace.config)
+  compare('tickets.source', startup.tickets.source, candidate.tickets.source)
+  compare('tickets.teamKey', startup.tickets.teamKey, candidate.tickets.teamKey)
+  compare('tickets.claimedState', startup.tickets.claimedState, candidate.tickets.claimedState)
+  compare('tickets.createState', startup.tickets.createState, candidate.tickets.createState)
+  compare('tickets.dir', startup.tickets.dir, candidate.tickets.dir)
+  compare('orchestrator', startup.orchestrator, candidate.orchestrator)
+  return changed
+}
+
+/** Overlay all hot fields while retaining every startup-built adapter field. */
+export function composeReloadedConfig(startup: Config, candidate: Config): Config {
+  return {
+    ...candidate,
+    forge: startup.forge,
+    plugins: startup.plugins,
+    workspace: startup.workspace,
+    orchestrator: startup.orchestrator,
+    tickets: {
+      ...candidate.tickets,
+      source: startup.tickets.source,
+      teamKey: startup.tickets.teamKey,
+      claimedState: startup.tickets.claimedState,
+      createState: startup.tickets.createState,
+      dir: startup.tickets.dir,
+    },
+  }
+}
+
+export interface ConfigSnapshot {
+  readonly config: Config
+  readonly resolver: RuntimeResolver
+  /** Process-local revision. Zero is the startup file. */
+  readonly revision: number
+}
+
+export type ConfigReloadOutcome =
+  | { kind: 'unchanged' }
+  | { kind: 'rejected'; error: string; notify: boolean }
+  | { kind: 'publication-failed'; error: string }
+  | {
+      kind: 'adopted'
+      snapshot: ConfigSnapshot
+      restartRequired: RestartRequiredConfigPath[]
+      effectiveChanged: boolean
+    }
+
+export type ConfigReloadPublisher = (input: {
+  content: string
+  /** Fully composed snapshot that will become current after publication. */
+  effectiveConfig: Config
+  restartRequired: readonly RestartRequiredConfigPath[]
+  effectiveChanged: boolean
+}) => Promise<void>
+
+/**
+ * Process-local owner of the dispatcher's effective config. A candidate is
+ * published only after parsing, eager route validation, and durable journal
+ * publication all succeed. Callers capture `current()` once per boundary.
+ */
+export class LiveConfig {
+  private snapshot: ConfigSnapshot
+  private acceptedContent: string
+  private rejectedContent: string | undefined
+
+  constructor(
+    private readonly source: string,
+    private readonly startup: Config,
+    startupContent: string,
+    private readonly runtimes: RuntimeRegistry,
+    private readonly publish: ConfigReloadPublisher,
+  ) {
+    this.acceptedContent = startupContent
+    this.snapshot = {
+      config: startup,
+      resolver: createRuntimeResolver(runtimes, startup.roles, startup.policy.sessionBudgetSeconds),
+      revision: 0,
+    }
+  }
+
+  current(): ConfigSnapshot {
+    return this.snapshot
+  }
+
+  async refreshFromDisk(): Promise<ConfigReloadOutcome> {
+    return this.refreshFrom(() => Bun.file(this.source).text())
+  }
+
+  /** Reload from any content source — the startup file (refreshFromDisk) or,
+   * in checkout-less origin mode, the base branch's autobuild.toml fetched
+   * through the forge. Read failures take the same rejected-read path: the
+   * last valid snapshot remains active and the error is reported once per
+   * distinct failure. */
+  async refreshFrom(read: () => Promise<string>): Promise<ConfigReloadOutcome> {
+    let content: string
+    try {
+      content = await read()
+    } catch (error) {
+      const code = (error as NodeJS.ErrnoException).code
+      const detail =
+        code === 'ENOENT'
+          ? 'is missing during live reload'
+          : `could not be read during live reload: ${
+              error instanceof Error ? error.message : String(error)
+            }`
+      const message =
+        `${this.source} ${detail}; the last valid configuration snapshot remains active — ` +
+        'restore a valid autobuild.toml to resume live reload'
+      const rejectedRead = `\0${message}`
+      const notify = this.rejectedContent !== rejectedRead
+      this.rejectedContent = rejectedRead
+      return { kind: 'rejected', error: message, notify }
+    }
+    return this.refresh(content)
+  }
+
+  async refresh(content: string): Promise<ConfigReloadOutcome> {
+    if (content === this.acceptedContent) {
+      this.rejectedContent = undefined
+      return { kind: 'unchanged' }
+    }
+
+    let candidate: Config
+    try {
+      candidate = parseConfig(content, this.source)
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error)
+      const notify = this.rejectedContent !== content
+      this.rejectedContent = content
+      return { kind: 'rejected', error: message, notify }
+    }
+
+    const config = composeReloadedConfig(this.startup, candidate)
+    let resolver: RuntimeResolver
+    try {
+      resolver = createRuntimeResolver(
+        this.runtimes,
+        config.roles,
+        config.policy.sessionBudgetSeconds,
+      )
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error)
+      const notify = this.rejectedContent !== content
+      this.rejectedContent = content
+      return { kind: 'rejected', error: message, notify }
+    }
+
+    const restartRequired = restartRequiredChanges(this.startup, candidate)
+    const effectiveChanged = !same(this.snapshot.config, config)
+    try {
+      await this.publish({ content, effectiveConfig: config, restartRequired, effectiveChanged })
+    } catch (error) {
+      return {
+        kind: 'publication-failed',
+        error: error instanceof Error ? error.message : String(error),
+      }
+    }
+
+    this.acceptedContent = content
+    this.rejectedContent = undefined
+    this.snapshot = {
+      config,
+      resolver,
+      revision: this.snapshot.revision + 1,
+    }
+    return {
+      kind: 'adopted',
+      snapshot: this.snapshot,
+      restartRequired,
+      effectiveChanged,
+    }
+  }
+}

package/packages/core/src/config/load.ts

@@ -0,0 +1,98 @@
+/**
+ * autobuild.toml loading (SPEC §16.1, D9).
+ *
+ * Branch-owned worktree config and supplied immutable text are parsed as
+ * one-shot inputs: `parseConfig(text)` is the primary API, while
+ * `loadConfig(path)` is a disk convenience for scoped CLI and local tooling.
+ * The running dispatcher has a separate live-reload context: `LiveConfig`
+ * reads the main checkout, retains its last valid snapshot across rejected
+ * candidates, and lets each action capture the current snapshot at its boundary.
+ */
+import { parse as parseToml, TomlError } from 'smol-toml'
+import type { z } from 'zod'
+import { expandIssues } from '../zod-issues'
+import { configSchema, TOP_LEVEL_SCALARS, TOP_LEVEL_TABLES, type Config } from './schema'
+
+/**
+ * Config failures are feedback to whoever edits the file: the message carries
+ * the source name, the path of every problem, and what would be accepted.
+ */
+export class ConfigError extends Error {
+  constructor(
+    message: string,
+    readonly issues?: unknown,
+  ) {
+    super(message)
+    this.name = 'ConfigError'
+  }
+}
+
+function formatPath(path: ReadonlyArray<PropertyKey>): string {
+  if (path.length === 0) return '(top level)'
+  return path
+    .map((segment, index) =>
+      typeof segment === 'number'
+        ? `[${segment}]`
+        : index === 0
+          ? String(segment)
+          : `.${String(segment)}`,
+    )
+    .join('')
+}
+
+function describeIssue(issue: z.core.$ZodIssue): string {
+  let message = issue.message
+  if (issue.code === 'unrecognized_keys' && issue.path.length === 0) {
+    if (issue.keys.includes('agent')) {
+      message +=
+        ' — [agent] was removed; move those fields to [roles.default] ' +
+        '(the default entry in [roles])'
+    }
+    if (issue.keys.includes('server')) {
+      message +=
+        ' — [server] was removed; arrange any application lifecycle inside the verify command or skill'
+    }
+    message +=
+      ` — known top-level keys: ${TOP_LEVEL_SCALARS.join(', ')}; ` +
+      `known tables: ${TOP_LEVEL_TABLES.join(', ')}`
+  }
+  const removedNeedsServer =
+    (issue.code === 'unrecognized_keys' && issue.keys.includes('needsServer')) ||
+    message.includes('"needsServer"')
+  if (removedNeedsServer) {
+    message +=
+      " — needsServer was removed; arrange any application lifecycle inside this step's command or skill"
+  }
+  const path =
+    removedNeedsServer && issue.path.at(-1) !== 'needsServer'
+      ? [...issue.path, 'needsServer']
+      : issue.path
+  return `  ${formatPath(path)}: ${message}`
+}
+
+export function parseConfig(tomlText: string, source = 'autobuild.toml'): Config {
+  let table: unknown
+  try {
+    table = parseToml(tomlText)
+  } catch (error) {
+    if (error instanceof TomlError) {
+      throw new ConfigError(`${source}: TOML syntax error: ${error.message}`)
+    }
+    throw error
+  }
+
+  const result = configSchema.safeParse(table)
+  if (!result.success) {
+    // Expanded for the operator, raw for the payload: the expanded copies carry
+    // synthesized `option N of M:` messages, while `ConfigError.issues` should
+    // stay what validation actually reported.
+    const details = expandIssues(result.error.issues).map(describeIssue).join('\n')
+    throw new ConfigError(`${source}: invalid config\n${details}`, result.error.issues)
+  }
+  return result.data
+}
+
+export async function loadConfig(path: string): Promise<Config> {
+  const text = await Bun.file(path).text()
+  return parseConfig(text, path)
+}