@hyperdrive.bot/fleet-client 0.3.218 → 0.3.221

package/dist/connection/legacy.js

@@ -0,0 +1,245 @@
+import { SessionInboundMessageSchema } from "@hyperdrive.bot/fleet-protocol/messages";
+import { LegacyWorkspaces } from "./legacy-workspaces.js";
+import { BrowserAutomationHostCapabilitySchema } from "@hyperdrive.bot/fleet-protocol/browser-automation/capabilities";
+// COMPAT(ownedSubscriptions): added in v0.8.0; remove after 2027-03-11 once daemon floor >= v0.8.0.
+// Legacy directories retain their connection-wide, last-query-wins semantics.
+// IDs below identify local listeners, not independent server subscriptions.
+export class LegacySubscriptions {
+    constructor(info, send, browserHost) {
+        this.info = info;
+        this.send = send;
+        this.browserHost = browserHost;
+        this.interests = new Map();
+        this.workspaces = info.features?.workspaceMultiplicity === true ? null : new LegacyWorkspaces();
+    }
+    normalize(message) {
+        return this.workspaces?.normalize(message) ?? message;
+    }
+    prepareRequest(message) {
+        const identity = {
+            message,
+            receive: (value) => value,
+            finish: async () => { },
+        };
+        const workspaces = this.workspaces;
+        if (workspaces && message.type === "fetch_workspaces_request") {
+            return {
+                ...identity,
+                message: SessionInboundMessageSchema.parse({
+                    type: "fetch_agents_request",
+                    requestId: message.requestId,
+                    scope: "active",
+                    sort: [{ key: "updated_at", direction: "desc" }],
+                    page: message.page,
+                    subscribe: message.subscribe,
+                }),
+                receive: (value) => {
+                    if (value.type !== "fetch_agents_response")
+                        return value;
+                    if (value.payload.requestId !== message.requestId)
+                        return value;
+                    return {
+                        type: "fetch_workspaces_response",
+                        payload: {
+                            ...value.payload,
+                            entries: workspaces.read(value.payload.entries, !message.page?.cursor),
+                            emptyProjects: [],
+                        },
+                    };
+                },
+            };
+        }
+        if (message.type === "subscribe_terminals_request") {
+            return {
+                ...identity,
+                receive: (value) => {
+                    if (value.type !== "terminals_changed" || value.payload.cwd !== message.cwd)
+                        return value;
+                    return { ...value, payload: { ...value.payload, requestId: message.requestId } };
+                },
+            };
+        }
+        if (message.type === "workspace.label.list.request" && !message.subscribe) {
+            return {
+                ...identity,
+                message: { ...message, subscribe: { subscriptionId: `legacy:${crypto.randomUUID()}` } },
+            };
+        }
+        if (message.type === "checkout.diff.get.request") {
+            const subscriptionId = `legacy:${crypto.randomUUID()}`;
+            return {
+                message: SessionInboundMessageSchema.parse({
+                    ...message,
+                    type: "subscribe_checkout_diff_request",
+                    subscriptionId,
+                }),
+                receive: (value) => {
+                    if (value.type !== "subscribe_checkout_diff_response")
+                        return value;
+                    if (value.payload.requestId !== message.requestId)
+                        return value;
+                    return { ...value, type: "checkout.diff.get.response" };
+                },
+                finish: () => this.send({ type: "unsubscribe_checkout_diff_request", subscriptionId }),
+            };
+        }
+        return identity;
+    }
+    start(query) {
+        const interest = { id: `legacy:${crypto.randomUUID()}`, query };
+        this.interests.set(interest.id, interest);
+        return interest;
+    }
+    request({ id, query }) {
+        switch (query.type) {
+            case "fetch_agents_request":
+            case "fetch_workspaces_request":
+            case "workspace.label.list.request":
+                return { ...query, subscribe: { subscriptionId: id } };
+            case "fs.file.subscribe.request":
+            case "subscribe_checkout_diff_request":
+                return { ...query, subscriptionId: id };
+            case "agent.timeline.set_subscription.request":
+                if (!this.info.features?.selectiveAgentTimeline)
+                    return null;
+                return { ...query, agentIds: this.members(query.type, "agentIds") };
+            case "session.events.set_subscription.request":
+                if (!this.info.features?.explicitEventSubscriptions)
+                    return null;
+                return {
+                    ...query,
+                    events: this.members(query.type, "events").filter(isLegacyEvent),
+                };
+            case "browser.host.register.request":
+                if (!matchesBrowserRegistration(this.browserHost, query)) {
+                    throw new Error("This daemon requires browser_host registration in the client's hello capabilities");
+                }
+                return null; // Older hosts register in hello.
+            default:
+                return query;
+        }
+    }
+    members(type, field) {
+        const members = new Set();
+        for (const interest of this.interests.values()) {
+            if (interest.query.type !== type)
+                continue;
+            for (const value of interest.query[field])
+                members.add(value);
+        }
+        return [...members].sort();
+    }
+    release(id) {
+        const interest = this.interests.get(id);
+        if (!interest)
+            return null;
+        this.interests.delete(id);
+        const { query } = interest;
+        switch (query.type) {
+            case "agent.timeline.set_subscription.request":
+            case "session.events.set_subscription.request":
+                return this.request(interest);
+            case "fs.file.subscribe.request":
+                return { type: "fs.file.unsubscribe.request", subscriptionId: id };
+            case "subscribe_checkout_diff_request":
+                return { type: "unsubscribe_checkout_diff_request", subscriptionId: id };
+            case "subscribe_terminal_request":
+                if ([...this.interests.values()].some((item) => item.query.type === query.type && item.query.terminalId === query.terminalId))
+                    return null;
+                return { type: "unsubscribe_terminal_request", terminalId: query.terminalId };
+            case "subscribe_terminals_request":
+                if ([...this.interests.values()].some((item) => item.query.type === query.type &&
+                    item.query.cwd === query.cwd &&
+                    item.query.workspaceId === query.workspaceId))
+                    return null;
+                return {
+                    type: "unsubscribe_terminals_request",
+                    cwd: query.cwd,
+                    workspaceId: query.workspaceId,
+                };
+            default:
+                // Directory slots have no release RPC. Detach the local listener.
+                return null;
+        }
+    }
+    owns(message) {
+        return [...this.interests.values()].some((interest) => this.matches(interest, message));
+    }
+    receive(message, deliver) {
+        const updates = [
+            message,
+            ...(this.workspaces?.update(message) ?? []),
+        ];
+        if (message.type === "agent_stream" && message.payload.event.type === "attention_required") {
+            const { agentId, event } = message.payload;
+            updates.push({
+                type: "agent_attention_required",
+                payload: {
+                    agentId,
+                    reason: event.reason,
+                    timestamp: event.timestamp,
+                    shouldNotify: event.shouldNotify,
+                    ...(event.notification ? { notification: event.notification } : {}),
+                },
+            });
+        }
+        for (const update of updates)
+            for (const interest of this.interests.values()) {
+                if (!this.matches(interest, update))
+                    continue;
+                // Normalize at the connection edge; all consumers receive the same handle shape.
+                deliver(("payload" in update
+                    ? { ...update, payload: { ...update.payload, subscriptionId: interest.id } }
+                    : { ...update, subscriptionId: interest.id }));
+            }
+    }
+    matches({ id, query }, message) {
+        switch (query.type) {
+            case "fetch_agents_request":
+                return message.type === "agent_update";
+            case "fetch_workspaces_request":
+                return message.type === "workspace_update";
+            case "workspace.label.list.request":
+                return message.type === "workspace.label.update";
+            case "fs.file.subscribe.request":
+                return message.type === "fs.file.update" && message.payload.subscriptionId === id;
+            case "subscribe_checkout_diff_request":
+                return message.type === "checkout_diff_update" && message.payload.subscriptionId === id;
+            case "subscribe_terminals_request":
+                return message.type === "terminals_changed" && message.payload.cwd === query.cwd;
+            case "subscribe_terminal_request":
+                return (message.type === "terminal_stream_exit" && message.payload.terminalId === query.terminalId);
+            case "agent.timeline.set_subscription.request":
+                return ((message.type === "agent_stream" || message.type === "agent.timeline.replacement") &&
+                    query.agentIds.includes(message.payload.agentId));
+            case "session.events.set_subscription.request":
+                return query.events.includes(message.type === "status" ? `status.${message.payload.status}` : message.type);
+            case "browser.host.register.request":
+                return message.type === "browser.automation.execute.request";
+            default:
+                return false;
+        }
+    }
+}
+function isLegacyEvent(event) {
+    return [
+        "project.update",
+        "providers_snapshot_update",
+        "agent_attention_required",
+        "agent_permission_request",
+        "agent_permission_resolved",
+    ].includes(event);
+}
+function matchesBrowserRegistration(advertised, request) {
+    const host = BrowserAutomationHostCapabilitySchema.safeParse(advertised);
+    if (!host.success)
+        return false;
+    if (host.data.hostKind !== request.hostKind)
+        return false;
+    for (const command of request.supportedCommands) {
+        if (!host.data.supportedCommands.some((supported) => supported === command))
+            return false;
+    }
+    return true;
+}
+//# sourceMappingURL=legacy.js.map

package/dist/connection/owned.d.ts

@@ -0,0 +1,36 @@
+import type { SessionOutboundMessage } from "@hyperdrive.bot/fleet-protocol/messages";
+export type SubscriptionSnapshot<T> = T & {
+    subscriptionId: string;
+};
+export interface SubscriptionObserver<T> {
+    snapshot(snapshot: T): void;
+    update(message: SessionOutboundMessage): void;
+    error?(error: unknown): void;
+}
+/** A stable local lifetime. IDs change on reconnect; legacy IDs identify local listeners only. */
+export interface OwnedSubscription<T> {
+    readonly subscriptionId: string | null;
+    readonly ready: Promise<SubscriptionSnapshot<T>>;
+    subscribe(observer: SubscriptionObserver<SubscriptionSnapshot<T>>): () => void;
+    release(): Promise<void>;
+}
+export interface OwnedSubscriptionsHost {
+    release(subscriptionId: string): Promise<void>;
+    failed(error: unknown): void;
+}
+/** Transport routing and lifetime only; query semantics remain with each domain. */
+export declare class OwnedSubscriptions {
+    private readonly host;
+    private readonly registrations;
+    private readonly routes;
+    private generation;
+    private connected;
+    constructor(host: OwnedSubscriptionsHost);
+    observe<T>(request: (accept: (snapshot: T) => void) => Promise<T>, signal?: AbortSignal, requestFailed?: () => void): OwnedSubscription<T>;
+    owns(message: SessionOutboundMessage): boolean;
+    receive(message: SessionOutboundMessage): void;
+    restore(): void;
+    disconnected(): void;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=owned.d.ts.map

package/dist/connection/owned.js

@@ -0,0 +1,210 @@
+const MAX_BOOTSTRAP_UPDATES = 128;
+/** Transport routing and lifetime only; query semantics remain with each domain. */
+export class OwnedSubscriptions {
+    constructor(host) {
+        this.host = host;
+        this.registrations = new Set();
+        this.routes = new Map();
+        this.generation = 0;
+        this.connected = false;
+    }
+    observe(request, signal, requestFailed) {
+        let id = null;
+        let snapshot;
+        let pending = null;
+        let teardown = null;
+        let disposed = false;
+        let overflow = false;
+        const buffered = [];
+        const observers = new Set();
+        let resolve;
+        let reject;
+        const ready = new Promise((accept, fail) => {
+            resolve = accept;
+            reject = fail;
+        });
+        void ready.catch(() => { });
+        const deliver = (observer, message) => {
+            try {
+                if (message)
+                    observer.update(message);
+                else if (snapshot)
+                    observer.snapshot(snapshot);
+            }
+            catch (error) {
+                this.host.failed(error);
+            }
+        };
+        const releaseId = async () => {
+            const released = id;
+            id = null;
+            if (!released)
+                return;
+            this.routes.delete(released);
+            await this.host.release(released);
+        };
+        const registration = {
+            start: () => {
+                if (disposed || pending || id || !this.connected)
+                    return;
+                const generation = this.generation;
+                pending = request((value) => {
+                    if (generation !== this.generation)
+                        return;
+                    assertSubscriptionSnapshot(value);
+                    id = value.subscriptionId;
+                    snapshot = value;
+                    buffered.length = 0;
+                    overflow = false;
+                    if (disposed)
+                        return;
+                    this.routes.set(id, registration);
+                    for (const observer of observers)
+                        deliver(observer);
+                })
+                    .then(() => {
+                    if (generation === this.generation && !disposed) {
+                        if (!snapshot)
+                            throw new Error("The host omitted its subscription snapshot");
+                        resolve(snapshot);
+                    }
+                    return undefined;
+                })
+                    .catch((error) => {
+                    if (generation !== this.generation)
+                        return;
+                    reject(error);
+                    for (const observer of observers) {
+                        try {
+                            observer.error?.(error);
+                        }
+                        catch (failure) {
+                            this.host.failed(failure);
+                        }
+                    }
+                    void handle.release().catch(this.host.failed);
+                    this.host.failed(error);
+                    requestFailed?.();
+                    return undefined;
+                })
+                    .finally(() => {
+                    pending = null;
+                    if (generation !== this.generation && !disposed)
+                        registration.start();
+                });
+            },
+            disconnected: () => {
+                id = null;
+                snapshot = undefined;
+                buffered.length = 0;
+                overflow = false;
+            },
+            receive: (message) => {
+                if (disposed || ("payload" in message && Object.is(message.payload, snapshot)))
+                    return;
+                if (buffered.length < MAX_BOOTSTRAP_UPDATES && !overflow)
+                    buffered.push(message);
+                else {
+                    buffered.length = 0;
+                    overflow = true;
+                }
+                for (const observer of observers)
+                    deliver(observer, message);
+            },
+            release: () => {
+                if (teardown)
+                    return teardown;
+                disposed = true;
+                signal?.removeEventListener("abort", abort);
+                observers.clear();
+                buffered.length = 0;
+                if (id)
+                    this.routes.delete(id);
+                reject(new Error("Subscription released"));
+                teardown = (async () => {
+                    await pending;
+                    await releaseId();
+                    this.registrations.delete(registration);
+                })();
+                return teardown;
+            },
+        };
+        const abort = () => {
+            void handle.release().catch(this.host.failed);
+        };
+        const handle = {
+            get subscriptionId() {
+                return id;
+            },
+            ready,
+            release: registration.release,
+            subscribe: (observer) => {
+                if (disposed)
+                    throw new Error("Subscription released");
+                observers.add(observer);
+                if (overflow) {
+                    overflow = false;
+                    snapshot = undefined;
+                    void releaseId()
+                        .then(() => {
+                        registration.start();
+                        return undefined;
+                    })
+                        .catch(this.host.failed);
+                }
+                else {
+                    deliver(observer);
+                    for (const message of buffered)
+                        deliver(observer, message);
+                }
+                return () => {
+                    observers.delete(observer);
+                };
+            },
+        };
+        this.registrations.add(registration);
+        if (signal?.aborted)
+            abort();
+        else {
+            signal?.addEventListener("abort", abort, { once: true });
+            registration.start();
+        }
+        return handle;
+    }
+    owns(message) {
+        const payload = "payload" in message ? message.payload : message;
+        return ("subscriptionId" in payload &&
+            typeof payload.subscriptionId === "string" &&
+            this.routes.has(payload.subscriptionId));
+    }
+    receive(message) {
+        const payload = "payload" in message ? message.payload : message;
+        if ("subscriptionId" in payload && typeof payload.subscriptionId === "string")
+            this.routes.get(payload.subscriptionId)?.receive(message);
+    }
+    restore() {
+        this.connected = true;
+        for (const registration of this.registrations)
+            registration.start();
+    }
+    disconnected() {
+        this.connected = false;
+        this.generation++;
+        this.routes.clear();
+        for (const registration of this.registrations)
+            registration.disconnected();
+    }
+    async close() {
+        await Promise.all([...this.registrations].map((registration) => registration.release()));
+    }
+}
+function assertSubscriptionSnapshot(value) {
+    if (value &&
+        typeof value === "object" &&
+        "subscriptionId" in value &&
+        typeof value.subscriptionId === "string" &&
+        value.subscriptionId)
+        return;
+    throw new Error("The host omitted its subscription ID");
+}
+//# sourceMappingURL=owned.js.map

package/dist/creation/index.d.ts

@@ -0,0 +1,40 @@
+import type { AgentSnapshotPayload, CreationSnapshot, WorkspaceCreateResponse } from "@hyperdrive.bot/fleet-protocol/messages";
+import type { CreateAgentRequestOptions, CreateWorkspaceRequestOptions } from "../daemon-client.js";
+type Kind = CreationSnapshot["kind"];
+export interface CreationResult {
+    agent?: AgentSnapshotPayload | null;
+    workspace?: WorkspaceCreateResponse["payload"]["workspace"];
+    creation?: CreationSnapshot;
+    error: string | null;
+    errorCode?: string;
+    setupTerminalId?: string | null;
+    setupSkippedReason?: string;
+    requestId?: string;
+}
+interface Dependencies {
+    supports: (feature: "creationLifecycle" | "agentRequestReceipts") => boolean;
+    requestId: () => string;
+    request: (kind: Kind, input: Record<string, unknown>) => Promise<CreationResult>;
+    observe: (kind: Kind, key: string, next: (snapshot: CreationSnapshot | null) => void, error: (error: unknown) => void) => () => void;
+    legacyAgent: (input: CreateAgentRequestOptions) => Promise<AgentSnapshotPayload>;
+    legacyWorkspace: (input: CreateWorkspaceRequestOptions) => Promise<WorkspaceCreateResponse["payload"]>;
+}
+/** Client-owned observation and compatibility. UI callbacks never advance creation. */
+export declare class CreationClient {
+    private readonly deps;
+    private readonly operations;
+    constructor(deps: Dependencies);
+    createAgent(input: CreateAgentRequestOptions): Promise<CreationResult>;
+    createWorkspace(input: CreateWorkspaceRequestOptions): Promise<CreationResult>;
+    private legacyAgent;
+    private start;
+    private submit;
+    receive(snapshot: CreationSnapshot): void;
+    reconnect(): void;
+    close(): void;
+    private finish;
+    private fail;
+    private notify;
+}
+export {};
+//# sourceMappingURL=index.d.ts.map