zidane 7.2.5 → 8.0.4

package/dist/environment-8wsKE2Ln.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"environment-8wsKE2Ln.js","names":[],"sources":["../src/chat/environment.ts"],"sourcesContent":["/**\n * Session environments — WHERE a session's work happens, chosen once at\n * creation: the current checkout (`local`), and — through providers — a git\n * worktree, a container, a remote sandbox.\n *\n * Every environment kind is an {@link EnvironmentProvider}. The host never\n * special-cases a kind; it drives the same lifecycle for all of them:\n *\n *   create   → `metadata.environment` stamped. A provider with `prepare` starts\n *              `provisioning` and the host provisions in the background (slow,\n *              fallible, retryable); one without is `ready` immediately.\n *   run      → `assertEnvironmentReady` gates every agent build; the execution\n *              context comes from {@link resolveExecution} (never built inline),\n *              cached per session by `execution-cache.ts`.\n *   delete   → `teardown` when the session owns the environment (a fork shares\n *              its parent's without owning it), reporting what it kept.\n *\n * Two directories stay distinct on purpose: `metadata.cwd` is the HOST\n * directory config and discovery read from (`AGENTS.md`, skills, MCPs), and\n * `environment.execCwd` — set only when it differs — is where commands run\n * inside the environment (e.g. `/workspace/repo` in a sandbox). Local and\n * worktree environments run on the host, so theirs is `metadata.cwd`.\n */\nimport type { IsolationPolicy } from '../contexts/isolation'\nimport type { ExecResult, ExecutionContext, ExecutionHandle } from '../contexts/types'\nimport type { JsonValue } from '../types'\n\n// ---------------------------------------------------------------------------\n// Session metadata\n// ---------------------------------------------------------------------------\n\nexport type EnvironmentState = 'provisioning' | 'ready' | 'failed'\n\n/** `metadata.environment` — absent on sessions that predate it (read as local). */\nexport interface SessionEnvironment {\n  /** Provider kind: `'local'`, `'worktree'`, `'docker'`, `'e2b'`, … */\n  kind: string\n  state: EnvironmentState\n  /** Where commands run inside the environment, when it isn't `metadata.cwd`. */\n  execCwd?: string\n  /** Branch the session works on (worktree and remote kinds). */\n  branch?: string\n  /** What `branch` was cut from. */\n  base?: string\n  /** Provider-owned state: a worktree path, a sandbox id, a container id. */\n  ref?: JsonValue\n  /**\n   * `false` when the session shares another session's environment (a fork):\n   * it runs there but never tears it down. Absent = owned.\n   */\n  owned?: boolean\n  /** Why provisioning failed (`state: 'failed'`). */\n  error?: string\n  /**\n   * The host paused it while idle (`provider.suspend` — a stopped container,\n   * a paused sandbox). Still `ready`: the next run resumes it.\n   */\n  suspended?: boolean\n}\n\nexport const ENVIRONMENT_METADATA_KEY = 'environment'\n\nexport const LOCAL_ENVIRONMENT: SessionEnvironment = { kind: 'local', state: 'ready' }\n\nconst STATES: ReadonlySet<string> = new Set(['provisioning', 'ready', 'failed'])\n\n/**\n * The session's environment, from its metadata. Tolerant: absent or\n * malformed reads as {@link LOCAL_ENVIRONMENT} — what every session was\n * before environments existed.\n */\nexport function readSessionEnvironment(metadata: Record<string, unknown> | undefined): SessionEnvironment {\n  const raw = metadata?.[ENVIRONMENT_METADATA_KEY]\n  if (!raw || typeof raw !== 'object' || Array.isArray(raw))\n    return LOCAL_ENVIRONMENT\n  const record = raw as Record<string, unknown>\n  if (typeof record.kind !== 'string' || !record.kind || typeof record.state !== 'string' || !STATES.has(record.state))\n    return LOCAL_ENVIRONMENT\n  return {\n    kind: record.kind,\n    state: record.state as EnvironmentState,\n    ...(typeof record.execCwd === 'string' && record.execCwd ? { execCwd: record.execCwd } : {}),\n    ...(typeof record.branch === 'string' && record.branch ? { branch: record.branch } : {}),\n    ...(typeof record.base === 'string' && record.base ? { base: record.base } : {}),\n    ...(record.ref !== undefined ? { ref: record.ref as JsonValue } : {}),\n    ...(record.owned === false ? { owned: false } : {}),\n    ...(typeof record.error === 'string' && record.error ? { error: record.error } : {}),\n    ...(record.suspended === true ? { suspended: true } : {}),\n  }\n}\n\n/** The metadata patch that persists `environment` (plain JSON, `undefined` keys dropped). */\nexport function environmentMetadata(environment: SessionEnvironment): Record<string, unknown> {\n  return { [ENVIRONMENT_METADATA_KEY]: JSON.parse(JSON.stringify(environment)) as JsonValue }\n}\n\n/** A session whose environment can't run yet (provisioning) or can't run at all (failed). */\nexport class EnvironmentNotReadyError extends Error {\n  readonly state: EnvironmentState\n  constructor(environment: SessionEnvironment) {\n    super(environment.state === 'failed'\n      ? `The session's ${environment.kind} environment failed to provision${environment.error ? `: ${environment.error}` : '.'} Retry it or delete the session.`\n      : `The session's ${environment.kind} environment is still being set up. Try again once it is ready.`)\n    this.name = 'EnvironmentNotReadyError'\n    this.state = environment.state\n  }\n}\n\n/** Throws {@link EnvironmentNotReadyError} unless the environment can run. */\nexport function assertEnvironmentReady(environment: SessionEnvironment): void {\n  if (environment.state !== 'ready')\n    throw new EnvironmentNotReadyError(environment)\n}\n\n// ---------------------------------------------------------------------------\n// Providers\n// ---------------------------------------------------------------------------\n\n/** A provider option's value, as stored in settings (secrets resolve to strings). */\nexport type EnvironmentConfigValue = string | number | boolean\n\n/** A kind's resolved options — see `environment-settings.ts` (`resolveProviderConfig`). */\nexport type EnvironmentConfig = Readonly<Record<string, EnvironmentConfigValue | undefined>>\n\n/**\n * One option a provider declares. Settings UIs render these generically\n * (no per-kind UI code); `environment-settings.ts` stores, validates and\n * resolves them.\n */\nexport interface EnvironmentConfigField {\n  key: string\n  label: string\n  description?: string\n  /**\n   * `secret` values never live in `state.json`: they go to the 0600\n   * environment credential store and reach clients only as \"configured\".\n   */\n  type: 'boolean' | 'string' | 'number' | 'choice' | 'path' | 'secret'\n  default?: EnvironmentConfigValue\n  /** `type: 'choice'` options; `description` is the one-line detail pickers show under the label. */\n  choices?: readonly { value: string, label: string, description?: string }[]\n  placeholder?: string\n  /** Environment variable that stands in when unset (e.g. `E2B_API_KEY`). */\n  env?: string\n  /**\n   * The value lives in this top-level `Settings` key instead of the kind's\n   * own config — for options that predate environments (Local's OS\n   * sandbox), so there is one source of truth.\n   */\n  setting?: string\n  /** Only meaningful while another field has this value (hidden otherwise). */\n  when?: { key: string, equals: EnvironmentConfigValue }\n}\n\nexport interface EnvironmentPrepareInput {\n  sessionId: string\n  /** The session's host directory (`metadata.cwd`). */\n  cwd: string\n  /** The environment as stamped at creation (`state: 'provisioning'`). */\n  environment: SessionEnvironment\n  config: EnvironmentConfig\n  signal?: AbortSignal\n}\n\nexport interface EnvironmentPrepareResult {\n  /** Fields to merge into the environment (`ref`, `execCwd`, resolved `branch`…). */\n  environment?: Partial<Omit<SessionEnvironment, 'kind' | 'state' | 'error'>>\n  /**\n   * New host directory for the session — a worktree provider returns the\n   * worktree it created. Config, discovery and a host-run context follow it.\n   */\n  cwd?: string\n}\n\nexport interface EnvironmentExecutionInput {\n  sessionId: string\n  /** The session's resolved host directory. */\n  cwd: string\n  environment: SessionEnvironment\n  config: EnvironmentConfig\n  /** OS sandbox policy from settings — meaningful for host-run kinds only. */\n  isolation?: IsolationPolicy\n}\n\nexport interface EnvironmentExecution {\n  /**\n   * Everything the context is configured with. The session's cached context\n   * is reused while this is unchanged; a new key replaces it.\n   */\n  key: string\n  create: () => ExecutionContext\n  /**\n   * The directory the model is told it works in, when it isn't the host\n   * `cwd` (inside a sandbox). Hosts use it for the prompt's environment\n   * section; tools resolve against the handle's cwd regardless.\n   */\n  promptCwd?: string\n}\n\nexport interface EnvironmentTeardownResult {\n  /** The environment is gone (or there was nothing to remove). */\n  removed: boolean\n  /** Why it was kept — surfaced to the user (e.g. \"has uncommitted changes\"). */\n  reason?: string\n}\n\nexport type EnvironmentAvailability = { ok: true } | { ok: false, reason: string }\n\n/** \"Test connection\" outcome — `detail` is what it connected to (account, region, version). */\nexport type EnvironmentVerifyResult = { ok: true, detail?: string } | { ok: false, reason: string }\n\nexport interface EnvironmentActionInput {\n  sessionId: string\n  environment: SessionEnvironment\n  config: EnvironmentConfig\n  /** The session's host directory (`metadata.cwd`). */\n  cwd: string\n  /** Run a command in the session's environment — its execution handle, spawned (or resumed) on demand. */\n  exec: (command: string, options?: { cwd?: string, env?: Record<string, string>, timeoutSeconds?: number }) => Promise<ExecResult>\n}\n\nexport interface EnvironmentActionResult {\n  /** One line for the user (\"Pushed zidane/ab12 to origin.\"). */\n  message: string\n  /** Something to open — a pull request. */\n  url?: string\n}\n\n/** Wire-safe {@link EnvironmentAction} — what session menus list. */\nexport interface EnvironmentActionSummary {\n  id: string\n  label: string\n  description?: string\n}\n\n/** A per-session command a kind offers (session menus): push the branch, open a PR, … */\nexport interface EnvironmentAction {\n  id: string\n  label: string\n  description?: string\n  /** Offered for this environment right now. Default: whenever it is ready. */\n  available?: (environment: SessionEnvironment, config: EnvironmentConfig) => boolean\n  run: (input: EnvironmentActionInput) => Promise<EnvironmentActionResult>\n}\n\nexport interface EnvironmentAvailabilityInput {\n  /** The folder a session would be created in (`''` = directory-less). */\n  cwd: string\n  config: EnvironmentConfig\n}\n\nexport interface EnvironmentProvider {\n  kind: string\n  /** Human label for pickers. */\n  label: string\n  /** One line for pickers and settings. */\n  description?: string\n  /** Options the kind takes — rendered by the Environments settings section. */\n  configSchema?: readonly EnvironmentConfigField[]\n  /**\n   * Hidden from pickers until turned on in Settings → Environments — kinds\n   * that need setting up first (a Docker install, a sandbox account).\n   */\n  offByDefault?: boolean\n  /**\n   * Whether the creator names a branch (worktree, a fresh-worktree\n   * container, remote sandboxes). Pickers show a branch field when true.\n   */\n  takesBranch?: boolean | ((config: EnvironmentConfig) => boolean)\n  /**\n   * Suggested branch for a new session — pickers pre-fill it and the host\n   * uses it when the creator leaves the branch empty.\n   */\n  suggestBranch?: (config: EnvironmentConfig) => string\n  /**\n   * Whether it can be offered right now for that folder (credentials,\n   * binaries, git, a reachable daemon). Default: available.\n   */\n  available?: (input: EnvironmentAvailabilityInput) => EnvironmentAvailability | Promise<EnvironmentAvailability>\n  /**\n   * One line pickers show under the kind when it's available for `cwd` —\n   * what creating one will do (\"Clones acme/app, branching off main\").\n   */\n  note?: (input: EnvironmentAvailabilityInput) => Promise<string | undefined>\n  /**\n   * The kind's folders are not on this host (a machine's,\n   * `docs/MACHINES.md`): the host checks a new session's folder with this\n   * (returning it, normalized, or throwing) instead of its own workspace\n   * confinement. Absent → the host's confinement applies.\n   */\n  checkFolder?: (cwd: string) => string\n  /** The machine behind a machine kind, `undefined` once it is forgotten (the kind is then not listed). */\n  machine?: () => { id: string, name: string, status: 'online' | 'offline' } | undefined\n  /**\n   * Make the environment exist. Absent → ready at creation. Must be\n   * idempotent: a retry (after a failure or a host restart mid-provisioning)\n   * runs it again over whatever a previous attempt left behind.\n   */\n  prepare?: (input: EnvironmentPrepareInput) => Promise<EnvironmentPrepareResult>\n  /** The execution context for a ready environment. */\n  execution: (input: EnvironmentExecutionInput) => EnvironmentExecution\n  /**\n   * \"Test connection\" for the settings UIs: one cheap real call with the\n   * current options (ping the daemon, list sandboxes). Absent → no button.\n   */\n  verify?: (input: { config: EnvironmentConfig }) => Promise<EnvironmentVerifyResult>\n  /** Per-session commands, shown in the session menus. */\n  actions?: readonly EnvironmentAction[]\n  /**\n   * Minutes of inactivity after which the host lets go of an idle session's\n   * execution (a container is removed) and calls {@link suspend} when\n   * present (a sandbox is paused). Absent or `<= 0` → only on host exit /\n   * eviction.\n   */\n  idleSuspendMinutes?: (config: EnvironmentConfig) => number | undefined\n  /**\n   * The host let go of the session's execution while the session lives on\n   * (idle eviction, host exit): pause what costs money while idle (a\n   * remote sandbox). The next `execution` resumes it. Absent → nothing to do.\n   */\n  suspend?: (environment: SessionEnvironment, context: { config: EnvironmentConfig }) => Promise<void>\n  /**\n   * Remove the environment when its owning session is deleted. Decides what\n   * \"safe\" means (a dirty worktree is kept, a sandbox is killed). Absent →\n   * nothing to remove.\n   */\n  teardown?: (environment: SessionEnvironment, context: { cwd: string, config: EnvironmentConfig }) => Promise<EnvironmentTeardownResult>\n}\n\n/** Whether `provider` takes a branch under `config`. */\nexport function environmentTakesBranch(provider: EnvironmentProvider, config: EnvironmentConfig): boolean {\n  return typeof provider.takesBranch === 'function' ? provider.takesBranch(config) : provider.takesBranch === true\n}\n\nexport interface EnvironmentRegistry {\n  get: (kind: string) => EnvironmentProvider | undefined\n  list: () => readonly EnvironmentProvider[]\n  /** Add a provider. A kind already registered keeps the first registration. */\n  register: (provider: EnvironmentProvider) => void\n}\n\n/**\n * A registry of `providers`. Hosts pass the chat layer's built-ins\n * (`builtinEnvironmentProviders`, which include `local`) plus any extras; a\n * registry without `local` can still create local sessions (an absent\n * environment IS local) but can't resolve their execution.\n */\nexport function createEnvironmentRegistry(providers: readonly EnvironmentProvider[] = []): EnvironmentRegistry {\n  const byKind = new Map<string, EnvironmentProvider>()\n  const registry: EnvironmentRegistry = {\n    get: kind => byKind.get(kind),\n    list: () => [...byKind.values()],\n    register: (provider) => {\n      if (!byKind.has(provider.kind))\n        byKind.set(provider.kind, provider)\n    },\n  }\n  for (const provider of providers)\n    registry.register(provider)\n  return registry\n}\n\n/** The provider for `kind`, or a clear error — an unknown kind can't run anywhere. */\nexport function requireEnvironmentProvider(registry: EnvironmentRegistry, kind: string): EnvironmentProvider {\n  const provider = registry.get(kind)\n  if (!provider)\n    throw new Error(`Unknown session environment \"${kind}\". Is the extension that provides it enabled?`)\n  return provider\n}\n\n/**\n * THE way a host gets a session's execution context: its environment's\n * provider decides. The key is namespaced by kind so two providers can't\n * collide on the same configuration string.\n */\nexport function resolveExecution(registry: EnvironmentRegistry, input: EnvironmentExecutionInput): EnvironmentExecution {\n  const execution = requireEnvironmentProvider(registry, input.environment.kind).execution(input)\n  return { ...execution, key: `${input.environment.kind}:${execution.key}` }\n}\n\n/** The actions `environment`'s kind offers for it right now (a ready, owned-or-shared environment). */\nexport function availableEnvironmentActions(\n  registry: EnvironmentRegistry,\n  environment: SessionEnvironment,\n  config: EnvironmentConfig,\n): EnvironmentAction[] {\n  if (environment.state !== 'ready')\n    return []\n  return (registry.get(environment.kind)?.actions ?? [])\n    .filter(action => action.available?.(environment, config) ?? true)\n}\n\n/** {@link availableEnvironmentActions}, wire-safe. */\nexport function environmentActionSummaries(registry: EnvironmentRegistry, environment: SessionEnvironment, config: EnvironmentConfig): EnvironmentActionSummary[] {\n  return availableEnvironmentActions(registry, environment, config)\n    .map(({ id, label, description }) => ({ id, label, ...(description ? { description } : {}) }))\n}\n\n/**\n * Run `actionId` for a session on `execution` — the session's own (hosts pass\n * the cached one, so the action runs exactly where the agent does). Throws\n * when the environment isn't ready or doesn't offer the action.\n */\nexport async function runSessionEnvironmentAction(input: {\n  registry: EnvironmentRegistry\n  sessionId: string\n  actionId: string\n  environment: SessionEnvironment\n  config: EnvironmentConfig\n  cwd: string\n  execution: { context: ExecutionContext, handle: () => Promise<ExecutionHandle> }\n}): Promise<EnvironmentActionResult> {\n  const { registry, sessionId, actionId, environment, config, cwd, execution } = input\n  assertEnvironmentReady(environment)\n  const action = availableEnvironmentActions(registry, environment, config).find(candidate => candidate.id === actionId)\n  if (!action)\n    throw new Error(`\"${actionId}\" isn't available for this session's environment.`)\n  return action.run({\n    sessionId,\n    environment,\n    config,\n    cwd,\n    exec: async (command, options) => execution.context.exec(await execution.handle(), command, {\n      ...(options?.cwd ? { cwd: options.cwd } : {}),\n      ...(options?.env ? { env: options.env } : {}),\n      ...(options?.timeoutSeconds ? { timeout: options.timeoutSeconds } : {}),\n    }),\n  })\n}\n\n/** \"Test connection\" for `kind`; a throwing or missing `verify` reads as a failure with the reason. */\nexport async function verifyEnvironment(registry: EnvironmentRegistry, kind: string, config: EnvironmentConfig): Promise<EnvironmentVerifyResult> {\n  const provider = registry.get(kind)\n  if (!provider?.verify)\n    return { ok: false, reason: provider ? `${provider.label} has no connection to test.` : `Unknown environment \"${kind}\".` }\n  try {\n    return await provider.verify({ config })\n  }\n  catch (err) {\n    return { ok: false, reason: err instanceof Error ? err.message : String(err) }\n  }\n}\n\n/**\n * `path` in a session workspace rooted at `root` (POSIX resolve): relative\n * paths against `root`, absolute paths as given. The same resolution the\n * execution contexts apply against their handle's cwd, so a workspace call\n * means what the agent's own tools mean; containment is the context's own\n * (sandboxes confine to their workspace root, the local process context\n * doesn't). Clients that must stay inside the workspace (the GUI's file\n * panels) guard their paths themselves.\n */\nexport function workspacePath(root: string, path: string): string {\n  const resolved: string[] = []\n  for (const segment of `${path.startsWith('/') ? '' : root}/${path}`.split('/')) {\n    if (!segment || segment === '.')\n      continue\n    if (segment === '..')\n      resolved.pop()\n    else\n      resolved.push(segment)\n  }\n  return `/${resolved.join('/')}`\n}\n\n/** What a creator asks for — the host turns it into a {@link SessionEnvironment}. */\nexport interface EnvironmentRequest {\n  kind: string\n  branch?: string\n  base?: string\n}\n\n/** Whether `provider` can be offered for `input`; a throwing probe reads as unavailable. */\nexport async function probeEnvironment(provider: EnvironmentProvider, input: EnvironmentAvailabilityInput): Promise<EnvironmentAvailability> {\n  try {\n    return (await provider.available?.(input)) ?? { ok: true }\n  }\n  catch (err) {\n    return { ok: false, reason: err instanceof Error ? err.message : String(err) }\n  }\n}\n\n/**\n * The environment to stamp on a new session: `ready` for a provider without\n * `prepare`, `provisioning` otherwise; a branch-taking kind gets the\n * requested branch or the provider's suggestion. Throws for an unknown or\n * unavailable kind — creation must fail loudly rather than produce a session\n * that can never run.\n */\nexport async function initialEnvironment(\n  registry: EnvironmentRegistry,\n  request: EnvironmentRequest,\n  context: EnvironmentAvailabilityInput,\n): Promise<SessionEnvironment> {\n  const provider = requireEnvironmentProvider(registry, request.kind)\n  const availability = await probeEnvironment(provider, context)\n  if (!availability.ok)\n    throw new Error(`The ${provider.label} environment is unavailable: ${availability.reason}`)\n  const branch = environmentTakesBranch(provider, context.config)\n    ? (request.branch?.trim() || provider.suggestBranch?.(context.config))\n    : undefined\n  return {\n    kind: request.kind,\n    state: provider.prepare ? 'provisioning' : 'ready',\n    ...(branch ? { branch } : {}),\n    ...(request.base ? { base: request.base } : {}),\n  }\n}\n\n/**\n * Remove a deleted session's environment when it owns one. Never throws —\n * a teardown failure must not block the delete; it comes back as a kept\n * result with the reason.\n */\nexport async function teardownSessionEnvironment(\n  registry: EnvironmentRegistry,\n  metadata: Record<string, unknown> | undefined,\n  context: { cwd: string, config: (kind: string) => EnvironmentConfig },\n): Promise<EnvironmentTeardownResult> {\n  const environment = readSessionEnvironment(metadata)\n  const provider = registry.get(environment.kind)\n  if (environment.owned === false || !provider?.teardown)\n    return { removed: true }\n  try {\n    return await provider.teardown(environment, { cwd: context.cwd, config: context.config(environment.kind) })\n  }\n  catch (err) {\n    return { removed: false, reason: err instanceof Error ? err.message : String(err) }\n  }\n}\n"],"mappings":"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"}