@hyperdrive.bot/fleet-client 0.3.218 → 0.3.221

package/dist/provider-snapshots/index.js

@@ -0,0 +1,56 @@
+/** Resolve announcements only while observed, coalescing changes during a fetch. */
+export class ProviderSnapshotUpdates {
+    constructor(host) {
+        this.host = host;
+        this.pending = new Map();
+    }
+    clear() {
+        this.pending.clear();
+    }
+    receive(update) {
+        if (!this.host.active(update))
+            return;
+        const key = JSON.stringify([update.payload.subscriptionId, update.payload.cwd]);
+        const pending = this.pending.get(key) ?? { latest: update, running: false };
+        pending.latest = update;
+        this.pending.set(key, pending);
+        if (pending.running)
+            return;
+        pending.running = true;
+        void this.resolve(key, pending);
+    }
+    async resolve(key, pending) {
+        try {
+            while (this.pending.get(key) === pending) {
+                const announced = pending.latest;
+                if (!this.host.active(announced))
+                    return;
+                const snapshot = await this.host.fetch(announced.payload.cwd);
+                if (!this.host.active(announced))
+                    return;
+                if (this.pending.get(key) !== pending)
+                    return;
+                // A change arriving while the body was in flight needs the current body.
+                // If that response already covers it, no second fetch is necessary.
+                if (pending.latest !== announced &&
+                    pending.latest.payload.snapshotHash !== snapshot.snapshotHash)
+                    continue;
+                this.pending.delete(key);
+                this.host.emit({
+                    type: "providers_snapshot_update",
+                    payload: { ...snapshot, subscriptionId: announced.payload.subscriptionId },
+                });
+                return;
+            }
+        }
+        catch (error) {
+            if (this.pending.get(key) === pending)
+                this.host.failed(error);
+        }
+        finally {
+            if (this.pending.get(key) === pending)
+                this.pending.delete(key);
+        }
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/terminal-stream-router.d.ts

@@ -1,28 +1,25 @@
 import { type TerminalStreamFrame } from "@hyperdrive.bot/fleet-protocol/binary-frames/index";
-import type { TerminalInput, TerminalState } from "@hyperdrive.bot/fleet-protocol/messages";
+import type { TerminalState } from "@hyperdrive.bot/fleet-protocol/messages";
 export type TerminalStreamEvent = {
     terminalId: string;
+    subscriptionId: string;
+} & ({
     type: "output";
     data: Uint8Array;
 } | {
-    terminalId: string;
     type: "snapshot";
     state: TerminalState;
 } | {
-    terminalId: string;
     type: "restore";
     data: Uint8Array;
-};
+});
 export declare class TerminalStreamRouter {
-    private readonly terminalSlots;
-    private readonly slotTerminals;
+    private readonly slots;
     private readonly listeners;
+    /** Passive wire diagnostics. App state consumes the registration's callback. */
     onEvent(handler: (event: TerminalStreamEvent) => void): () => void;
-    setSlot(terminalId: string, slot: number): void;
-    removeTerminal(terminalId: string): void;
+    attach(subscriptionId: string, terminalId: string, slot: number, receive: (event: TerminalStreamEvent) => void): () => void;
     clearSlots(): void;
-    encodeInput(terminalId: string, message: TerminalInput["message"]): Uint8Array | null;
     handleFrame(frame: TerminalStreamFrame): void;
-    private emit;
 }
 //# sourceMappingURL=terminal-stream-router.d.ts.map

package/dist/terminal-stream-router.js

@@ -1,106 +1,60 @@
-import { decodeTerminalSnapshotPayload, encodeTerminalResizePayload, encodeTerminalStreamFrame, TerminalStreamOpcode, } from "@hyperdrive.bot/fleet-protocol/binary-frames/index";
+import { decodeTerminalSnapshotPayload, TerminalStreamOpcode, } from "@hyperdrive.bot/fleet-protocol/binary-frames/index";
 export class TerminalStreamRouter {
     constructor() {
-        this.terminalSlots = new Map();
-        this.slotTerminals = new Map();
+        this.slots = new Map();
         this.listeners = new Set();
     }
+    /** Passive wire diagnostics. App state consumes the registration's callback. */
     onEvent(handler) {
         this.listeners.add(handler);
         return () => {
             this.listeners.delete(handler);
         };
     }
-    setSlot(terminalId, slot) {
-        const existingTerminalId = this.slotTerminals.get(slot);
-        if (existingTerminalId && existingTerminalId !== terminalId) {
-            this.terminalSlots.delete(existingTerminalId);
-        }
-        const existingSlot = this.terminalSlots.get(terminalId);
-        if (typeof existingSlot === "number" && existingSlot !== slot) {
-            this.slotTerminals.delete(existingSlot);
-        }
-        this.terminalSlots.set(terminalId, slot);
-        this.slotTerminals.set(slot, terminalId);
-    }
-    removeTerminal(terminalId) {
-        const slot = this.terminalSlots.get(terminalId);
-        if (typeof slot !== "number") {
-            return;
-        }
-        this.terminalSlots.delete(terminalId);
-        if (this.slotTerminals.get(slot) === terminalId) {
-            this.slotTerminals.delete(slot);
-        }
+    attach(subscriptionId, terminalId, slot, receive) {
+        const registration = { subscriptionId, terminalId, receive };
+        const registrations = this.slots.get(slot) ?? new Set();
+        registrations.add(registration);
+        this.slots.set(slot, registrations);
+        return () => {
+            registrations.delete(registration);
+            if (registrations.size === 0)
+                this.slots.delete(slot);
+        };
     }
     clearSlots() {
-        this.terminalSlots.clear();
-        this.slotTerminals.clear();
-    }
-    encodeInput(terminalId, message) {
-        const slot = this.terminalSlots.get(terminalId);
-        if (typeof slot !== "number") {
-            return null;
-        }
-        if (message.type === "input") {
-            return encodeTerminalStreamFrame({
-                opcode: TerminalStreamOpcode.Input,
-                slot,
-                payload: message.data,
-            });
-        }
-        if (message.type === "resize") {
-            return encodeTerminalStreamFrame({
-                opcode: TerminalStreamOpcode.Resize,
-                slot,
-                payload: encodeTerminalResizePayload({
-                    rows: message.rows,
-                    cols: message.cols,
-                }),
-            });
-        }
-        return null;
+        this.slots.clear();
     }
     handleFrame(frame) {
-        const terminalId = this.slotTerminals.get(frame.slot);
-        if (!terminalId) {
-            return;
-        }
-        if (frame.opcode === TerminalStreamOpcode.Output) {
-            this.emit({
-                terminalId,
-                type: "output",
-                data: frame.payload,
-            });
+        const registrations = this.slots.get(frame.slot);
+        if (!registrations)
             return;
-        }
-        if (frame.opcode === TerminalStreamOpcode.Restore) {
-            this.emit({
-                terminalId,
-                type: "restore",
-                data: frame.payload,
-            });
-            return;
-        }
-        if (frame.opcode === TerminalStreamOpcode.Snapshot) {
-            const state = decodeTerminalSnapshotPayload(frame.payload);
-            if (!state) {
-                return;
+        for (const registration of registrations) {
+            const identity = {
+                subscriptionId: registration.subscriptionId,
+                terminalId: registration.terminalId,
+            };
+            let event;
+            if (frame.opcode === TerminalStreamOpcode.Output)
+                event = { ...identity, type: "output", data: frame.payload };
+            else if (frame.opcode === TerminalStreamOpcode.Restore)
+                event = { ...identity, type: "restore", data: frame.payload };
+            else if (frame.opcode === TerminalStreamOpcode.Snapshot) {
+                const state = decodeTerminalSnapshotPayload(frame.payload);
+                if (!state)
+                    return;
+                event = { ...identity, type: "snapshot", state };
             }
-            this.emit({
-                terminalId,
-                type: "snapshot",
-                state,
-            });
-        }
-    }
-    emit(event) {
-        for (const listener of this.listeners) {
-            try {
-                listener(event);
-            }
-            catch {
-                // no-op
+            else
+                return;
+            registration.receive(event);
+            for (const listener of this.listeners) {
+                try {
+                    listener(event);
+                }
+                catch {
+                    /* Passive diagnostics cannot interrupt delivery. */
+                }
             }
         }
     }

package/dist/terminals/index.d.ts

@@ -0,0 +1,69 @@
+import { z } from "zod";
+import type { DaemonClient } from "../daemon-client.js";
+declare const TerminalSchema: z.ZodObject<{
+    id: z.ZodString;
+    workspaceId: z.ZodString;
+    cwd: z.ZodString;
+    name: z.ZodString;
+}, z.core.$strip>;
+export type PaseoTerminal = z.infer<typeof TerminalSchema>;
+export interface PaseoTerminalCreateOptions {
+    workspaceId: string;
+    /** Process working directory; defaults to the workspace directory. */
+    cwd?: string;
+    name?: string;
+    command?: string;
+    args?: string[];
+    size?: {
+        rows: number;
+        cols: number;
+    };
+    requestId?: string;
+}
+export interface PaseoTerminalListOptions {
+    /** Ownership filter. When supplied, cwd does not restrict the results. */
+    workspaceId?: string;
+    /** Workspace root directory filter for unscoped listings. */
+    cwd?: string;
+    requestId?: string;
+}
+export interface PaseoTerminalListResult {
+    entries: PaseoTerminal[];
+    requestId: string;
+}
+export interface PaseoTerminalCaptureOptions {
+    start?: number;
+    end?: number;
+    stripAnsi?: boolean;
+    requestId?: string;
+}
+export type PaseoTerminalCaptureResult = Awaited<ReturnType<DaemonClient["captureTerminal"]>>;
+export interface PaseoTerminalHandle {
+    readonly id: string;
+    current(): PaseoTerminal | null;
+    refresh(options?: {
+        requestId?: string;
+    }): Promise<PaseoTerminal | null>;
+    /** Sends literal input and returns its UTF-16 length. Does not await command execution. */
+    write(data: string): number;
+    /** Expands CLI key tokens; other strings are literal. Returns the input's UTF-16 length. */
+    sendKeys(keys: readonly string[]): number;
+    capture(options?: PaseoTerminalCaptureOptions): Promise<PaseoTerminalCaptureResult>;
+    kill(requestId?: string): Promise<void>;
+}
+export interface PaseoTerminalActions {
+    create(options: PaseoTerminalCreateOptions): Promise<PaseoTerminalHandle>;
+    list(options?: PaseoTerminalListOptions): Promise<PaseoTerminalListResult>;
+    ref(terminal: string | PaseoTerminal): PaseoTerminalHandle;
+}
+export interface PaseoWorkspaceTerminalActions {
+    create(options?: Omit<PaseoTerminalCreateOptions, "workspaceId">): Promise<PaseoTerminalHandle>;
+    list(options?: {
+        requestId?: string;
+    }): Promise<PaseoTerminalListResult>;
+}
+type TerminalClient = Pick<DaemonClient, "ensureConnected" | "getLastServerInfoMessage" | "createTerminal" | "listTerminals" | "sendTerminalInput" | "captureTerminal" | "killTerminal">;
+/** @package */
+export declare function createTerminalActions(daemonClient: TerminalClient, resolveWorkspaceDirectory: (workspaceId: string) => Promise<string>): PaseoTerminalActions;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/terminals/index.js

@@ -0,0 +1,103 @@
+import { z } from "zod";
+const TerminalSchema = z.object({
+    id: z.string(),
+    workspaceId: z.string(),
+    cwd: z.string(),
+    name: z.string(),
+});
+/** @package */
+export function createTerminalActions(daemonClient, resolveWorkspaceDirectory) {
+    function client() {
+        daemonClient.ensureConnected();
+        // COMPAT(workspaceTerminals): added in v0.7.3, remove gate after 2027-09-05.
+        if (daemonClient.getLastServerInfoMessage()?.features?.workspaceTerminals !== true) {
+            throw new Error("Update the host to use workspace terminals through the SDK.");
+        }
+        return daemonClient;
+    }
+    const list = async (options = {}) => {
+        const result = await client().listTerminals(options.cwd, options.requestId, {
+            workspaceId: options.workspaceId,
+        });
+        return {
+            entries: result.terminals.map((terminal) => TerminalSchema.parse(terminal)),
+            requestId: result.requestId,
+        };
+    };
+    const ref = (terminal) => {
+        const id = typeof terminal === "string" ? terminal : terminal.id;
+        let current = typeof terminal === "string" ? null : terminal;
+        const write = (data) => {
+            client().sendTerminalInput(id, { type: "input", data });
+            return data.length;
+        };
+        return {
+            id,
+            current: () => current,
+            refresh: async (options) => {
+                const result = await list(options);
+                current = result.entries.find((entry) => entry.id === id) ?? null;
+                return current;
+            },
+            write,
+            sendKeys: (keys) => write(keys.map(resolveKeyToken).join("")),
+            capture: (options = {}) => {
+                const { requestId, ...captureOptions } = options;
+                return client().captureTerminal(id, captureOptions, requestId);
+            },
+            kill: async (requestId) => {
+                const result = await client().killTerminal(id, requestId);
+                if (!result.success)
+                    throw new Error(`Failed to kill terminal ${id}`);
+                current = null;
+            },
+        };
+    };
+    return {
+        create: async ({ workspaceId, cwd, name, requestId, ...options }) => {
+            const driver = client();
+            if (!workspaceId)
+                throw new Error("workspaceId is required");
+            const directory = cwd ?? (await resolveWorkspaceDirectory(workspaceId));
+            const result = await driver.createTerminal(directory, name, requestId, {
+                ...options,
+                workspaceId,
+            });
+            if (result.error || !result.terminal) {
+                throw new Error(result.error ?? "The daemon did not create a terminal");
+            }
+            return ref(TerminalSchema.parse(result.terminal));
+        },
+        list,
+        ref,
+    };
+}
+function resolveKeyToken(key) {
+    switch (key) {
+        case "Enter":
+            return "\r";
+        case "Tab":
+            return "\t";
+        case "Escape":
+            return "\u001b";
+        case "Space":
+            return " ";
+        case "BSpace":
+            return "\u007f";
+        case "C-c":
+            return "\u0003";
+        case "C-d":
+            return "\u0004";
+        case "C-z":
+            return "\u001a";
+        case "C-l":
+            return "\u000c";
+        case "C-a":
+            return "\u0001";
+        case "C-e":
+            return "\u0005";
+        default:
+            return key;
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/timeline-subscription/index.d.ts

@@ -0,0 +1,25 @@
+import type { SessionOutboundMessage } from "@hyperdrive.bot/fleet-protocol/messages";
+import type { OwnedSubscription, TimelineSubscription } from "../connection/index.js";
+type TimelineUpdate = Extract<SessionOutboundMessage, {
+    type: "agent_stream" | "agent.timeline.replacement";
+}>;
+/** Local SDK lifecycle messages; these are not additional wire RPCs. */
+export type TimelineMessage = TimelineUpdate | {
+    type: "agent.timeline.subscription_restored";
+    payload: {
+        agentId: string;
+        subscriptionId: string;
+    };
+} | {
+    type: "agent.timeline.error";
+    payload: {
+        agentId: string;
+        error: string;
+    };
+};
+/** Restores live delivery; the consumer owns history reads and gap recovery. */
+export declare function subscribeTimeline(agentId: string, observation: OwnedSubscription<{
+    agentIds: string[];
+}>, handler: (message: TimelineMessage) => void, reportError: (error: unknown) => void): TimelineSubscription;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/timeline-subscription/index.js

@@ -0,0 +1,56 @@
+/** Restores live delivery; the consumer owns history reads and gap recovery. */
+export function subscribeTimeline(agentId, observation, handler, reportError) {
+    let established = false;
+    let released = false;
+    const notify = (message) => {
+        if (released)
+            return;
+        try {
+            handler(message);
+        }
+        catch (error) {
+            reportError(error);
+        }
+    };
+    const release = () => {
+        released = true;
+        return observation.release();
+    };
+    const stop = () => {
+        // Use the public release entry point so the owning API also forgets this handle.
+        void subscription.release().catch(reportError);
+    };
+    const fail = (error) => {
+        notify({
+            type: "agent.timeline.error",
+            payload: { agentId, error: error instanceof Error ? error.message : String(error) },
+        });
+        stop();
+    };
+    observation.subscribe({
+        snapshot: ({ subscriptionId }) => {
+            if (!established) {
+                established = true;
+                return;
+            }
+            notify({
+                type: "agent.timeline.subscription_restored",
+                payload: { agentId, subscriptionId },
+            });
+        },
+        update: (message) => {
+            if (message.type === "agent_stream" || message.type === "agent.timeline.replacement")
+                notify(message);
+        },
+        error: fail,
+    });
+    const subscription = Object.assign(stop, {
+        ready: observation.ready.then(() => undefined),
+        release,
+        subscriptionId: null,
+    });
+    Object.defineProperty(subscription, "subscriptionId", { get: () => observation.subscriptionId });
+    void subscription.ready.catch(fail);
+    return subscription;
+}
+//# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperdrive.bot/fleet-client",
-  "version": "0.3.218",
+  "version": "0.3.221",
   "description": "Paseo client SDK package",
   "license": "Apache-2.0",
   "files": [
@@ -21,21 +21,25 @@
     "./internal/daemon-client-transport-types": {
       "types": "./dist/daemon-client-transport-types.d.ts",
       "default": "./dist/daemon-client-transport-types.js"
+    },
+    "./internal/daemon-client-websocket-transport": {
+      "types": "./dist/daemon-client-websocket-transport.d.ts",
+      "default": "./dist/daemon-client-websocket-transport.js"
     }
   },
   "scripts": {
     "clean": "node ../../scripts/clean-package-dist.mjs",
-    "build": "npm run build --workspace=@hyperdrive.bot/fleet-protocol && tsc -p tsconfig.json --incremental false",
+    "build": "npm run build --workspace=@hyperdrive.bot/fleet-protocol && npm run build --workspace=@hyperdrive.bot/fleet-relay && tsc -p tsconfig.json --incremental false",
     "build:clean": "npm run clean && npm run build",
     "prepack": "npm run build:clean",
-    "postpack": "node ../../scripts/personal-data-scan.mjs --npm-package .",
     "typecheck": "tsgo --noEmit",
     "typecheck:examples": "tsgo -p tsconfig.examples.json --noEmit",
-    "test": "vitest run"
+    "test": "vitest run",
+    "postpack": "node ../../scripts/personal-data-scan.mjs --npm-package ."
   },
   "dependencies": {
-    "@hyperdrive.bot/fleet-protocol": "0.3.218",
-    "@hyperdrive.bot/fleet-relay": "0.3.218",
+    "@hyperdrive.bot/fleet-protocol": "0.3.221",
+    "@hyperdrive.bot/fleet-relay": "0.3.221",
     "zod": "^4.4.3"
   },
   "devDependencies": {