@defrex/autobuild 0.8.0

package/packages/core/src/open-map.ts

@@ -0,0 +1,203 @@
+/**
+ * The open-map preservation contract: author-chosen keys → strictly validated
+ * values, with EVERY declared key surviving validation verbatim.
+ *
+ * `z.record` and `z.looseObject` build their result by assignment, so a
+ * perfectly valid entry named `__proto__` invokes the legacy
+ * `Object.prototype.__proto__` setter instead of creating an own key. Parsing
+ * SUCCEEDS and the entry vanishes — never resolved, never selectable, and
+ * invisible to whatever diagnostic exists to catch dead configuration. A silent
+ * drop is the one outcome an otherwise strict validator must never produce.
+ *
+ * So these keep the key intact end to end: own descriptors in, `defineProperty`
+ * out, null prototype on the result. Consumers can then read an author-chosen
+ * key off these maps without `Object.hasOwn` ceremony, and a name nobody
+ * declared answers `undefined` rather than an inherited object member.
+ *
+ * The entry boundary keeps the other half of the same promise: it must not
+ * narrow what the value schema said. A value that validates *to* nothing is
+ * kept — success is carried in the result's `ok`, never inferred from the value,
+ * or a legitimately absent value would be read as a rejection and produce the
+ * silent drop above from the other direction. And a rejection reaches the map's
+ * caller as validation reported it — every issue forwarded whole, with only its
+ * path prefixed — because re-encoding an issue as prose discards the structure a
+ * diagnostic needs to say what was actually wrong (see `../zod-issues`).
+ *
+ * Two surfaces consume this. `autobuild.toml`'s open maps ([commands],
+ * [roles], [workspace.config], and the named [verify.<step>] / [finalize.<step>]
+ * table sets) are one; the plugin manifest's adapter maps (`ticketSources`,
+ * `agentRuntimes`, `workspaceProviders`, `forges`) are the other, whose keys are
+ * likewise author-chosen — there, by the plugin author rather than the operator.
+ */
+import { z } from 'zod'
+import { forwardIssues, type IssueSink } from './zod-issues'
+
+/** How an entry name is validated. Autobuild-owned maps must be able to address
+ * every entry, so a nameless one is dead configuration; a map whose names belong
+ * to a plugin is not Autobuild's to narrow. */
+export type OpenMapKeyPolicy = 'nonempty' | 'nonblank' | 'any'
+
+export interface OpenMapOptions {
+  keys?: OpenMapKeyPolicy
+  /** What the container is called when the input is not one. */
+  shape?: string
+}
+
+const DEFAULT_SHAPE = 'a table of named entries'
+
+function keyIsValid(key: string, policy: OpenMapKeyPolicy): boolean {
+  switch (policy) {
+    case 'nonempty':
+      return key.length > 0
+    case 'nonblank':
+      return key.trim().length > 0
+    case 'any':
+      return true
+  }
+}
+
+/**
+ * Whether a container is a plain record of named entries — a parsed TOML table
+ * (null prototype), an object literal, or any object built on top of those.
+ *
+ * The exclusions are load-bearing rather than pedantic. A `Map`, a `Set`, a
+ * `Date`, an array, or a class instance has no own string-keyed entries to
+ * collect, so accepting one would produce an EMPTY map from an input that
+ * plainly meant to declare something — the same silent drop this module exists
+ * to prevent, just arrived at from the other direction. `null` is rejected for
+ * the same reason: absence is spelled by omission, which `openMap`'s
+ * `.prefault({})` turns into `{}` before this ever runs.
+ *
+ * The decision itself is `z.record`'s, deliberately: this module replaced that
+ * schema on the manifest surface, and a container it accepted must keep
+ * parsing. Hence "was it built by something other than a plain-object
+ * constructor" rather than an identity test against the local `Object` — which
+ * would turn away a record whose prototype declares a non-function
+ * `constructor`, one whose constructor prototype owns `isPrototypeOf`, and
+ * every plain object arriving from another realm.
+ *
+ * The one departure: `constructor` is read off the PROTOTYPE, never off
+ * `input`. Reading it off the input is what `z.record` does, and it is the same
+ * prototype hazard this module exists to close — a map declaring an adapter
+ * named `constructor` shadows the property the check depends on, and the whole
+ * container is rejected over an entry that is merely unusually named. Starting
+ * one link up cannot be shadowed by any declared entry, and answers identically
+ * for every container that does not declare that name.
+ */
+function isRecord(input: unknown): input is object {
+  if (typeof input !== 'object' || input === null) return false
+  const prototype = Object.getPrototypeOf(input)
+  if (prototype === null) return true
+  const builder = (prototype as { constructor?: unknown }).constructor
+  if (typeof builder !== 'function') return true
+  const builderPrototype: unknown = (builder as { prototype?: unknown }).prototype
+  if (typeof builderPrototype !== 'object' || builderPrototype === null) return false
+  return Object.hasOwn(builderPrototype, 'isPrototypeOf')
+}
+
+/**
+ * The own ENUMERABLE STRING entries of a parsed container, read BY DESCRIPTOR.
+ * `input[key]` is wrong here: on any object that has a prototype, reading
+ * `"__proto__"` answers that prototype rather than the declared entry.
+ *
+ * The key set is `z.record`'s — own and enumerable — because a container that
+ * schema collected must still be collected the same way. Non-enumerable
+ * properties are internal bookkeeping rather than declarations, and are skipped
+ * in both.
+ *
+ * An own enumerable SYMBOL is an error rather than a skip. `z.record` ran every
+ * own key through its string key schema, so a symbol failed validation and the
+ * whole container was invalid; passing over it silently instead would be the
+ * exact drop this module exists to prevent, applied to the one key shape that
+ * can never name an entry in the map it produces.
+ *
+ * `label` is rendered verbatim into the diagnostic — `'[roles]'` for a TOML
+ * table, `'forges'` for a manifest map.
+ */
+export function ownEntries(
+  input: unknown,
+  label: string,
+  ctx: IssueSink,
+  shape?: string,
+): [string, unknown][] {
+  if (!isRecord(input)) {
+    ctx.addIssue({ code: 'custom', message: `${label} must be ${shape ?? DEFAULT_SHAPE}` })
+    return []
+  }
+  for (const symbol of Object.getOwnPropertySymbols(input)) {
+    if (Object.getOwnPropertyDescriptor(input, symbol)?.enumerable !== true) continue
+    ctx.addIssue({
+      code: 'custom',
+      message: `${label} entry names must be strings; ${String(symbol)} cannot name an entry`,
+    })
+  }
+  const entries: [string, unknown][] = []
+  for (const key of Object.getOwnPropertyNames(input)) {
+    const descriptor = Object.getOwnPropertyDescriptor(input, key)
+    if (descriptor === undefined || !descriptor.enumerable) continue
+    // TOML only ever produces data properties, but a manifest is real
+    // JavaScript: `forges: { get acme() { … } }` is a valid declaration, and
+    // `descriptor.value` is `undefined` for it. Invoking the getter still never
+    // consults the prototype chain.
+    entries.push([key, 'value' in descriptor ? descriptor.value : descriptor.get?.call(input)])
+  }
+  return entries
+}
+
+/** Record a named entry so the key survives verbatim. Plain assignment is what
+ * loses `__proto__`; `defineProperty` on a null-prototype target cannot. */
+export function defineEntry<T>(entries: Record<string, T>, key: string, value: T): void {
+  Object.defineProperty(entries, key, {
+    value,
+    enumerable: true,
+    writable: true,
+    configurable: true,
+  })
+}
+
+/** Whether one entry's value validated, and what it validated to. Success is
+ * explicit rather than read off the value: a schema may legitimately validate to
+ * `undefined`, and that entry is kept like any other. */
+export type ParsedEntry<T> = { ok: true; value: T } | { ok: false }
+
+/** Validate one open-map value, forwarding every issue under its own key. */
+export function parseEntry<T>(
+  schema: z.ZodType<T>,
+  raw: unknown,
+  key: string,
+  ctx: IssueSink,
+): ParsedEntry<T> {
+  const parsed = schema.safeParse(raw)
+  if (parsed.success) return { ok: true, value: parsed.data }
+  forwardIssues(parsed.error.issues, ctx, [key])
+  return { ok: false }
+}
+
+/**
+ * An open map: author-chosen keys → strictly validated values, keys preserved.
+ *
+ * Preservation is the shared contract; the key vocabulary is not. An
+ * Autobuild-owned map names entries Autobuild itself must be able to address —
+ * a role to dispatch, a command to run — so a nameless entry there is dead
+ * configuration and an error. A plugin-owned pass-through map is not
+ * Autobuild's to narrow, and a map of adapter names is narrower still: a name
+ * made only of whitespace is unaddressable from configuration.
+ */
+export function openMap<T>(label: string, valueSchema: z.ZodType<T>, opts: OpenMapOptions = {}) {
+  const keys = opts.keys ?? 'nonempty'
+  return z
+    .unknown()
+    .transform((input, ctx): Record<string, T> => {
+      const entries: Record<string, T> = Object.create(null)
+      for (const [key, raw] of ownEntries(input, label, ctx, opts.shape)) {
+        if (!keyIsValid(key, keys)) {
+          ctx.addIssue({ code: 'custom', message: `${label} entry names must be ${keys}` })
+          continue
+        }
+        const parsed = parseEntry(valueSchema, raw, key, ctx)
+        if (parsed.ok) defineEntry(entries, key, parsed.value)
+      }
+      return entries
+    })
+    .prefault({})
+}

package/packages/core/src/operator/annotations.ts

@@ -0,0 +1,187 @@
+/**
+ * The checked-in risk table for the agent tool registry (operator/registry.ts).
+ *
+ * MCP annotations are per-tool hints, never per-argument, so a tool whose
+ * action set *may* destroy work carries `destructiveHint: true` for the whole
+ * tool, and each destructive action value is additionally named in the input
+ * field's description so a model still sees the per-value risk. Today exactly
+ * three tools may destroy work: `builds.control` (abort, discard),
+ * `builds.answer` (revise-spec), and `tickets.move` (a move into the
+ * configured ready state).
+ *
+ * The registry entries and the contract suite both read this table, so a
+ * change to any tool's risk class is a one-line visible diff this suite
+ * enforces. `approval` is the registry's own vocabulary (`'never'` for reads,
+ * `'default'` for mutators): the registry carries the class, and each binding
+ * decides what to do with it — the registry itself enforces only that a
+ * mutator refuses to run without an attributed identity.
+ */
+
+export interface ToolAnnotationsTableEntry {
+  readOnlyHint: boolean
+  destructiveHint: boolean
+  idempotentHint: boolean
+  approval: 'never' | 'default'
+}
+
+/** The exact version-one tool names; the registry's closed table must match. */
+export const OPERATOR_TOOL_ANNOTATIONS = {
+  'builds.list': {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    approval: 'never',
+  },
+  'builds.get': {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    approval: 'never',
+  },
+  'builds.events': {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    approval: 'never',
+  },
+  'builds.artifact': {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    approval: 'never',
+  },
+  'builds.control': {
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: false,
+    approval: 'default',
+  },
+  'builds.answer': {
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: false,
+    approval: 'default',
+  },
+  'repository.status': {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    approval: 'never',
+  },
+  'repository.settings': {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    approval: 'default',
+  },
+  'repository.bulk_control': {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    approval: 'default',
+  },
+  'harvest.status': {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    approval: 'never',
+  },
+  'harvest.control': {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    approval: 'default',
+  },
+  'tickets.list': {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    approval: 'never',
+  },
+  'tickets.get': {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    approval: 'never',
+  },
+  'tickets.create': {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    approval: 'default',
+  },
+  'tickets.update': {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    approval: 'default',
+  },
+  'tickets.block': {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    approval: 'default',
+  },
+  'tickets.unblock': {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    approval: 'default',
+  },
+  'tickets.move': {
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: false,
+    approval: 'default',
+  },
+  'notes.read': {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    approval: 'never',
+  },
+  'notes.write': {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    approval: 'default',
+  },
+  'sandbox.exec': {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    approval: 'default',
+  },
+  'sandbox.start': {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    approval: 'default',
+  },
+  'sandbox.wait': {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    approval: 'default',
+  },
+  'sandbox.read_file': {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    approval: 'default',
+  },
+  'sandbox.write_file': {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    approval: 'default',
+  },
+  'sandbox.reset': {
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: false,
+    approval: 'default',
+  },
+} as const satisfies Record<string, ToolAnnotationsTableEntry>
+
+export type OperatorToolName = keyof typeof OPERATOR_TOOL_ANNOTATIONS

package/packages/core/src/operator/client.ts

@@ -0,0 +1,311 @@
+import type { BuildControlResult } from '../cli/build-control'
+import type { BulkControlSummary } from '../cli/bulk-control'
+import type { HarvestStatusView } from '../cli/harvest'
+import type { RepositoryStatus } from '../cli/repository-status'
+import type { BuildSummary } from '../cli/status'
+import {
+  AUTOBUILD_VERSION,
+  AUTOBUILD_VERSION_HEADER,
+  REMOTE_STORE_PROTOCOL_VERSION,
+  REMOTE_STORE_PROTOCOL_VERSION_HEADER,
+} from '../store/remote/version'
+import {
+  operatorErrorSchema,
+  type OperatorAnswerRequest,
+  type OperatorBuildControlRequest,
+  type OperatorTicketBlockerRequest,
+  type OperatorTicketCreateRequest,
+  type OperatorTicketMoveRequest,
+  type OperatorTicketUpdateRequest,
+} from './protocol'
+import type { OperatorBuildView, OperatorDashboardSnapshot } from './query'
+import type { OperatorTicketDetail, OperatorTicketQueue } from './tickets'
+import type { OperatorSessionView } from './sessions'
+import type { SessionRecord } from '../store/types'
+import type { StreamRead } from '../store/streams/types'
+import type {
+  OperatorSessionApprovalRequest,
+  OperatorSessionCreateRequest,
+  OperatorSessionMessageRequest,
+  OperatorSessionWakeRequest,
+} from './protocol'
+
+export class OperatorApiError extends Error {
+  constructor(
+    readonly status: number,
+    readonly kind: string,
+    readonly code?: string,
+    readonly progress?: unknown,
+  ) {
+    super(kind)
+    this.name = 'OperatorApiError'
+  }
+}
+
+export interface OperatorApiClientOptions {
+  url: string
+  token: string
+  fetchFn?: typeof fetch
+}
+
+export interface DownloadedArtifact {
+  content: Uint8Array
+  kind: string
+  revision: number
+  blobRef: string
+  disposition?: string
+}
+
+export class OperatorApiClient {
+  private readonly base: string
+  private readonly fetchFn: typeof fetch
+  constructor(private readonly options: OperatorApiClientOptions) {
+    this.base = options.url.replace(/\/+$/, '')
+    this.fetchFn = options.fetchFn ?? fetch
+  }
+
+  private repoPath(repo: string, suffix: string): string {
+    return `/operator/v1/repos/${encodeURIComponent(repo)}/${suffix}`
+  }
+
+  private async request<T>(repo: string, suffix: string, init: RequestInit = {}): Promise<T> {
+    const headers = new Headers(init.headers)
+    headers.set(AUTOBUILD_VERSION_HEADER, AUTOBUILD_VERSION)
+    headers.set(REMOTE_STORE_PROTOCOL_VERSION_HEADER, REMOTE_STORE_PROTOCOL_VERSION)
+    headers.set('authorization', `Bearer ${this.options.token}`)
+    if (init.body !== undefined) headers.set('content-type', 'application/json')
+    const response = await this.fetchFn(`${this.base}${this.repoPath(repo, suffix)}`, {
+      ...init,
+      headers,
+    })
+    if (!response.ok) {
+      const parsed = operatorErrorSchema.safeParse(await response.json().catch(() => null))
+      if (!parsed.success) throw new Error(`operator API returned HTTP ${response.status}`)
+      const error = new OperatorApiError(
+        response.status,
+        parsed.data.kind,
+        parsed.data.code,
+        parsed.data.progress,
+      )
+      error.message = parsed.data.error
+      throw error
+    }
+    return (await response.json()) as T
+  }
+
+  listBuilds(repo: string, scope: 'active' | 'queued' | 'all' = 'active'): Promise<BuildSummary[]> {
+    return this.request(repo, `builds?scope=${scope}`)
+  }
+  getBuild(repo: string, slug: string): Promise<OperatorBuildView> {
+    return this.request(repo, `builds/${encodeURIComponent(slug)}`)
+  }
+  dashboard(repo: string): Promise<OperatorDashboardSnapshot> {
+    return this.request(repo, 'dashboard')
+  }
+  repositoryStatus(repo: string): Promise<RepositoryStatus> {
+    return this.request(repo, 'status')
+  }
+  harvestStatus(repo: string): Promise<HarvestStatusView> {
+    return this.request(repo, 'harvest/status')
+  }
+  listTickets(
+    repo: string,
+    filters: { state?: string; labels?: string[] } = {},
+  ): Promise<OperatorTicketQueue> {
+    const query = new URLSearchParams()
+    if (filters.state !== undefined) query.set('state', filters.state)
+    for (const label of filters.labels ?? []) query.append('label', label)
+    const suffix = query.size > 0 ? `tickets?${query}` : 'tickets'
+    return this.request(repo, suffix)
+  }
+  getTicket(repo: string, id: string): Promise<OperatorTicketDetail> {
+    return this.request(repo, `tickets/${encodeURIComponent(id)}`)
+  }
+  createTicket(repo: string, request: OperatorTicketCreateRequest): Promise<OperatorTicketDetail> {
+    return this.request(repo, 'tickets', { method: 'POST', body: JSON.stringify(request) })
+  }
+  updateTicket(
+    repo: string,
+    id: string,
+    request: OperatorTicketUpdateRequest,
+  ): Promise<OperatorTicketDetail> {
+    return this.request(repo, `tickets/${encodeURIComponent(id)}`, {
+      method: 'PATCH',
+      body: JSON.stringify(request),
+    })
+  }
+  moveTicket(
+    repo: string,
+    id: string,
+    request: OperatorTicketMoveRequest,
+  ): Promise<OperatorTicketDetail> {
+    return this.request(repo, `tickets/${encodeURIComponent(id)}/move`, {
+      method: 'POST',
+      body: JSON.stringify(request),
+    })
+  }
+  blockTicket(
+    repo: string,
+    id: string,
+    request: OperatorTicketBlockerRequest,
+  ): Promise<OperatorTicketDetail> {
+    return this.request(repo, `tickets/${encodeURIComponent(id)}/block`, {
+      method: 'POST',
+      body: JSON.stringify(request),
+    })
+  }
+  unblockTicket(
+    repo: string,
+    id: string,
+    request: OperatorTicketBlockerRequest,
+  ): Promise<OperatorTicketDetail> {
+    return this.request(repo, `tickets/${encodeURIComponent(id)}/unblock`, {
+      method: 'POST',
+      body: JSON.stringify(request),
+    })
+  }
+  listSessions(repo: string): Promise<SessionRecord[]> {
+    return this.request(repo, 'sessions')
+  }
+  createSession(repo: string, request: OperatorSessionCreateRequest): Promise<SessionRecord> {
+    return this.request(repo, 'sessions', { method: 'POST', body: JSON.stringify(request) })
+  }
+  getSession(repo: string, sid: string): Promise<OperatorSessionView> {
+    return this.request(repo, `sessions/${encodeURIComponent(sid)}`)
+  }
+  postSessionMessage(
+    repo: string,
+    sid: string,
+    request: OperatorSessionMessageRequest,
+  ): Promise<{ ok: boolean }> {
+    return this.request(repo, `sessions/${encodeURIComponent(sid)}/messages`, {
+      method: 'POST',
+      body: JSON.stringify(request),
+    })
+  }
+  setSessionWake(
+    repo: string,
+    sid: string,
+    request: OperatorSessionWakeRequest,
+  ): Promise<{ ok: boolean }> {
+    return this.request(repo, `sessions/${encodeURIComponent(sid)}/wake`, {
+      method: 'PUT',
+      body: JSON.stringify(request),
+    })
+  }
+  answerSessionApproval(
+    repo: string,
+    sid: string,
+    request: OperatorSessionApprovalRequest,
+  ): Promise<{ ok: boolean }> {
+    return this.request(repo, `sessions/${encodeURIComponent(sid)}/approvals`, {
+      method: 'POST',
+      body: JSON.stringify(request),
+    })
+  }
+  archiveSession(repo: string, sid: string): Promise<{ ok: boolean }> {
+    return this.request(repo, `sessions/${encodeURIComponent(sid)}/archive`, {
+      method: 'POST',
+    })
+  }
+  readSessionTurnStream(
+    repo: string,
+    sid: string,
+    turn: string,
+    opts: { since?: number; waitSeconds?: number } = {},
+  ): Promise<StreamRead> {
+    const query = new URLSearchParams({ since: String(opts?.since ?? 0) })
+    if (opts?.waitSeconds !== undefined) query.set('wait', String(opts.waitSeconds))
+    return this.request(
+      repo,
+      `sessions/${encodeURIComponent(sid)}/turns/${encodeURIComponent(turn)}/stream?${query}`,
+    )
+  }
+  controlBuild(
+    repo: string,
+    slug: string,
+    request: OperatorBuildControlRequest,
+  ): Promise<BuildControlResult> {
+    return this.request(repo, `builds/${encodeURIComponent(slug)}/control`, {
+      method: 'POST',
+      body: JSON.stringify(request),
+    })
+  }
+  /** The registry's generic protocol face: execute any tool from the closed
+   * table by name. The body is the tool's input (repo included); failures
+   * parse into OperatorApiError exactly like the typed routes. */
+  callTool(repo: string, tool: string, input: unknown): Promise<unknown> {
+    return this.request(repo, `tools/${encodeURIComponent(tool)}`, {
+      method: 'POST',
+      body: JSON.stringify(input),
+    })
+  }
+  answer(repo: string, slug: string, request: OperatorAnswerRequest): Promise<BuildControlResult> {
+    return this.request(repo, `builds/${encodeURIComponent(slug)}/answer`, {
+      method: 'POST',
+      body: JSON.stringify(request),
+    })
+  }
+  setIntake(repo: string, enabled: boolean): Promise<unknown> {
+    return this.request(repo, 'settings/intake', {
+      method: 'PUT',
+      body: JSON.stringify({ enabled }),
+    })
+  }
+  toggleIntake(repo: string): Promise<unknown> {
+    return this.request(repo, 'settings/intake/toggle', { method: 'POST' })
+  }
+  setAutoMergeDefault(repo: string, enabled: boolean): Promise<unknown> {
+    return this.request(repo, 'settings/auto-merge-default', {
+      method: 'PUT',
+      body: JSON.stringify({ enabled }),
+    })
+  }
+  toggleAutoMergeDefault(repo: string): Promise<unknown> {
+    return this.request(repo, 'settings/auto-merge-default/toggle', { method: 'POST' })
+  }
+  bulkControl(repo: string, action: 'pause' | 'resume'): Promise<BulkControlSummary> {
+    return this.request(repo, 'bulk-control', { method: 'POST', body: JSON.stringify({ action }) })
+  }
+  toggleHarvest(repo: string): Promise<unknown> {
+    return this.request(repo, 'harvest/control', {
+      method: 'POST',
+      body: JSON.stringify({ action: 'toggle-gate' }),
+    })
+  }
+  controlHarvestRun(repo: string, run: string): Promise<unknown> {
+    return this.request(repo, 'harvest/control', {
+      method: 'POST',
+      body: JSON.stringify({ action: 'run', run }),
+    })
+  }
+  async downloadArtifact(
+    repo: string,
+    slug: string,
+    kind: string,
+    rev?: number,
+  ): Promise<DownloadedArtifact> {
+    const suffix = `builds/${encodeURIComponent(slug)}/artifacts/${encodeURIComponent(kind)}${rev === undefined ? '' : `?rev=${rev}`}`
+    const headers = new Headers({
+      [AUTOBUILD_VERSION_HEADER]: AUTOBUILD_VERSION,
+      [REMOTE_STORE_PROTOCOL_VERSION_HEADER]: REMOTE_STORE_PROTOCOL_VERSION,
+      authorization: `Bearer ${this.options.token}`,
+    })
+    const response = await this.fetchFn(`${this.base}${this.repoPath(repo, suffix)}`, { headers })
+    if (!response.ok) {
+      const parsed = operatorErrorSchema.parse(await response.json())
+      const error = new OperatorApiError(response.status, parsed.kind, parsed.code, parsed.progress)
+      error.message = parsed.error
+      throw error
+    }
+    return {
+      content: new Uint8Array(await response.arrayBuffer()),
+      kind: response.headers.get('x-autobuild-artifact-kind') ?? kind,
+      revision: Number(response.headers.get('x-autobuild-artifact-revision')),
+      blobRef: response.headers.get('x-autobuild-artifact-blob-ref') ?? '',
+      ...(response.headers.get('content-disposition') !== null
+        ? { disposition: response.headers.get('content-disposition')! }
+        : {}),
+    }
+  }
+}