@coltonkirsten/a12s 0.5.0 → 0.7.0

package/dist/src/client.d.ts

@@ -1,5 +1,5 @@
-import type { A12sEvent, ApiErrorBody, ComputerStatus, EnqueueRequest, EnqueueResponse, GapData, InboxListOptions, InboxListResponse, Message, PutFleetRequest, PutFleetResponse, ServiceStatus, StatusResponse, Token, TokenRequest, Turn } from "./types.js";
-export interface A12sClientOptions {
+import type { A12sEvent, ApiErrorBody, ComputerStatus, EnqueueResponse, GapData, InboxListOptions, InboxListResponse, Message, PutFleetRequest, PutFleetResponse, SendRequest, ServiceStatus, StatusResponse, Token, TokenRequest, Turn } from "./types.js";
+export interface ConnectOptions {
     /**
      * The Controller's API, e.g. http://127.0.0.1:52011. Default "": the page's own origin, which is what a browser
      * app served by `a12s gateway` uses.
@@ -58,18 +58,14 @@ export interface WaitOptions {
 export interface Reply extends Turn {
     message: EnqueueResponse;
 }
-/**
- * @deprecated Use {@link Fleet}: `fleet.agentComputers.get(name)` returns an {@link AgentComputer} with these
- * methods. Kept for one release.
- */
-export declare class A12sClient {
+/** The HTTP transport behind {@link Fleet} and its handles; the package doesn't export it. */
+export declare class Client {
     readonly url: string;
     private readonly token?;
     private readonly fetchImpl;
     private shared?;
-    constructor(opts?: A12sClientOptions);
+    constructor(opts?: ConnectOptions);
     private headers;
-    /** @internal */
     request<T>(method: string, path: string, body?: unknown, opts?: {
         headers?: Record<string, string>;
         signal?: AbortSignal;
@@ -81,9 +77,9 @@ export declare class A12sClient {
      * Puts a Message in a Computer's inbox and returns at once. It is delivered at the Computer's next idle moment,
      * batched with anything else pending. Works while the Computer is busy or asleep.
      */
-    send(computer: string, msg: EnqueueRequest | string): Promise<EnqueueResponse>;
+    send(computer: string, msg: SendRequest | string): Promise<EnqueueResponse>;
     /** Sends a Message, waits for the Turn that delivers it and resolves when that Turn ends. */
-    prompt(computer: string, body: string, opts?: Omit<EnqueueRequest, "body"> & WaitOptions): Promise<Reply>;
+    prompt(computer: string, body: string, opts?: Omit<SendRequest, "body"> & WaitOptions): Promise<Reply>;
     /**
      * @internal Waits for the Turn that delivers the Message and resolves when it ends. Delivery is read from the
      * Message's own snapshot and the Turn is replayed from its start, so it works however late it is called.
@@ -91,7 +87,7 @@ export declare class A12sClient {
     reply(computer: string, message: EnqueueResponse, opts?: WaitOptions): Promise<Reply>;
     /**
      * Live events of one Computer, several, or (no argument) every Computer in the Fleet, merged. Each event carries
-     * its `computer`. Reconnects after a network drop without losing or repeating events. Call `await stream.ready()`
+     * its `agentComputer`. Reconnects after a network drop without losing or repeating events. Call `await stream.ready()`
      * before sending work you want to see from the start; `close()` (or `break`) ends it.
      */
     events(computers?: string | string[], opts?: EventsOptions): EventStream;
@@ -118,10 +114,8 @@ export declare class A12sClient {
     sleep(computer: string, opts?: {
         hold?: boolean;
     }): Promise<void>;
-    /** Starts a sleeping agent computer; its session resumes on the next Turn. `clearInbox` discards pending Messages. */
-    wake(computer: string, opts?: {
-        clearInbox?: boolean;
-    }): Promise<void>;
+    /** Starts a sleeping agent computer; its session resumes on the next Turn. */
+    wake(computer: string): Promise<void>;
     /** Holds the inbox: Messages still queue, none is delivered until resume(). */
     hold(computer: string, opts?: {
         reason?: string;

package/dist/src/client.js

@@ -1,4 +1,4 @@
-// Runs in Node, Deno, Bun and browsers: no node: imports here (`npm run dashboard` bundles it for the browser).
+// Runs in Node, Deno, Bun and browsers: no node: imports here (`npm run browser` bundles it for the browser).
 import { readSSE } from "./sse.js";
 /** A refused call: the HTTP status and the Controller's error, including its fix line. */
 export class A12sError extends Error {
@@ -45,11 +45,8 @@ export class A12sStreamError extends Error {
     }
 }
 const enc = encodeURIComponent;
-/**
- * @deprecated Use {@link Fleet}: `fleet.agentComputers.get(name)` returns an {@link AgentComputer} with these
- * methods. Kept for one release.
- */
-export class A12sClient {
+/** The HTTP transport behind {@link Fleet} and its handles; the package doesn't export it. */
+export class Client {
     url;
     token;
     fetchImpl;
@@ -62,7 +59,6 @@ export class A12sClient {
     headers(extra = {}) {
         return this.token ? { authorization: `Bearer ${this.token}`, ...extra } : extra;
     }
-    /** @internal */
     async request(method, path, body, opts = {}) {
         const res = await this.fetchImpl(this.url + path, {
             method,
@@ -90,8 +86,7 @@ export class A12sClient {
      * batched with anything else pending. Works while the Computer is busy or asleep.
      */
     send(computer, msg) {
-        const m = typeof msg === "string" ? { body: msg } : { ...msg };
-        m.idempotencyKey ??= globalThis.crypto.randomUUID();
+        const m = { ...(typeof msg === "string" ? { body: msg } : msg), idempotencyKey: globalThis.crypto.randomUUID() };
         return this.request("POST", `/v1/agent-computers/${enc(computer)}/inbox`, m);
     }
     /** Sends a Message, waits for the Turn that delivers it and resolves when that Turn ends. */
@@ -118,7 +113,7 @@ export class A12sClient {
     }
     /**
      * Live events of one Computer, several, or (no argument) every Computer in the Fleet, merged. Each event carries
-     * its `computer`. Reconnects after a network drop without losing or repeating events. Call `await stream.ready()`
+     * its `agentComputer`. Reconnects after a network drop without losing or repeating events. Call `await stream.ready()`
      * before sending work you want to see from the start; `close()` (or `break`) ends it.
      */
     events(computers, opts = {}) {
@@ -186,12 +181,9 @@ export class A12sClient {
             ...(opts.hold ? { hold: true } : {}),
         });
     }
-    /** Starts a sleeping agent computer; its session resumes on the next Turn. `clearInbox` discards pending Messages. */
-    async wake(computer, opts = {}) {
-        await this.request("POST", `/v1/agent-computers/${enc(computer)}/power`, {
-            state: "awake",
-            ...(opts.clearInbox ? { clearInbox: true, requestId: crypto.randomUUID() } : {}),
-        });
+    /** Starts a sleeping agent computer; its session resumes on the next Turn. */
+    async wake(computer) {
+        await this.request("POST", `/v1/agent-computers/${enc(computer)}/power`, { state: "awake" });
     }
     /** Holds the inbox: Messages still queue, none is delivered until resume(). */
     hold(computer, opts = {}) {
@@ -307,7 +299,7 @@ export class A12sClient {
                         cursor = undefined; // the stream goes live; a reconnect starts live too
                         if (opts.onGap === "throw")
                             throw new A12sGapError(data);
-                        const gap = { v: 1, computer, session: "", turn: "", seq: 0, ts: new Date().toISOString(), type: "gap", data };
+                        const gap = { v: 1, agentComputer: computer, session: "", turn: "", seq: 0, ts: new Date().toISOString(), type: "gap", data };
                         yield gap;
                         continue;
                     }
@@ -478,7 +470,7 @@ class SharedEvents {
         }
         if (f.event === "gap") {
             const data = cursor !== undefined ? { lastEventId: cursor } : {};
-            const gap = { v: 1, computer: "", session: "", turn: "", seq: 0, ts: new Date().toISOString(), type: "gap", data };
+            const gap = { v: 1, session: "", turn: "", seq: 0, ts: new Date().toISOString(), type: "gap", data };
             for (const s of this.subs) {
                 if (s.onGap === "throw")
                     s.fail(new A12sGapError(data));
@@ -510,7 +502,7 @@ class SharedEvents {
     }
 }
 function agentComputerOf(ev) {
-    return ev.agentComputer || ev.computer;
+    return ev.agentComputer ?? "";
 }
 function wanted(names, ev) {
     if (!names)
@@ -721,7 +713,6 @@ class TurnBuilder {
                 this.open.delete(key);
                 return {
                     agentComputer: name,
-                    computer: name,
                     id: ev.turn,
                     session: ev.session,
                     status: ev.data.status,

package/dist/src/fleet.d.ts

@@ -1,11 +1,9 @@
-import { A12sClient, type A12sClientOptions, type EventsOptions, TurnStream, type EventStream, type Reply, type SharedEventsOptions, type WaitOptions } from "./client.js";
-import type { AgentComputerData, AgentComputerSpec, Change, ComputerStatus, CredentialInfo, EnqueueRequest, EnqueueResponse, FleetSpec, InboxListOptions, InboxListResponse, MergePatch, Message, ServiceStatus, StatusResponse, Token, TokenAction, Turn } from "./types.js";
+import { Client, type ConnectOptions, type EventsOptions, TurnStream, type EventStream, type Reply, type SharedEventsOptions, type WaitOptions } from "./client.js";
+import type { AgentComputerData, AgentComputerSpec, ComputerStatus, CredentialInfo, EnqueueResponse, FleetSpec, InboxListOptions, InboxListResponse, MergePatch, Message, SendRequest, ServiceStatus, StatusResponse, Token, TokenAction, Turn } from "./types.js";
 /** The Fleet as written, and its version for a conditional write. */
 export interface FleetState {
     version: number;
     spec: FleetSpec;
-    /** What changed through the API since the last whole-Fleet write. */
-    drift: Change[];
 }
 export interface CreateOptions {
     /** Overwrite an existing one instead of failing with A12sError code `exists`. */
@@ -23,19 +21,21 @@ export interface CreateOptions {
  * ```
  */
 export declare class Fleet {
-    /** The lower-level client the handles use, for API calls that have no method here. */
-    readonly client: A12sClient;
+    /** For API calls that have no method here: `request(method, path, body?, { headers, signal })`. */
+    readonly client: Pick<Client, "url" | "request">;
     readonly agentComputers: AgentComputers;
     readonly services: Services;
     readonly tokens: Tokens;
     readonly credentials: Credentials;
+    private readonly transport;
     /** No discovery: `url` and `token` as given, by default the page's own origin. */
-    constructor(opts?: A12sClientOptions);
+    constructor(opts?: ConnectOptions);
     /**
      * In a browser: the Fleet behind the page's own origin, which is `a12s gateway` serving the page (no token
-     * needed). In Node: found like {@link connect} finds it. Pass `url` and `token` to reach anything else.
+     * needed). In Node: a running Fleet found from the files `a12s up` writes. Pass `url` and `token` to reach anything
+     * else.
      */
-    static connect(opts?: A12sClientOptions): Promise<Fleet>;
+    static connect(opts?: ConnectOptions): Promise<Fleet>;
     get url(): string;
     get(): Promise<FleetState>;
     /**
@@ -57,7 +57,7 @@ export declare class Fleet {
 }
 export declare class AgentComputers {
     private readonly client;
-    constructor(client: A12sClient);
+    constructor(client: Client);
     /**
      * Adds an agent computer to the Fleet and starts it. One that names a credential with no value yet resolves at once,
      * waiting in Provisioning (`status.waiting`, and a console warning); it starts when the value is set. Fails with
@@ -76,7 +76,7 @@ export declare class AgentComputer {
     /** The spec with the Fleet's defaults merged in. */
     effective: AgentComputerSpec;
     status: ComputerStatus;
-    constructor(client: A12sClient, data: AgentComputerData);
+    constructor(client: Client, data: AgentComputerData);
     private set;
     private get path();
     reload(): Promise<this>;
@@ -88,7 +88,7 @@ export declare class AgentComputer {
      * Puts a Message in the inbox; it is delivered at the next idle moment. Await it for the queued Message, or call
      * `wait()` on it (or on the awaited Message, at any time later) for the Turn that delivers it.
      */
-    send(text: string, opts?: Omit<EnqueueRequest, "body">): Sending;
+    send(text: string, opts?: Omit<SendRequest, "body">): Sending;
     /** Its events, live, from the Fleet's shared connection; `turn` replays one Turn from its start instead. */
     events(opts?: EventsOptions): EventStream;
     /** Its last `limit` finished Turns, newest first. */
@@ -104,10 +104,8 @@ export declare class AgentComputer {
     sleep(opts?: {
         hold?: boolean;
     }): Promise<void>;
-    /** Wakes it; `clearInbox` discards the pending Messages first. */
-    wake(opts?: {
-        clearInbox?: boolean;
-    }): Promise<void>;
+    /** Wakes it; its session resumes on the next Turn. */
+    wake(): Promise<void>;
     /** Holds its inbox: Messages still queue, none is delivered until resume(). */
     hold(opts?: {
         reason?: string;
@@ -142,7 +140,7 @@ export declare class Sending implements Promise<SentMessage> {
 }
 export declare class Services {
     private readonly client;
-    constructor(client: A12sClient);
+    constructor(client: Client);
     /** Adds a Service to the Fleet. Fails with code `exists` if the name is taken. */
     create(name: string, spec?: Record<string, unknown> & CreateOptions): Promise<Service>;
     /** Throws {@link NotFound} if there is none. */
@@ -154,7 +152,7 @@ export declare class Service {
     private readonly client;
     readonly name: string;
     status: ServiceStatus;
-    constructor(client: A12sClient, status: ServiceStatus);
+    constructor(client: Client, status: ServiceStatus);
     /** As written in the Fleet. */
     get spec(): Record<string, unknown>;
     private get path();
@@ -169,10 +167,11 @@ export declare class Service {
 }
 export declare class Tokens {
     private readonly client;
-    constructor(client: A12sClient);
+    constructor(client: Client);
     /**
      * A token for another program; owner only. The secret is in the result once. With `prefix` it may do everything
-     * the owner can for names that start with it, and nothing outside; otherwise `actions` on `agentComputers`.
+     * the owner can for names that start with it except set `security.seccomp`, and nothing outside; otherwise
+     * `actions` on `agentComputers`.
      */
     create(name: string, opts: {
         prefix: string;
@@ -186,7 +185,7 @@ export declare class Tokens {
 /** Credentials by name: set once, then name them in a spec's `credentials`. Values are never read back. */
 export declare class Credentials {
     private readonly client;
-    constructor(client: A12sClient);
+    constructor(client: Client);
     /** Stores the value on the Controller; agent computers that use it get the new value at once. */
     set(name: string, value: string): Promise<CredentialInfo>;
     list(): Promise<CredentialInfo[]>;

package/dist/src/fleet.js

@@ -1,5 +1,5 @@
-// Runs in Node, Deno, Bun and browsers: no node: imports here (`npm run dashboard` bundles it for the browser).
-import { A12sClient, A12sError, TurnStream, } from "./client.js";
+// Runs in Node, Deno, Bun and browsers: no node: imports here (`npm run browser` bundles it for the browser).
+import { A12sError, Client, TurnStream, } from "./client.js";
 const enc = encodeURIComponent;
 const maxReplaceTries = 5;
 /**
@@ -14,23 +14,25 @@ const maxReplaceTries = 5;
  * ```
  */
 export class Fleet {
-    /** The lower-level client the handles use, for API calls that have no method here. */
+    /** For API calls that have no method here: `request(method, path, body?, { headers, signal })`. */
     client;
     agentComputers;
     services;
     tokens;
     credentials;
+    transport;
     /** No discovery: `url` and `token` as given, by default the page's own origin. */
     constructor(opts = {}) {
-        this.client = new A12sClient(opts);
-        this.agentComputers = new AgentComputers(this.client);
-        this.services = new Services(this.client);
-        this.tokens = new Tokens(this.client);
-        this.credentials = new Credentials(this.client);
+        this.client = this.transport = new Client(opts);
+        this.agentComputers = new AgentComputers(this.transport);
+        this.services = new Services(this.transport);
+        this.tokens = new Tokens(this.transport);
+        this.credentials = new Credentials(this.transport);
     }
     /**
      * In a browser: the Fleet behind the page's own origin, which is `a12s gateway` serving the page (no token
-     * needed). In Node: found like {@link connect} finds it. Pass `url` and `token` to reach anything else.
+     * needed). In Node: a running Fleet found from the files `a12s up` writes. Pass `url` and `token` to reach anything
+     * else.
      */
     static async connect(opts = {}) {
         return new Fleet(opts);
@@ -40,7 +42,7 @@ export class Fleet {
     }
     async get() {
         const r = await this.client.request("GET", "/v1/fleet");
-        return { version: r.version, spec: r.fleet ?? emptySpec(), drift: r.drift ?? [] };
+        return { version: r.version, spec: r.fleet ?? emptySpec() };
     }
     /**
      * Reads the Fleet, lets `fn` change it (in place, or by returning a new spec) and writes it back only if nobody
@@ -72,16 +74,16 @@ export class Fleet {
      */
     events(agentComputers, opts = {}) {
         if (opts.turn !== undefined || opts.after !== undefined)
-            return this.client.events(agentComputers, opts);
-        return this.client.sharedEvents(namesOf(agentComputers), opts);
+            return this.transport.events(agentComputers, opts);
+        return this.transport.sharedEvents(namesOf(agentComputers), opts);
     }
     /** Finished Turns of the named agent computers, or all of them, as they end. */
     turns(agentComputers, opts = {}) {
-        return new TurnStream(this.client.sharedEvents(namesOf(agentComputers), opts));
+        return new TurnStream(this.transport.sharedEvents(namesOf(agentComputers), opts));
     }
     /** Every agent computer and Service: phase, session, active Turn, inbox, power. */
     status() {
-        return this.client.status();
+        return this.transport.status();
     }
 }
 function namesOf(names) {
@@ -189,9 +191,9 @@ export class AgentComputer {
     sleep(opts = {}) {
         return this.client.sleep(this.name, opts);
     }
-    /** Wakes it; `clearInbox` discards the pending Messages first. */
-    wake(opts = {}) {
-        return this.client.wake(this.name, opts);
+    /** Wakes it; its session resumes on the next Turn. */
+    wake() {
+        return this.client.wake(this.name);
     }
     /** Holds its inbox: Messages still queue, none is delivered until resume(). */
     hold(opts = {}) {
@@ -311,7 +313,8 @@ export class Tokens {
     }
     /**
      * A token for another program; owner only. The secret is in the result once. With `prefix` it may do everything
-     * the owner can for names that start with it, and nothing outside; otherwise `actions` on `agentComputers`.
+     * the owner can for names that start with it except set `security.seccomp`, and nothing outside; otherwise
+     * `actions` on `agentComputers`.
      */
     create(name, opts) {
         if ("prefix" in opts) {

package/dist/src/index.d.ts

@@ -1,12 +1,3 @@
-import { A12sClient, type A12sClientOptions } from "./client.js";
-export * from "./client.js";
+export { A12sError, A12sGapError, A12sStreamError, EventStream, NotFound, TurnStream, type ConnectOptions, type EventsOptions, type Reply, type SharedEventsOptions, type WaitOptions, } from "./client.js";
 export * from "./fleet.js";
 export * from "./types.js";
-export type ConnectOptions = A12sClientOptions;
-/**
- * @deprecated Use `Fleet.connect()`. Kept for one release.
- *
- * In a browser: a client for the page's own origin, which is `a12s gateway` serving the page (no token needed).
- * Pass `url` and `token` to reach anything else.
- */
-export declare function connect(opts?: ConnectOptions): Promise<A12sClient>;

package/dist/src/index.js

@@ -1,15 +1,5 @@
 // The default entry (browsers, Deno, workers): no node: imports. Node resolves "@coltonkirsten/a12s" to ./node.ts instead, through
 // the "node" export condition, so `import { Fleet } from "@coltonkirsten/a12s"` works everywhere.
-import { A12sClient } from "./client.js";
-export * from "./client.js";
+export { A12sError, A12sGapError, A12sStreamError, EventStream, NotFound, TurnStream, } from "./client.js";
 export * from "./fleet.js";
 export * from "./types.js";
-/**
- * @deprecated Use `Fleet.connect()`. Kept for one release.
- *
- * In a browser: a client for the page's own origin, which is `a12s gateway` serving the page (no token needed).
- * Pass `url` and `token` to reach anything else.
- */
-export async function connect(opts = {}) {
-    return new A12sClient(opts);
-}

package/dist/src/node.d.ts

@@ -1,31 +1,25 @@
-import { A12sClient, type A12sClientOptions } from "./client.js";
+import type { ConnectOptions as PageConnectOptions } from "./client.js";
 import { Fleet as PageFleet } from "./fleet.js";
-export * from "./client.js";
-export * from "./fleet.js";
-export * from "./types.js";
+export * from "./index.js";
 export declare class Fleet extends PageFleet {
-    /** A running Fleet, as its owner, found like {@link connect} finds it. */
+    /**
+     * A running Fleet, as its owner. It uses the first of:
+     * 1. `url` (and `token`), or `$A12S_URL` (and `$A12S_TOKEN`);
+     * 2. the Fleet named by `fleet`;
+     * 3. the Fleet file in `$A12S_FLEET`, else the nearest `fleet.yaml` in the current directory or a parent;
+     * 4. the only Fleet with a running Controller on this machine.
+     * For 2–4 it reads `~/.a12s/<fleet>/controller.json`, which `a12s up` writes: its URL always, and its owner token
+     * unless `token` is given (a prefix or narrow token on this machine).
+     */
     static connect(opts?: ConnectOptions): Promise<Fleet>;
 }
-export interface ConnectOptions extends A12sClientOptions {
-    /** The Fleet's name (`metadata.name`). Default: found as described on {@link connect}. */
+export interface ConnectOptions extends PageConnectOptions {
+    /** The Fleet's name (`metadata.name`). Default: found as described on {@link Fleet.connect}. */
     fleet?: string;
     /** Where `.a12s/` lives. Default: the home directory. */
     home?: string;
     /** Where to start looking for fleet.yaml. Default: the current directory. */
     cwd?: string;
 }
-/**
- * @deprecated Use `Fleet.connect()`, which finds the Fleet the same way. Kept for one release.
- *
- * A client for a running Fleet, as its owner. It uses the first of:
- * 1. `url` (and `token`), or `$A12S_URL` (and `$A12S_TOKEN`);
- * 2. the Fleet named by `fleet`;
- * 3. the Fleet file in `$A12S_FLEET`, else the nearest `fleet.yaml` in the current directory or a parent;
- * 4. the only Fleet with a running Controller on this machine.
- * For 2–4 it reads `~/.a12s/<fleet>/controller.json`, which `a12s up` writes: its URL always, and its owner token
- * unless `token` is given (a prefix or narrow token on this machine).
- */
-export declare function connect(opts?: ConnectOptions): Promise<A12sClient>;
 /** metadata.name from a Fleet file, in either `metadata: { name: x }` or block form. */
 export declare function fleetName(yaml: string): string | undefined;

package/dist/src/node.js

@@ -1,32 +1,23 @@
-// The Node entry ("node" export condition): connect() finds a running Fleet from the files `a12s up` writes.
+// The Node entry ("node" export condition): Fleet.connect() finds a running Fleet from the files `a12s up` writes.
 import { readdir, readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
-import { A12sClient } from "./client.js";
 import { Fleet as PageFleet } from "./fleet.js";
-export * from "./client.js";
-export * from "./fleet.js";
-export * from "./types.js";
+export * from "./index.js";
 export class Fleet extends PageFleet {
-    /** A running Fleet, as its owner, found like {@link connect} finds it. */
+    /**
+     * A running Fleet, as its owner. It uses the first of:
+     * 1. `url` (and `token`), or `$A12S_URL` (and `$A12S_TOKEN`);
+     * 2. the Fleet named by `fleet`;
+     * 3. the Fleet file in `$A12S_FLEET`, else the nearest `fleet.yaml` in the current directory or a parent;
+     * 4. the only Fleet with a running Controller on this machine.
+     * For 2–4 it reads `~/.a12s/<fleet>/controller.json`, which `a12s up` writes: its URL always, and its owner token
+     * unless `token` is given (a prefix or narrow token on this machine).
+     */
     static async connect(opts = {}) {
         return new Fleet(await discover(opts));
     }
 }
-/**
- * @deprecated Use `Fleet.connect()`, which finds the Fleet the same way. Kept for one release.
- *
- * A client for a running Fleet, as its owner. It uses the first of:
- * 1. `url` (and `token`), or `$A12S_URL` (and `$A12S_TOKEN`);
- * 2. the Fleet named by `fleet`;
- * 3. the Fleet file in `$A12S_FLEET`, else the nearest `fleet.yaml` in the current directory or a parent;
- * 4. the only Fleet with a running Controller on this machine.
- * For 2–4 it reads `~/.a12s/<fleet>/controller.json`, which `a12s up` writes: its URL always, and its owner token
- * unless `token` is given (a prefix or narrow token on this machine).
- */
-export async function connect(opts = {}) {
-    return new A12sClient(await discover(opts));
-}
 async function discover(opts) {
     const url = opts.url ?? process.env.A12S_URL;
     if (url)
@@ -93,6 +84,6 @@ async function onlyRunningFleet(home) {
     if (running.length === 1)
         return running[0];
     throw new Error(running.length === 0
-        ? "no running Fleet found: run a12s up in your Fleet's directory, or pass connect({ url, token })"
-        : `several Fleets are running (${running.join(", ")}): pass connect({ fleet: "<name>" }) or run from the Fleet's directory`);
+        ? "no running Fleet found: run a12s up in your Fleet's directory, or pass Fleet.connect({ url, token })"
+        : `several Fleets are running (${running.join(", ")}): pass Fleet.connect({ fleet: "<name>" }) or run from the Fleet's directory`);
 }

package/dist/src/types.d.ts

@@ -28,18 +28,8 @@ export interface AgentComputerSpec {
         cpu?: string | number;
         memory?: string | number;
     };
-    home?: {
-        size?: string | number;
-        preset?: string;
-    };
-    autonomy?: "full" | "restricted";
-    /** Credential names; their values come from `a12s up` or the credentials API. */
+    /** Credential names, added to the defaults' list; their values come from `a12s creds set` or the credentials API. */
     credentials?: string[];
-    drives?: Array<{
-        name: string;
-        at: string;
-        readOnly?: boolean;
-    }>;
     egress?: {
         allow?: string[];
     };
@@ -50,7 +40,6 @@ export interface AgentComputerSpec {
     inbox?: {
         maxMessages?: number;
         maxBytes?: string;
-        intro?: string;
     };
     power?: {
         sleepAfterIdle?: string;
@@ -78,15 +67,7 @@ export interface FleetSpec {
     metadata: {
         name: string;
     };
-    egress?: {
-        enforcement?: string;
-        allowPrivate?: string[];
-    };
     defaults?: AgentComputerSpec;
-    drives?: Record<string, {
-        size?: string | number;
-        access: string;
-    }>;
     agent_computers: Record<string, AgentComputerSpec>;
     services?: Record<string, Record<string, unknown>>;
 }
@@ -110,8 +91,6 @@ export interface FieldDiff {
 export interface FleetResponse {
     version: number;
     fleet: FleetSpec | null;
-    /** What changed through the API since the last whole-Fleet write: `a12s up` from the file undoes it. */
-    drift: Change[];
 }
 export interface AgentComputerData {
     name: string;
@@ -124,22 +103,10 @@ export interface AgentComputerData {
 export interface AgentComputersResponse {
     agentComputers: AgentComputerData[];
 }
-export interface Lock {
-    a12s?: string;
-    images: Record<string, string>;
-    bundles: Record<string, string>;
-    presets: Record<string, string>;
-    services?: Record<string, string>;
-    /** Each security.seccomp profile's digest, by its path in the Fleet file. */
-    seccomp?: Record<string, string>;
-}
 export interface PutFleetRequest {
     fleet: FleetSpec;
-    lock?: Lock;
-    /** Credential values by name, base64-encoded (Go []byte). Kept in the Controller's memory only. */
+    /** Credential values by name, base64-encoded (Go []byte). */
     credentials?: Record<string, string>;
-    asleep?: boolean;
-    refresh?: string[];
 }
 export interface ServiceChanges {
     created: string[] | null;
@@ -155,7 +122,6 @@ export interface PutFleetResponse {
     updated: string[] | null;
     staged: string[] | null;
     removed: string[] | null;
-    lock: Lock | null;
     errors?: Record<string, string>;
     warnings?: string[];
     services: ServiceChanges;
@@ -218,28 +184,21 @@ export interface ComputerStatus {
     image: string;
     /** The Fleet's security.seccomp path, when the Computer runs with a custom seccomp profile. */
     seccomp?: string;
-    autonomy: string;
     generation: number;
     stagedGeneration?: number;
     credentialGeneration?: number;
-    /** A quantity such as "10Gi". */
-    homeSize?: string;
-    drives?: string[];
     egressMode?: string;
     warnings?: string[];
     inbox?: InboxSummary;
-    /** Set only on a wake --clear-inbox answer: how many Messages were discarded. */
-    inboxCleared?: number;
     power?: PowerStatus;
 }
 export interface DriveRow {
     name: string;
-    kind: "home" | "work" | "state";
+    kind: "home" | "state";
     computer?: string;
     service?: string;
     /** A quantity such as "10Gi". */
     size?: string;
-    access?: string;
     attachedTo?: string[];
     orphaned?: boolean;
 }
@@ -257,7 +216,6 @@ export interface ServiceStatus {
     send?: string[];
     uses?: string[];
     usedBy?: string[];
-    publish?: string[];
     ports?: string[];
     stateDrive?: string;
     egressMode?: string;
@@ -267,12 +225,8 @@ export interface ServiceStatus {
 }
 export interface StatusResponse {
     fleet: string;
-    egressEnforcement: string;
     agentComputers: ComputerStatus[];
-    /** @deprecated `agentComputers` under its old name. */
-    computers: ComputerStatus[];
     orphanedDrives?: DriveRow[];
-    credentialsLoaded: boolean;
     warnings?: string[];
     orphanedInboxes?: InboxSummary[];
     services?: ServiceStatus[];
@@ -284,12 +238,14 @@ export interface EnqueueRequest {
     sender?: string;
     metadata?: Record<string, string>;
     fresh?: boolean;
-    /** A retry with the same key returns the original Message. The client sends a random one if unset. */
+    /** Set by the client on every send: a request repeated with the same key returns the original Message. */
     idempotencyKey?: string;
     /** Seconds; 0 means now or never. */
     expires?: number;
     replaceKey?: string;
 }
+/** What send() takes: the client sets the idempotencyKey itself. */
+export type SendRequest = Omit<EnqueueRequest, "idempotencyKey">;
 export interface EnqueueResponse {
     id: string;
     seq: number;
@@ -336,10 +292,8 @@ export interface InboxListOptions {
 /** The fields every event has. `seq` is the agent computer's journal position (0 for the Controller's own events). */
 export interface EventEnvelope {
     v: number;
-    /** The agent computer it is about; absent on `fleet.changed` and in journals older than the field. */
+    /** The agent computer it is about; absent on `fleet.changed` and `service.phase`. */
     agentComputer?: string;
-    /** `agentComputer` under its old name, for one release. */
-    computer: string;
     session: string;
     /** The Turn it belongs to; "" for events outside a Turn. */
     turn: string;
@@ -515,8 +469,6 @@ export interface ToolCall {
 /** A finished Turn: what `turns()` yields and `wait()` returns. */
 export interface Turn {
     agentComputer: string;
-    /** `agentComputer` under its old name, for one release. */
-    computer: string;
     /** The Turn id. */
     id: string;
     session: string;
@@ -553,7 +505,7 @@ export interface TokenRequest {
     name: string;
     actions?: TokenAction[];
     computers?: string[];
-    /** Every power over agent computers, Services and credentials whose names start with it; none outside. */
+    /** Every power over agent computers, Services and credentials whose names start with it but seccomp; none outside. */
     prefix?: string;
 }
 /** A credential's name, whether it has a value, and who uses it. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coltonkirsten/a12s",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "TypeScript client for a12s: send work to agent Computers, stream their events and Turns, in Node or the browser",
   "license": "MIT",
   "type": "module",
@@ -35,10 +35,10 @@
     "provenance": true
   },
   "scripts": {
-    "build": "rm -rf dist && tsc -p tsconfig.json && npm run dashboard",
+    "build": "rm -rf dist && tsc -p tsconfig.json && npm run browser",
     "lint": "tsc -p tsconfig.json --noEmit",
     "test": "npm run build && node --test 'dist/test/*.test.js'",
-    "dashboard": "esbuild ../../internal/gateway/dashboard/main.js --bundle --platform=browser --format=esm --alias:@coltonkirsten/a12s=./src/index.ts --log-level=warning --outfile=dist/dashboard.js"
+    "browser": "esbuild src/index.ts --bundle --platform=browser --format=esm --log-level=warning --outfile=dist/browser.js"
   },
   "devDependencies": {
     "@types/node": "^24.19.1",