@bud.sh/app 0.5.1 → 0.6.0

package/dist/types/design.d.ts

@@ -1,5 +1,5 @@
-import { S as fieldByRole, a as WorkDetail, h as valueByRole, m as WorkValue, o as WorkItem, v as FieldKind, x as WorkSchema, y as FieldSchema } from "./assets/items-CaVkByHk.js";
-import { a as TaskDesignContext, c as TaskPageDesignProps, d as TaskSectionsDesignProps, f as defineTaskDesign, g as TaskCard, h as TaskOperations, i as TaskDesign, l as TaskPropertiesDesignProps, m as TaskDetails, n as TaskCardDesignProps, o as TaskDesignProject, p as PropertiesDefault, r as TaskColumnDesignProps, s as TaskDesignSlot, t as TaskActionsDesignProps, u as TaskRenderField } from "./assets/task-design-xJOhRNWh.js";
+import { C as fieldByRole, S as WorkSchema, a as WorkDetail, h as valueByRole, m as WorkValue, o as WorkItem, v as FieldKind, y as FieldSchema } from "./assets/items-BQdaVksf.js";
+import { a as TaskDesignContext, c as TaskPageDesignProps, d as TaskSectionsDesignProps, f as defineTaskDesign, g as TaskCard, h as TaskOperations, i as TaskDesign, l as TaskPropertiesDesignProps, m as TaskDetails, n as TaskCardDesignProps, o as TaskDesignProject, p as PropertiesDefault, r as TaskColumnDesignProps, s as TaskDesignSlot, t as TaskActionsDesignProps, u as TaskRenderField } from "./assets/task-design-BDHKFHpp.js";
 import { Handle, RemixNode } from "remix/component";
 //#region ../ui/src/lib/tasks/task-design-parts.d.ts
 /**

package/dist/types/hosted.d.ts

@@ -1,5 +1,5 @@
-import { i as ResolvedBudConfig } from "./assets/config-DIC2cf_S.js";
-import { a as HostedAuthor, c as HostedStorage, i as HostedAppOptions, l as RemoteBranchState, n as CreateHostedApp, o as HostedDatabase, r as HostedApp, s as HostedRequestContext, t as BranchRemote, u as hostedScreenModules } from "./assets/contract-CAT-XFNq.js";
+import { i as ResolvedBudConfig } from "./assets/config-CvcYmE2s.js";
+import { a as HostedAuthor, c as HostedFactoryTick, d as RemoteBranchState, f as hostedScreenModules, i as HostedAppOptions, l as HostedRequestContext, n as CreateHostedApp, o as HostedDatabase, r as HostedApp, s as HostedFactory, t as BranchRemote, u as HostedStorage } from "./assets/contract-B7yuuqSn.js";
 //#region src/hosted.server.d.ts
 /**
  * Creates a hosted Bud: Bud's own routes for the canvas and tasks on the host's stores.
@@ -8,4 +8,4 @@ import { a as HostedAuthor, c as HostedStorage, i as HostedAppOptions, l as Remo
  */
 export declare const createHostedApp: CreateHostedApp;
 //#endregion
-export { type BranchRemote, type CreateHostedApp, type HostedApp, type HostedAppOptions, type HostedAuthor, type HostedDatabase, type HostedRequestContext, type HostedStorage, type RemoteBranchState, type ResolvedBudConfig, hostedScreenModules };
+export { type BranchRemote, type CreateHostedApp, type HostedApp, type HostedAppOptions, type HostedAuthor, type HostedDatabase, type HostedFactory, type HostedFactoryTick, type HostedRequestContext, type HostedStorage, type RemoteBranchState, type ResolvedBudConfig, hostedScreenModules };

package/dist/types/index.d.ts

@@ -1,5 +1,5 @@
 import { n as ElementSource } from "./assets/canvas-anchor-CYU3qBPx.js";
-import { a as defineConfig, c as files, l as pages, n as BudRoute, o as BudScreen, s as canvas, t as BudConfig, u as tasks } from "./assets/config-DIC2cf_S.js";
+import { a as defineConfig, c as taskDesign, d as files, f as pages, l as BudScreen, n as BudRoute, p as tasks, s as picker, t as BudConfig, u as canvas } from "./assets/config-CvcYmE2s.js";
 //#region ../picker/src/lib/types.d.ts
 /** What a framework adds about an element, beyond what the page's DOM shows. */
 interface PickerDescription {
@@ -21,4 +21,4 @@ interface PickerAdapter {
   pick?(signal: AbortSignal): Promise<Element | null>;
 }
 //#endregion
-export { type BudConfig, type BudRoute, type BudScreen, type ElementSource, type PickerAdapter, type PickerDescription, canvas, defineConfig, files, pages, tasks };
+export { type BudConfig, type BudRoute, type BudScreen, type ElementSource, type PickerAdapter, type PickerDescription, canvas, defineConfig, files, pages, picker, taskDesign, tasks };

package/dist/types/node-host.d.ts

@@ -1,5 +1,5 @@
-import { d as BudTheme } from "./assets/config-DIC2cf_S.js";
-import { a as HostedAuthor, s as HostedRequestContext } from "./assets/contract-CAT-XFNq.js";
+import { m as BudTheme } from "./assets/config-CvcYmE2s.js";
+import { a as HostedAuthor, l as HostedRequestContext } from "./assets/contract-B7yuuqSn.js";
 //#region src/node-host.server.d.ts
 /** Where the project's Bud on Cloudflare is, and the secret its remote API takes. */
 export interface NodeHostOptions {

package/dist/types/plugins.d.ts

@@ -0,0 +1,445 @@
+import { n as ThreadAdapter, r as WorkAdapter, t as MemoryAdapterOptions } from "./assets/memory-state-BBW-FAVA.js";
+import { c as taskDesign, i as ResolvedBudConfig, o as BudPluginBase, r as ProjectInfo, s as picker } from "./assets/config-CvcYmE2s.js";
+import * as Effect from "effect/Effect";
+import * as Cause from "effect/Cause";
+import * as Layer from "effect/Layer";
+//#region ../factory/src/lib/run.d.ts
+/** Where a run is: setting up, working, waiting for review, being pushed, or over. */
+type RunState = "provisioning" | "working" | "review" | "needs_context" | "changes" | "approved" | "pushing" | "pushed" | "merged" | "failed" | "discarded";
+/** A person, as the server derived them. */
+interface RunPerson {
+  name: string;
+  email: string;
+}
+/** One line of a run's activity, as the task shows it. */
+interface RunActivity {
+  at: string;
+  kind: "status" | "message" | "tool" | "error";
+  text: string;
+}
+/**
+ * A task's run, kept in its metadata as `budRun`. It never holds secrets or tokens: it syncs into
+ * the task store's history.
+ */
+interface RunRecord {
+  version: 1;
+  id: string;
+  state: RunState;
+  /** The step that failed, which Retry repeats; null unless failed. */
+  failedIn: RunState | null;
+  provider: string;
+  sandbox: string | null;
+  harness: string;
+  model: string;
+  session: string | null;
+  /**
+   * The sandbox's ports for the dev server and the agent, once it is set up, and for its terminal
+   * bridge and the preview proxy in front of the dev server where it has them.
+   */
+  ports: {
+    dev: number | null;
+    agent: number | null;
+    terminal?: number | null;
+    preview?: number | null;
+  };
+  branch: string;
+  base: {
+    branch: string;
+    commit: string | null;
+  };
+  /**
+   * Whether the sandbox is stopped to save cost while nobody needs it, its disk kept; the preview,
+   * changes or approval wake it.
+   */
+  asleep: boolean;
+  /** The agent's last commit. */
+  head: string | null;
+  /** The commit pushed on approval. */
+  pushed: string | null;
+  summary: string | null;
+  /** What the agent asked when it couldn't go on without a person; null unless it waits. */
+  question: string | null;
+  activity: RunActivity[];
+  error: {
+    message: string;
+    at: string;
+    retryable: boolean;
+  } | null;
+  startedBy: RunPerson;
+  approvedBy: RunPerson | null;
+  createdAt: string;
+  updatedAt: string;
+  /** Earlier runs of the task, newest first. */
+  previous: {
+    id: string;
+    state: RunState;
+    endedAt: string;
+  }[];
+}
+/** What happened to a run: a person's action, or what the sandbox or agent reported. */
+type RunEvent = {
+  type: "ready";
+  sandbox: string;
+  session: string;
+  commit: string | null;
+  ports: RunRecord["ports"];
+} | {
+  type: "created";
+  sandbox: string;
+} | {
+  type: "activity";
+  entry: Omit<RunActivity, "at">;
+} | {
+  type: "idle";
+  summary: string;
+  head: string | null;
+} | {
+  type: "changes";
+  message: string;
+  by: RunPerson;
+} | {
+  type: "answer";
+  message: string;
+  by: RunPerson;
+} | {
+  type: "approve";
+  by: RunPerson;
+} | {
+  type: "pushed";
+  commit: string;
+} | {
+  type: "merged";
+} | {
+  type: "discard";
+} | {
+  type: "fail";
+  message: string;
+  retryable: boolean;
+} | {
+  type: "retry";
+} | {
+  type: "sleep";
+} | {
+  type: "wake";
+};
+//#endregion
+//#region ../factory/src/server/harness.d.ts
+/** What an agent reports while it works: activity, done, or broken. */
+type RunFollowEvent = Extract<RunEvent, {
+  type: "activity" | "idle" | "fail";
+}>;
+/** An image that goes with a prompt, such as the comment's screenshot, as base64. */
+interface HarnessImage {
+  mime: string;
+  name: string;
+  data: string;
+}
+/** Where a run's agent server listens, as Bud reaches it through the sandbox provider. */
+interface HarnessAddress {
+  url: string;
+  /** Sent with every request, such as the provider's access cookie. */
+  headers: Record<string, string>;
+  /** The password the server was started with, derived per run. */
+  password: string;
+}
+/** One run's agent server: its sessions, prompts and what it does. */
+interface HarnessAgent {
+  /** Whether the server answers yet. */
+  healthy(): Promise<boolean>;
+  /** Starts a session for the task and returns its id. */
+  session(title: string): Promise<string>;
+  /** Sends a prompt, resolving once the session has it. */
+  prompt(session: string, text: string, images?: readonly HarnessImage[]): Promise<void>;
+  /**
+   * The agent's work from now on: activity while it works, then `idle` with its summary and the
+   * checkout's commit, or `fail`. A turn that ended before the follow began ends it at once.
+   */
+  follow(session: string, head: () => Promise<string | null>, signal: AbortSignal): AsyncIterable<RunFollowEvent>;
+}
+/**
+ * The coding agent a run works with, such as OpenCode: how its server starts in a sandbox and
+ * how Bud talks to it. A plugin's `harness`.
+ */
+interface Harness {
+  /** Such as `opencode`, kept on each run. */
+  id: string;
+  /** The model, as the harness names it, kept on each run. */
+  model: string;
+  /** Server environment variables the model needs, passed into sandboxes as secrets. */
+  keys: readonly string[];
+  /** The port the server prefers when the provider doesn't pick one. */
+  port: number;
+  /**
+   * The shell command starting the agent's server in the sandbox's checkout, on 127.0.0.1, and
+   * the environment it needs.
+   */
+  start(options: {
+    port: number;
+    password: string;
+    /** Bud's read-only task database for the agent, as an MCP server, when it can reach it. */
+    tools?: {
+      url: string;
+      token: string;
+    };
+  }): {
+    command: string;
+    env: Record<string, string>;
+  };
+  /** A client for a run's server. */
+  connect(address: HarnessAddress, fetch?: typeof globalThis.fetch): HarnessAgent;
+  /**
+   * The shell command opening the agent's own interface on a session in a terminal in the
+   * sandbox, attached to the running server; none when the harness has no such interface.
+   */
+  attach?(options: {
+    port: number;
+    password: string;
+    session: string;
+  }): {
+    command: string;
+    env: Record<string, string>;
+  };
+}
+//#endregion
+//#region ../factory/src/server/errors.d.ts
+interface RunErrorFields {
+  readonly message: string;
+  readonly retryable: boolean;
+  readonly cause?: unknown;
+}
+declare const RunErrorBase: new (fields: RunErrorFields) => Cause.YieldableError & RunErrorFields & {
+  readonly _tag: "RunError";
+};
+/** A sandbox or agent failure; `retryable` when trying the same step again may work. */
+export declare class RunError extends RunErrorBase {}
+//#endregion
+//#region ../factory/src/server/sandbox.d.ts
+/** What a new sandbox starts from: the project at a ref, on a new local branch. */
+interface SandboxSpec {
+  /** The project's checkout or clone URL, without credentials. */
+  repository: string;
+  /** The ref to start from, such as `main`. */
+  ref: string;
+  /** The local branch to create for the run. */
+  branch: string;
+  /** Run once in the checkout, such as `bun install`; null for none. */
+  setup: string | null;
+  /** For every command and process in the sandbox; values named in `secrets` are never shown. */
+  env: Record<string, string>;
+  secrets: readonly string[];
+  labels: Record<string, string>;
+}
+/** A command's outcome: its exit code and the end of its output. */
+interface SandboxExec {
+  exitCode: number;
+  output: string;
+}
+/** A sandbox port from outside: for browsers, and for Bud's own requests. */
+interface SandboxPort {
+  url: string;
+  server?: {
+    url: string;
+    headers: Record<string, string>;
+  };
+}
+/** What a provider can do beyond the basics. */
+interface SandboxCapabilities {
+  /** Reach a port of the sandbox from outside, for a live preview. */
+  expose: boolean;
+  /** Stop keeps the disk, so resume finds the work as it was. */
+  snapshot: boolean;
+  /** Resume restarts the sandbox's processes. */
+  resume: boolean;
+  /** The sandbox shares this machine's network, so it reaches Bud on 127.0.0.1. */
+  localhost?: boolean;
+}
+/**
+ * Where agents work: a provider of sandboxes, each a checkout of the project with its own
+ * processes. `bud:local` runs them as Git worktrees on this machine; `bud:boat` on boat.dev.
+ */
+interface SandboxAdapter {
+  readonly id: string;
+  readonly capabilities: SandboxCapabilities;
+  /** Creates a sandbox: checkout on the run's branch and setup done. Resolves with its id. */
+  create(spec: SandboxSpec): Effect.Effect<string, RunError>;
+  status(id: string): Effect.Effect<"ready" | "stopped" | "gone", RunError>;
+  /** Runs a shell command in the checkout and waits for it. */
+  exec(id: string, command: string, options?: {
+    env?: Record<string, string>;
+    timeoutMs?: number;
+  }): Effect.Effect<SandboxExec, RunError>;
+  /**
+   * Starts a long-running process in the checkout, such as the dev server or the agent, under a
+   * name; starting a name again replaces it. Resume starts the named processes again.
+   */
+  spawn(id: string, name: string, command: string, options?: {
+    env?: Record<string, string>;
+  }): Effect.Effect<void, RunError>;
+  /**
+   * A free port for a process in the sandbox. Sandboxes on this machine share its ports; a
+   * provider without it has a machine of its own, where the configured ports are free.
+   */
+  freePort?(id: string): Effect.Effect<number, RunError>;
+  /**
+   * A URL that reaches a port of the sandbox, for a browser; it may carry a token, so it is never
+   * stored. `server` is how Bud itself reaches the port, when that differs, such as a URL without
+   * the token and the token as a cookie. `public` asks for a URL a browser can frame without a
+   * token or cookie, such as the preview in Agent view, for as long as the sandbox is up.
+   */
+  expose(id: string, port: number, options?: {
+    public?: boolean;
+  }): Effect.Effect<SandboxPort, RunError>;
+  /** Takes a port's public URL down again, before the sandbox sleeps; stop does it too. */
+  hide?(id: string, port: number): Effect.Effect<void, RunError>;
+  /** Where a named process writes its output in the sandbox, for the terminal to follow. */
+  logFile?(id: string, name: string): string;
+  stop(id: string): Effect.Effect<void, RunError>;
+  resume(id: string): Effect.Effect<void, RunError>;
+  destroy(id: string): Effect.Effect<void, RunError>;
+}
+//#endregion
+//#region ../plugin/src/plugin.server.d.ts
+/** What Bud hands a plugin's store when it makes it: the project it serves. */
+interface PluginHost {
+  project: {
+    readonly root: string;
+    readonly config: ResolvedBudConfig;
+    readonly info: ProjectInfo;
+  };
+}
+/**
+ * A store as a plugin gives it: an Effect layer, or a function making one for the project. Its
+ * layer may use the host's services, such as Project, Git, the file system and the Beads queue.
+ */
+type PluginStore<Service> = Layer.Layer<Service, unknown, any> | ((host: PluginHost) => Layer.Layer<Service, unknown, any>);
+/** What Bud hands a plugin's sandbox provider. */
+interface SandboxContext {
+  /** The project's checkout. */
+  root: string;
+  /** The server's environment, for keys such as `BOAT_API_KEY`. */
+  env: Readonly<Record<string, string | undefined>>;
+  /** The project's push remote as an HTTPS clone URL without credentials, or null. */
+  repository: string | null;
+  /** Credentials for cloning, when the factory has a push token; only the clone may use them. */
+  clone: {
+    username: string;
+    token: string;
+  } | null;
+  /** Server environment variables sandboxes must never see, such as the push token. */
+  withhold: readonly string[];
+}
+/** A Bud plugin, as in Vite: a name, an optional config hook and what it contributes. */
+interface BudPlugin extends BudPluginBase {
+  work?: PluginStore<WorkAdapter>;
+  threads?: PluginStore<ThreadAdapter>;
+  /** The factory's sandboxes, made for the project when Bud starts. */
+  sandbox?: (context: SandboxContext) => SandboxAdapter;
+  /** The factory's coding agent: how its server starts in a sandbox, its model and keys. */
+  harness?: Harness;
+}
+/**
+ * Keeps a plugin typed without changing it.
+ * @param plugin - The plugin.
+ * @returns The same plugin.
+ */
+export declare function definePlugin<P extends BudPlugin>(plugin: P): P;
+/**
+ * Tasks and discussions in memory, for tests and examples; they're gone when Bud stops.
+ * @param options - The schema, the tasks and discussions to start with, and `only` to provide
+ *   just one of the stores.
+ * @returns The plugin.
+ */
+export declare function memory(options?: Partial<MemoryAdapterOptions> & {
+  only?: "work" | "threads";
+}): BudPlugin;
+//#endregion
+//#region ../beads/src/plugin.server.d.ts
+/**
+ * Tasks and discussions in the project's Beads workspace, through the `bd` CLI and Bud's shared
+ * Beads queue: Bud's default stores.
+ * @param options - `only` to provide just one of the stores; both by default.
+ * @returns The store plugin.
+ */
+export declare function beads(options?: {
+  only?: "work" | "threads";
+}): BudPlugin;
+//#endregion
+//#region ../comments/src/plugin.server.d.ts
+/**
+ * Discussions on the project's `bud/comments` Git branch, kept for projects that used Bud's
+ * earlier Git storage; tasks come from another plugin.
+ * @returns The discussion store plugin.
+ */
+export declare function gitComments(): BudPlugin;
+//#endregion
+//#region ../harness-opencode/src/plugin.server.d.ts
+/**
+ * `bud:opencode`: the factory's agent is OpenCode, Bud's default.
+ * @param options - The model as OpenCode names it, `provider/model` (DeepSeek V4.1 Flash on
+ *   OpenCode's free tier by default), and the server variables its key is in, such as
+ *   `DEEPSEEK_API_KEY`, which Bud passes into sandboxes as secrets.
+ * @returns The harness plugin.
+ */
+export declare function opencode(options?: {
+  model?: string;
+  keys?: readonly string[];
+}): BudPlugin;
+//#endregion
+//#region ../picker-react-grab/src/plugin.server.d.ts
+/**
+ * Comments find React components and their source through React Grab, for React projects with
+ * React Grab installed.
+ * @returns The picker plugin.
+ */
+export declare function reactGrab(): BudPlugin;
+/**
+ * Comments find React components and their source from React alone, without React Grab.
+ * @returns The picker plugin.
+ */
+export declare function react(): BudPlugin;
+//#endregion
+//#region ../sandbox-boat/src/sandbox.server.d.ts
+/** How `bud:boat` reaches boat.dev, and the sandboxes it makes. */
+interface BoatSandboxOptions {
+  /** A boat API key (`boat_…`), read on the server. */
+  token: string;
+  /** Defaults to `https://boat.dev/api/v1`. */
+  base?: string;
+  /** The sandbox size; `default` is 4 vCPU and 8 GB. */
+  type?: "small" | "default" | "large" | "xlarge";
+  /** When an idle sandbox stops on its own; 2 hours by default, the trial's limit. */
+  ttlSeconds?: number;
+  /** Git credentials for cloning; they reach only the clone command, like the push token. */
+  clone?: {
+    username: string;
+    token: string;
+  } | null;
+  fetch?: typeof fetch;
+  /** How long to wait between status reads, for tests. */
+  pollMs?: number;
+}
+//#endregion
+//#region ../sandbox-boat/src/plugin.server.d.ts
+/**
+ * `bud:boat`: the factory's sandboxes on boat.dev, full machines cloned from the project's remote
+ * and billed while they run.
+ * @param options - The server variable with the API key (`BOAT_API_KEY` by default), the size
+ *   and how long an idle sandbox lives.
+ * @returns The sandbox plugin.
+ */
+export declare function boat(options?: {
+  key?: string;
+} & Pick<BoatSandboxOptions, "type" | "ttlSeconds">): BudPlugin;
+//#endregion
+//#region ../sandbox-local/src/plugin.server.d.ts
+/**
+ * `bud:local`: the factory's sandboxes as Git worktrees of the project on this machine, for
+ * trying it with tasks you trust; they aren't isolated from your machine.
+ * @param options - Where worktrees go; the system's temp folder by default.
+ * @returns The sandbox plugin.
+ */
+export declare function local(options?: {
+  directory?: string;
+}): BudPlugin;
+//#endregion
+export { type BudPlugin, type Harness, type HarnessAddress, type HarnessAgent, type HarnessImage, type PluginHost, type PluginStore, type RunFollowEvent, type SandboxAdapter, type SandboxCapabilities, type SandboxContext, type SandboxExec, type SandboxPort, type SandboxSpec, picker, taskDesign };

package/dist/types/screen.d.ts

@@ -1,5 +1,5 @@
-import { r as ProjectInfo } from "./assets/config-DIC2cf_S.js";
-import { i as TaskDesign } from "./assets/task-design-xJOhRNWh.js";
+import { r as ProjectInfo } from "./assets/config-CvcYmE2s.js";
+import { i as TaskDesign } from "./assets/task-design-BDHKFHpp.js";
 import { RequestMethod, Route, RouteMap } from "remix/routes";
 import { Handle, Props, RemixNode } from "remix/component";
 import { MatchParams } from "remix/route-pattern/match";