@hyperdrive.bot/fleet-client 0.3.218 → 0.3.221

package/dist/creation/index.js

@@ -0,0 +1,197 @@
+/** Client-owned observation and compatibility. UI callbacks never advance creation. */
+export class CreationClient {
+    constructor(deps) {
+        this.deps = deps;
+        this.operations = new Map();
+    }
+    createAgent(input) {
+        const { onEvent, ...request } = input;
+        return this.start("agent", request, onEvent, () => this.legacyAgent(request));
+    }
+    createWorkspace(input) {
+        const { onEvent, ...request } = input;
+        return this.start("workspace", request, onEvent, async (operation) => {
+            if (request.workspaceId || request.agent?.agentId)
+                throw new Error("Update the host to use caller-selected creation IDs.");
+            const { agent, ...workspaceInput } = request;
+            const sourceCwd = request.source.kind === "directory" ? request.source.path : request.source.cwd;
+            const relativeCwd = agent && sourceCwd ? relativeDirectory(agent.config.cwd, sourceCwd) : undefined;
+            const workspace = await this.deps.legacyWorkspace(workspaceInput);
+            if (workspace.error || !workspace.workspace)
+                return workspace;
+            this.receive({
+                kind: "workspace",
+                idempotencyKey: operation.key,
+                revision: 1,
+                phase: "workspace_ready",
+                workspaceId: workspace.workspace.id,
+                agentId: null,
+                workspace: workspace.workspace,
+                setupSkippedReason: workspace.setupSkippedReason,
+                error: null,
+            });
+            if (!agent)
+                return workspace;
+            const cwd = `${workspace.workspace.workspaceDirectory.replace(/[\\/]+$/, "")}${relativeCwd ?? relativeDirectory(agent.config.cwd, workspace.workspace.projectRootPath)}`;
+            const created = await this.legacyAgent({
+                ...agent,
+                config: { ...agent.config, cwd },
+                workspaceId: workspace.workspace.id,
+                idempotencyKey: `${operation.key}:agent`,
+            });
+            return { ...workspace, agent: created.agent };
+        });
+    }
+    async legacyAgent(input) {
+        if (input.agentId)
+            throw new Error("Update the host to use caller-selected creation IDs.");
+        const { idempotencyKey: _key, ...unkeyed } = input;
+        const hasPrompt = Boolean(input.initialPrompt || input.images?.length || input.attachments?.length);
+        // COMPAT(creationLifecycle): added in v0.8.0, remove after 2027-03-11 once the daemon floor supports creationLifecycle.
+        // Preserve the original create-and-prompt RPC: old hosts use its prompt for
+        // titles, creation context and startup. Their keyed create cannot accept it.
+        const request = !hasPrompt && this.deps.supports("agentRequestReceipts") ? input : unkeyed;
+        return { agent: await this.deps.legacyAgent(request), error: null };
+    }
+    start(kind, input, observer, legacy) {
+        const key = typeof input.idempotencyKey === "string" ? input.idempotencyKey : this.deps.requestId();
+        const identity = JSON.stringify([kind, key]);
+        const { requestId: _requestId, ...intent } = input;
+        const fingerprint = JSON.stringify(intent, (_key, value) => value && typeof value === "object" && !Array.isArray(value)
+            ? Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)))
+            : value);
+        const previous = this.operations.get(identity);
+        if (previous) {
+            if (previous.fingerprint !== fingerprint)
+                return Promise.reject(new Error(`${kind}_request_key_conflict`));
+            if (observer) {
+                previous.observers.add(observer);
+                if (previous.snapshot)
+                    this.notify(observer, previous.snapshot);
+            }
+            return previous.result;
+        }
+        let resolve;
+        let reject;
+        const result = new Promise((done, fail) => {
+            resolve = done;
+            reject = fail;
+        });
+        const operation = {
+            kind,
+            key,
+            input: { ...input, idempotencyKey: key },
+            fingerprint,
+            observers: new Set(observer ? [observer] : []),
+            result,
+            resolve,
+            reject,
+            settled: false,
+            modern: this.deps.supports("creationLifecycle"),
+            recovering: false,
+        };
+        this.operations.set(identity, operation);
+        if (operation.modern)
+            void this.submit(operation);
+        else
+            void legacy(operation).then((value) => this.finish(operation, value), (error) => this.fail(operation, error));
+        return result;
+    }
+    async submit(operation) {
+        try {
+            const result = await this.deps.request(operation.kind, {
+                ...operation.input,
+                subscribe: true,
+            });
+            if (result.creation)
+                this.receive(result.creation);
+            this.finish(operation, result);
+        }
+        catch (error) {
+            if (operation.settled ||
+                (error instanceof Error && "code" in error && error.code === "DAEMON_CONNECTION_LOST"))
+                return;
+            this.fail(operation, error);
+        }
+    }
+    receive(snapshot) {
+        const operation = this.operations.get(JSON.stringify([snapshot.kind, snapshot.idempotencyKey]));
+        if (!operation || (operation.snapshot && operation.snapshot.revision > snapshot.revision))
+            return;
+        if (operation.snapshot?.revision !== snapshot.revision) {
+            operation.snapshot = snapshot;
+            for (const observer of operation.observers)
+                this.notify(observer, snapshot);
+        }
+        if (operation.recovering && (snapshot.phase === "completed" || snapshot.phase === "failed")) {
+            this.finish(operation, {
+                agent: snapshot.agent,
+                workspace: snapshot.workspace,
+                creation: snapshot,
+                setupSkippedReason: snapshot.setupSkippedReason,
+                error: snapshot.error,
+                errorCode: snapshot.errorCode,
+            });
+        }
+    }
+    reconnect() {
+        for (const operation of this.operations.values()) {
+            if (operation.settled || !operation.modern || operation.recovering)
+                continue;
+            operation.recovering = true;
+            operation.stopObserving = this.deps.observe(operation.kind, operation.key, (snapshot) => {
+                if (!snapshot)
+                    void this.submit(operation);
+                else {
+                    // Re-subscription is authoritative even if its revision matches the last live event.
+                    this.receive(snapshot);
+                }
+            }, (error) => this.fail(operation, error));
+        }
+    }
+    close() {
+        for (const operation of this.operations.values())
+            if (!operation.settled)
+                this.fail(operation, new Error("Daemon client closed"));
+        this.operations.clear();
+    }
+    finish(operation, result) {
+        if (operation.settled)
+            return;
+        operation.settled = true;
+        operation.stopObserving?.();
+        operation.resolve(result);
+        operation.observers.clear();
+        this.operations.delete(JSON.stringify([operation.kind, operation.key]));
+    }
+    fail(operation, error) {
+        if (operation.settled)
+            return;
+        operation.settled = true;
+        operation.stopObserving?.();
+        operation.reject(error instanceof Error ? error : new Error(String(error)));
+        operation.observers.clear();
+        this.operations.delete(JSON.stringify([operation.kind, operation.key]));
+    }
+    notify(observer, snapshot) {
+        try {
+            observer(snapshot);
+        }
+        catch {
+            /* Observation does not control execution. */
+        }
+    }
+}
+function relativeDirectory(cwd, source) {
+    const normalize = (value) => value.replace(/\\/g, "/").replace(/\/+$/, "");
+    const normalized = normalize(cwd), root = normalize(source);
+    // Parent traversal must never survive mapping into the newly created checkout.
+    if ([normalized, root].some((path) => path.split("/").includes("..")))
+        throw new Error("Agent directory must be inside the workspace source");
+    if (normalized === root)
+        return "";
+    if (!normalized.startsWith(`${root}/`))
+        throw new Error("Agent directory must be inside the workspace source");
+    return normalized.slice(root.length);
+}
+//# sourceMappingURL=index.js.map

package/dist/daemon-client-relay-e2ee-transport.d.ts

@@ -4,5 +4,6 @@ export declare function createRelayE2eeTransportFactory(args: {
     daemonPublicKeyB64: string;
     logger: TransportLogger;
 }): DaemonTransportFactory;
+export declare function createRelayTransportFactory(baseFactory: DaemonTransportFactory): DaemonTransportFactory;
 export declare function createEncryptedTransport(base: DaemonTransport, daemonPublicKeyB64: string, logger: TransportLogger): DaemonTransport;
 //# sourceMappingURL=daemon-client-relay-e2ee-transport.d.ts.map

package/dist/daemon-client-relay-e2ee-transport.js

@@ -1,11 +1,15 @@
 import { createClientChannel, } from "@hyperdrive.bot/fleet-relay/e2ee";
-import { extractRelayMessageData, normalizeTransportPayload, } from "./daemon-client-transport-utils.js";
+import { extractRelayMessage, normalizeTransportPayload } from "./daemon-client-transport-utils.js";
 export function createRelayE2eeTransportFactory(args) {
-    return ({ url, headers }) => {
-        const base = args.baseFactory({ url, headers });
+    return ({ url }) => {
+        const base = args.baseFactory({ url });
         return createEncryptedTransport(base, args.daemonPublicKeyB64, args.logger);
     };
 }
+export function createRelayTransportFactory(baseFactory) {
+    // The relay upgrade precedes E2EE. Only the encrypted hello may carry daemon credentials.
+    return ({ url }) => baseFactory({ url });
+}
 export function createEncryptedTransport(base, daemonPublicKeyB64, logger) {
     let channel = null;
     let opened = false;
@@ -38,7 +42,7 @@ export function createEncryptedTransport(base, daemonPublicKeyB64, logger) {
         if (closed) {
             return;
         }
-        emitHandlers(messageHandlers, data);
+        emitHandlers(messageHandlers, data, data instanceof ArrayBuffer);
     };
     const relayTransport = {
         send: (data) => {
@@ -81,8 +85,8 @@ export function createEncryptedTransport(base, daemonPublicKeyB64, logger) {
     base.onOpen(() => {
         void startHandshake();
     });
-    base.onMessage((event) => {
-        relayTransport.onmessage?.(extractRelayMessageData(event));
+    base.onMessage((data, isBinary) => {
+        relayTransport.onmessage?.(extractRelayMessage(data, isBinary));
     });
     base.onClose((event) => {
         const record = event;

package/dist/daemon-client-transport-types.d.ts

@@ -1,7 +1,7 @@
 export interface DaemonTransport {
     send: (data: string | Uint8Array | ArrayBuffer) => void;
     close: (code?: number, reason?: string) => void;
-    onMessage: (handler: (data: unknown) => void) => () => void;
+    onMessage: (handler: (data: unknown, isBinary: boolean) => void) => () => void;
     onOpen: (handler: () => void) => () => void;
     onClose: (handler: (event?: unknown) => void) => () => void;
     onError: (handler: (event?: unknown) => void) => () => void;

package/dist/daemon-client-transport-utils.d.ts

@@ -1,6 +1,10 @@
 export declare function copyArrayBufferViewToBuffer(data: ArrayBufferView): ArrayBuffer;
 export declare function normalizeTransportPayload(data: string | Uint8Array | ArrayBuffer): string | ArrayBuffer;
-export declare function extractRelayMessageData(event: unknown): string | ArrayBuffer;
+export interface RelayTransportMessage {
+    data: string | ArrayBuffer;
+    isBinary: boolean;
+}
+export declare function extractRelayMessage(event: unknown, nodeIsBinary?: boolean): RelayTransportMessage;
 export declare function describeTransportClose(event?: unknown): string;
 export declare function describeTransportError(event?: unknown): string;
 export declare function safeRandomId(): string;

package/dist/daemon-client-transport-utils.js

@@ -10,18 +10,20 @@ export function normalizeTransportPayload(data) {
     }
     return copyArrayBufferViewToBuffer(data);
 }
-export function extractRelayMessageData(event) {
+export function extractRelayMessage(event, nodeIsBinary) {
     const raw = event && typeof event === "object" && "data" in event
         ? event.data
         : event;
-    if (typeof raw === "string")
-        return raw;
+    const isBinary = nodeIsBinary ?? typeof raw !== "string";
+    if (!isBinary) {
+        return { data: decodeMessageData(raw) ?? String(raw ?? ""), isBinary: false };
+    }
     if (raw instanceof ArrayBuffer)
-        return raw;
+        return { data: raw, isBinary: true };
     if (ArrayBuffer.isView(raw)) {
-        return copyArrayBufferViewToBuffer(raw);
+        return { data: copyArrayBufferViewToBuffer(raw), isBinary: true };
     }
-    return String(raw ?? "");
+    return { data: String(raw ?? ""), isBinary: true };
 }
 export function describeTransportClose(event) {
     if (!event) {

package/dist/daemon-client-transport.d.ts

@@ -1,5 +1,5 @@
 export type { DaemonTransport, DaemonTransportFactory, TransportLogger, WebSocketFactory, WebSocketLike, } from "./daemon-client-transport-types.js";
-export { decodeMessageData, describeTransportClose, describeTransportError, encodeUtf8String, extractRelayMessageData, normalizeTransportPayload, safeRandomId, } from "./daemon-client-transport-utils.js";
-export { createEncryptedTransport, createRelayE2eeTransportFactory, } from "./daemon-client-relay-e2ee-transport.js";
+export { decodeMessageData, describeTransportClose, describeTransportError, encodeUtf8String, extractRelayMessage, normalizeTransportPayload, safeRandomId, } from "./daemon-client-transport-utils.js";
+export { createEncryptedTransport, createRelayE2eeTransportFactory, createRelayTransportFactory, } from "./daemon-client-relay-e2ee-transport.js";
 export { bindWsHandler, createWebSocketTransportFactory, defaultWebSocketFactory, } from "./daemon-client-websocket-transport.js";
 //# sourceMappingURL=daemon-client-transport.d.ts.map

package/dist/daemon-client-transport.js

@@ -1,4 +1,4 @@
-export { decodeMessageData, describeTransportClose, describeTransportError, encodeUtf8String, extractRelayMessageData, normalizeTransportPayload, safeRandomId, } from "./daemon-client-transport-utils.js";
-export { createEncryptedTransport, createRelayE2eeTransportFactory, } from "./daemon-client-relay-e2ee-transport.js";
+export { decodeMessageData, describeTransportClose, describeTransportError, encodeUtf8String, extractRelayMessage, normalizeTransportPayload, safeRandomId, } from "./daemon-client-transport-utils.js";
+export { createEncryptedTransport, createRelayE2eeTransportFactory, createRelayTransportFactory, } from "./daemon-client-relay-e2ee-transport.js";
 export { bindWsHandler, createWebSocketTransportFactory, defaultWebSocketFactory, } from "./daemon-client-websocket-transport.js";
 //# sourceMappingURL=daemon-client-transport.js.map

package/dist/daemon-client-websocket-transport.d.ts

@@ -3,6 +3,10 @@ export declare function defaultWebSocketFactory(url: string, options?: {
     headers?: Record<string, string>;
     protocols?: string[];
 }): WebSocketLike;
+export declare function nativeWebSocketFactory(url: string, options?: {
+    headers?: Record<string, string>;
+    protocols?: string[];
+}): WebSocketLike;
 export declare function createWebSocketTransportFactory(factory: WebSocketFactory): DaemonTransportFactory;
 export declare function bindWsHandler(ws: WebSocketLike, event: "open" | "close" | "error" | "message", handler: (...args: unknown[]) => void): () => void;
 //# sourceMappingURL=daemon-client-websocket-transport.d.ts.map

package/dist/daemon-client-websocket-transport.js

@@ -1,9 +1,22 @@
-export function defaultWebSocketFactory(url, options) {
+import { extractRelayMessage } from "./daemon-client-transport-utils.js";
+function getGlobalWebSocket() {
     const globalWs = globalThis.WebSocket;
     if (!globalWs) {
         throw new Error("WebSocket is not available in this runtime");
     }
-    return new globalWs(url, options?.protocols);
+    return globalWs;
+}
+export function defaultWebSocketFactory(url, options) {
+    const globalWs = getGlobalWebSocket();
+    if (options?.protocols === undefined) {
+        return new globalWs(url);
+    }
+    return new globalWs(url, options.protocols);
+}
+// React Native and Node-compatible WebSocket implementations accept this extra options object.
+// Keep it out of the standard browser factory above.
+export function nativeWebSocketFactory(url, options) {
+    return new (getGlobalWebSocket())(url, options?.protocols, { headers: options?.headers });
 }
 export function createWebSocketTransportFactory(factory) {
     return ({ url, headers, protocols }) => {
@@ -40,10 +53,17 @@ export function createWebSocketTransportFactory(factory) {
             onOpen: (handler) => bindWsHandler(ws, "open", handler),
             onClose: (handler) => bindWsHandler(ws, "close", handler),
             onError: (handler) => bindWsHandler(ws, "error", handler),
-            onMessage: (handler) => bindWsHandler(ws, "message", handler),
+            onMessage: (handler) => bindWsMessageHandler(ws, handler),
         };
     };
 }
+function bindWsMessageHandler(ws, handler) {
+    const listener = (...args) => {
+        const message = extractRelayMessage(args[0], typeof args[1] === "boolean" ? args[1] : undefined);
+        handler(message.data, message.isBinary);
+    };
+    return bindWsHandler(ws, "message", listener);
+}
 function bindTemporaryEarlyCloseErrorHandler(ws) {
     const noop = () => { };
     if (typeof ws.addEventListener === "function") {