@slopus/happy-agent-client 0.0.0

package/dist/HappyAgentClient.js

@@ -0,0 +1,739 @@
+import { endpointUrl } from "./endpointUrl.js";
+import { readApiError } from "./HappyAgentApiError.js";
+import { EventStreamProtocolError, readEventStream } from "./readEventStream.js";
+/**
+ * A thin, faithful client for the Happy agent HTTP API.
+ *
+ * Every request-response route of `packages/happy-agent/API.md` is one method,
+ * and the event journal is available both as pages and as the live stream. The
+ * client keeps no state beyond the endpoint and the token: it does not cache
+ * resources, reconcile versions, retry, or reconnect. Those are decisions for
+ * whatever builds a live view on top of it.
+ *
+ * It is built on `fetch`, streams, `AbortController`, and standard timers
+ * alone, so one build runs unchanged in Node and in a browser. Nothing is
+ * validated at runtime; the types are a promise about what the specification
+ * says the daemon sends.
+ */
+export class HappyAgentClient {
+    #endpoint;
+    #token;
+    #fetch;
+    constructor(options) {
+        this.#endpoint = options.endpoint.toString();
+        this.#token = options.token;
+        this.#fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
+    }
+    /** Where this client talks, as it was given. */
+    get endpoint() {
+        return this.#endpoint;
+    }
+    // The daemon
+    /** `GET /` — a greeting confirming the caller reached a Happy agent. */
+    async getGreeting(options = {}) {
+        return await this.#json({ method: "GET", path: "", signal: options.signal });
+    }
+    /**
+     * `GET /v0/health` — whether the daemon is alive and ready to serve.
+     *
+     * The only route guaranteed to answer during startup; a client polls it
+     * until `ready` is `true` before using the rest of the API.
+     */
+    async getHealth(options = {}) {
+        return await this.#json({ method: "GET", path: "v0/health", signal: options.signal });
+    }
+    /** `GET /v0/config` — the sanitized effective configuration. */
+    async getConfig(options = {}) {
+        return await this.#json({ method: "GET", path: "v0/config", signal: options.signal });
+    }
+    /**
+     * `PATCH /v0/config` — requests a runtime settings change.
+     *
+     * A daemon that cannot reconfigure itself at runtime answers `409`.
+     */
+    async patchConfig(patch, options = {}) {
+        return await this.#json({
+            method: "PATCH",
+            path: "v0/config",
+            json: patch,
+            signal: options.signal,
+        });
+    }
+    /** `GET /v0/config/instructions` — the global instructions document. */
+    async getInstructions(options = {}) {
+        return await this.#json({
+            method: "GET",
+            path: "v0/config/instructions",
+            signal: options.signal,
+        });
+    }
+    /** `PUT /v0/config/instructions` — replaces it; the maximum size is 256 KB. */
+    async putInstructions(instructions, options = {}) {
+        return await this.#json({
+            method: "PUT",
+            path: "v0/config/instructions",
+            json: { instructions },
+            signal: options.signal,
+        });
+    }
+    /** `GET /v0/config/security` — the security policy document. */
+    async getSecurityPolicy(options = {}) {
+        return await this.#json({
+            method: "GET",
+            path: "v0/config/security",
+            signal: options.signal,
+        });
+    }
+    /** `PUT /v0/config/security` — replaces it; the maximum size is 32 KB. */
+    async putSecurityPolicy(policy, options = {}) {
+        return await this.#json({
+            method: "PUT",
+            path: "v0/config/security",
+            json: { policy },
+            signal: options.signal,
+        });
+    }
+    /** `POST /v0/shutdown` — asks the daemon to shut down; it answers first. */
+    async shutdown(options = {}) {
+        return await this.#json({ method: "POST", path: "v0/shutdown", signal: options.signal });
+    }
+    /** `POST /v0/debug/inspector` — starts the Node.js inspector on the daemon. */
+    async startInspector(options = {}) {
+        return await this.#json({
+            method: "POST",
+            path: "v0/debug/inspector",
+            signal: options.signal,
+        });
+    }
+    /** `DELETE /v0/debug/inspector` — stops it. */
+    async stopInspector(options = {}) {
+        return await this.#json({
+            method: "DELETE",
+            path: "v0/debug/inspector",
+            signal: options.signal,
+        });
+    }
+    // Profile
+    /** `GET /v0/profile` — always succeeds; an untouched profile is all `null`. */
+    async getProfile(options = {}) {
+        return await this.#json({ method: "GET", path: "v0/profile", signal: options.signal });
+    }
+    /** `PATCH /v0/profile` — a partial update; a field set to `null` is cleared. */
+    async updateProfile(request, options) {
+        return await this.#json({
+            method: "PATCH",
+            path: "v0/profile",
+            json: request,
+            ifMatch: options.ifMatch,
+            signal: options.signal,
+        });
+    }
+    /** `GET /v0/profile/photo` — the photo bytes; `null` when unchanged. */
+    async getProfilePhoto(options = {}) {
+        return await this.#binary({
+            method: "GET",
+            path: "v0/profile/photo",
+            ifNoneMatch: options.ifNoneMatch,
+            signal: options.signal,
+        });
+    }
+    /** `PUT /v0/profile/photo` — the daemon computes the ThumbHash. */
+    async setProfilePhoto(image, options = {}) {
+        return await this.#json({
+            method: "PUT",
+            path: "v0/profile/photo",
+            binary: image,
+            ifMatch: options.ifMatch,
+            signal: options.signal,
+        });
+    }
+    /** `DELETE /v0/profile/photo` */
+    async deleteProfilePhoto(options = {}) {
+        return await this.#json({
+            method: "DELETE",
+            path: "v0/profile/photo",
+            ifMatch: options.ifMatch,
+            signal: options.signal,
+        });
+    }
+    // Onboarding
+    /** `GET /v0/onboarding` — what a fresh installation still needs. */
+    async getOnboarding(options = {}) {
+        return await this.#json({ method: "GET", path: "v0/onboarding", signal: options.signal });
+    }
+    /** `POST /v0/onboarding/complete` — idempotent. */
+    async completeOnboarding(options = {}) {
+        return await this.#json({
+            method: "POST",
+            path: "v0/onboarding/complete",
+            signal: options.signal,
+        });
+    }
+    // Projects
+    /** `GET /v0/projects` — every project, archived ones included. */
+    async listProjects(options = {}) {
+        return await this.#json({ method: "GET", path: "v0/projects", signal: options.signal });
+    }
+    /** `POST /v0/projects` — registers an existing local folder. */
+    async registerProject(request, options = {}) {
+        return await this.#json({
+            method: "POST",
+            path: "v0/projects",
+            json: request,
+            signal: options.signal,
+        });
+    }
+    /** `POST /v0/projects/clone` — the clone itself runs in the background. */
+    async cloneProject(request, options = {}) {
+        return await this.#json({
+            method: "POST",
+            path: "v0/projects/clone",
+            json: request,
+            signal: options.signal,
+        });
+    }
+    /** `GET /v0/projects/:projectId` */
+    async getProject(projectId, options = {}) {
+        return await this.#json({
+            method: "GET",
+            path: `v0/projects/${encodeURIComponent(projectId)}`,
+            signal: options.signal,
+        });
+    }
+    /** `PATCH /v0/projects/:projectId` — renames it; `nameSource` becomes `"user"`. */
+    async renameProject(projectId, request, options) {
+        return await this.#json({
+            method: "PATCH",
+            path: `v0/projects/${encodeURIComponent(projectId)}`,
+            json: request,
+            ifMatch: options.ifMatch,
+            signal: options.signal,
+        });
+    }
+    /** `PUT /v0/projects/:projectId/settings` — replaces the settings. */
+    async replaceProjectSettings(projectId, request, options) {
+        return await this.#json({
+            method: "PUT",
+            path: `v0/projects/${encodeURIComponent(projectId)}/settings`,
+            json: request,
+            ifMatch: options.ifMatch,
+            signal: options.signal,
+        });
+    }
+    /** `POST /v0/projects/:projectId/refresh` — re-runs project setup. */
+    async refreshProject(projectId, options = {}) {
+        return await this.#json({
+            method: "POST",
+            path: `v0/projects/${encodeURIComponent(projectId)}/refresh`,
+            signal: options.signal,
+        });
+    }
+    /** `POST /v0/projects/:projectId/reorder` — neighbours move through events. */
+    async reorderProject(projectId, request, options) {
+        return await this.#json({
+            method: "POST",
+            path: `v0/projects/${encodeURIComponent(projectId)}/reorder`,
+            json: request,
+            ifMatch: options.ifMatch,
+            signal: options.signal,
+        });
+    }
+    /** `POST /v0/projects/:projectId/archive` — idempotent; cleanup is background work. */
+    async archiveProject(projectId, options) {
+        return await this.#json({
+            method: "POST",
+            path: `v0/projects/${encodeURIComponent(projectId)}/archive`,
+            json: bodyOf(options),
+            ifMatch: options.ifMatch,
+            signal: options.signal,
+        });
+    }
+    /** `GET /v0/projects/:projectId/avatar` — the picture bytes; `null` when unchanged. */
+    async getProjectAvatar(projectId, options = {}) {
+        return await this.#binary({
+            method: "GET",
+            path: `v0/projects/${encodeURIComponent(projectId)}/avatar`,
+            ifNoneMatch: options.ifNoneMatch,
+            signal: options.signal,
+        });
+    }
+    /** `PUT /v0/projects/:projectId/avatar` — the limit is 8 MB. */
+    async setProjectAvatar(projectId, image, options) {
+        return await this.#json({
+            method: "PUT",
+            path: `v0/projects/${encodeURIComponent(projectId)}/avatar`,
+            binary: image,
+            ifMatch: options.ifMatch,
+            signal: options.signal,
+        });
+    }
+    /** `DELETE /v0/projects/:projectId/avatar` */
+    async deleteProjectAvatar(projectId, options) {
+        return await this.#json({
+            method: "DELETE",
+            path: `v0/projects/${encodeURIComponent(projectId)}/avatar`,
+            ifMatch: options.ifMatch,
+            signal: options.signal,
+        });
+    }
+    // Workspaces
+    /** `GET /v0/workspaces` — a flat array; clients build the tree from `parentId`. */
+    async listWorkspaces(query = {}, options = {}) {
+        return await this.#json({
+            method: "GET",
+            path: "v0/workspaces",
+            query: { projectId: query.projectId, includeArchived: query.includeArchived },
+            signal: options.signal,
+        });
+    }
+    /** `POST /v0/workspaces` — the checkout builds in the background. */
+    async createWorkspace(request, options = {}) {
+        return await this.#json({
+            method: "POST",
+            path: "v0/workspaces",
+            json: request,
+            signal: options.signal,
+        });
+    }
+    /** `GET /v0/workspaces/:workspaceId` — a project ID answers with its root workspace. */
+    async getWorkspace(workspaceId, options = {}) {
+        return await this.#json({
+            method: "GET",
+            path: `v0/workspaces/${encodeURIComponent(workspaceId)}`,
+            signal: options.signal,
+        });
+    }
+    /** `PATCH /v0/workspaces/:workspaceId` — the Git branch moves in the background. */
+    async renameWorkspace(workspaceId, request, options) {
+        return await this.#json({
+            method: "PATCH",
+            path: `v0/workspaces/${encodeURIComponent(workspaceId)}`,
+            json: request,
+            ifMatch: options.ifMatch,
+            signal: options.signal,
+        });
+    }
+    /** `POST /v0/workspaces/:workspaceId/archive` — archives it and everything beneath. */
+    async archiveWorkspace(workspaceId, options) {
+        return await this.#json({
+            method: "POST",
+            path: `v0/workspaces/${encodeURIComponent(workspaceId)}/archive`,
+            json: bodyOf(options),
+            ifMatch: options.ifMatch,
+            signal: options.signal,
+        });
+    }
+    /** `POST /v0/workspaces/:workspaceId/reorder` — moves it among its siblings. */
+    async reorderWorkspace(workspaceId, request, options) {
+        return await this.#json({
+            method: "POST",
+            path: `v0/workspaces/${encodeURIComponent(workspaceId)}/reorder`,
+            json: request,
+            ifMatch: options.ifMatch,
+            signal: options.signal,
+        });
+    }
+    // Terminals
+    /** `GET /v0/workspaces/:workspaceId/terminals` */
+    async listTerminals(workspaceId, options = {}) {
+        return await this.#json({
+            method: "GET",
+            path: `v0/workspaces/${encodeURIComponent(workspaceId)}/terminals`,
+            signal: options.signal,
+        });
+    }
+    /** `POST /v0/workspaces/:workspaceId/terminals` — a workspace holds at most 32. */
+    async openTerminal(workspaceId, request = {}, options = {}) {
+        return await this.#json({
+            method: "POST",
+            path: `v0/workspaces/${encodeURIComponent(workspaceId)}/terminals`,
+            json: request,
+            signal: options.signal,
+        });
+    }
+    /** `PATCH /v0/workspaces/:workspaceId/terminals/:terminalId` */
+    async resizeTerminal(workspaceId, terminalId, request, options = {}) {
+        return await this.#json({
+            method: "PATCH",
+            path: `v0/workspaces/${encodeURIComponent(workspaceId)}/terminals/${encodeURIComponent(terminalId)}`,
+            json: request,
+            signal: options.signal,
+        });
+    }
+    /** `DELETE /v0/workspaces/:workspaceId/terminals/:terminalId` — stops it and its process. */
+    async stopTerminal(workspaceId, terminalId, options = {}) {
+        return await this.#json({
+            method: "DELETE",
+            path: `v0/workspaces/${encodeURIComponent(workspaceId)}/terminals/${encodeURIComponent(terminalId)}`,
+            signal: options.signal,
+        });
+    }
+    /**
+     * The URL of `GET /v0/workspaces/:workspaceId/terminals/:terminalId/attach`.
+     *
+     * The attachment is a WebSocket upgrade carrying binary terminal frames,
+     * which `fetch` cannot open. This client hands back the address so a caller
+     * can attach with whatever WebSocket its runtime provides; the bearer token
+     * goes on that request the same way it does here.
+     */
+    terminalAttachUrl(workspaceId, terminalId) {
+        return endpointUrl(this.#endpoint, `v0/workspaces/${encodeURIComponent(workspaceId)}/terminals/${encodeURIComponent(terminalId)}/attach`);
+    }
+    /**
+     * The URL of `CONNECT /v0/workspaces/:workspaceId/proxy`.
+     *
+     * The tunnel is a raw byte stream that `fetch` cannot open either, so the
+     * address is what this client offers.
+     */
+    workspaceProxyUrl(workspaceId) {
+        return endpointUrl(this.#endpoint, `v0/workspaces/${encodeURIComponent(workspaceId)}/proxy`);
+    }
+    // Files
+    /** `GET /v0/workspaces/:workspaceId/files` — case-insensitive filename search. */
+    async searchFiles(workspaceId, query, options = {}) {
+        return await this.#json({
+            method: "GET",
+            path: `v0/workspaces/${encodeURIComponent(workspaceId)}/files`,
+            query: { query: query.query, limit: query.limit },
+            signal: options.signal,
+        });
+    }
+    /** `GET /v0/workspaces/:workspaceId/file-tree` — one directory level, paginated. */
+    async getFileTree(workspaceId, query = {}, options = {}) {
+        return await this.#json({
+            method: "GET",
+            path: `v0/workspaces/${encodeURIComponent(workspaceId)}/file-tree`,
+            query: { path: query.path, cursor: query.cursor, limit: query.limit },
+            signal: options.signal,
+        });
+    }
+    /** `GET /v0/workspaces/:workspaceId/file` — base64 content and its sha256. */
+    async readFile(workspaceId, path, options = {}) {
+        return await this.#json({
+            method: "GET",
+            path: `v0/workspaces/${encodeURIComponent(workspaceId)}/file`,
+            query: { path },
+            signal: options.signal,
+        });
+    }
+    /** `PUT /v0/workspaces/:workspaceId/file` — `expectedHash` is the compare-and-swap. */
+    async writeFile(workspaceId, request, options = {}) {
+        return await this.#json({
+            method: "PUT",
+            path: `v0/workspaces/${encodeURIComponent(workspaceId)}/file`,
+            json: request,
+            signal: options.signal,
+        });
+    }
+    /** `GET /v0/workspaces/:workspaceId/file-revision` — one file as of a revision. */
+    async readFileRevision(workspaceId, query, options = {}) {
+        return await this.#json({
+            method: "GET",
+            path: `v0/workspaces/${encodeURIComponent(workspaceId)}/file-revision`,
+            query: { path: query.path, revision: query.revision },
+            signal: options.signal,
+        });
+    }
+    // Git
+    /** `GET /v0/workspaces/:workspaceId/git` — scans if nothing fresh is cached. */
+    async getWorkspaceGit(workspaceId, options = {}) {
+        return await this.#json({
+            method: "GET",
+            path: `v0/workspaces/${encodeURIComponent(workspaceId)}/git`,
+            signal: options.signal,
+        });
+    }
+    /**
+     * `POST /v0/git/watch` — subscribes workspaces to the live git watcher.
+     *
+     * Registrations are held per subscription set: a client re-posts its
+     * current interest, and workspaces it stops naming age out of the watcher.
+     */
+    async watchGit(request, options = {}) {
+        return await this.#json({
+            method: "POST",
+            path: "v0/git/watch",
+            json: request,
+            signal: options.signal,
+        });
+    }
+    // Agents
+    /** `POST /v0/agents` — creation always makes a top-level agent. */
+    async createAgent(request, options = {}) {
+        return await this.#json({
+            method: "POST",
+            path: "v0/agents",
+            json: request,
+            signal: options.signal,
+        });
+    }
+    /** `GET /v0/agents/:agentId` */
+    async getAgent(agentId, options = {}) {
+        return await this.#json({
+            method: "GET",
+            path: `v0/agents/${encodeURIComponent(agentId)}`,
+            signal: options.signal,
+        });
+    }
+    /**
+     * `POST /v0/agents/:agentId/send` — queues a message, or steers the run.
+     *
+     * The message is pending until inference accepts it; the acceptance travels
+     * as a `message.updated` event, and the `runId` it brings is the handle for
+     * `abortAgent`.
+     */
+    async sendMessage(agentId, request, options = {}) {
+        return await this.#json({
+            method: "POST",
+            path: `v0/agents/${encodeURIComponent(agentId)}/send`,
+            json: request,
+            signal: options.signal,
+        });
+    }
+    /**
+     * `GET /v0/agents/:agentId/messages` — history, grouped by run.
+     *
+     * `limit` is a lower bound: a page always contains whole runs and may
+     * overflow well past it, so buffers are sized for the runs received.
+     */
+    async getMessages(agentId, query = {}, options = {}) {
+        return await this.#json({
+            method: "GET",
+            path: `v0/agents/${encodeURIComponent(agentId)}/messages`,
+            query: {
+                before: query.before,
+                after: query.after,
+                limit: query.limit,
+                omitToolData: query.omitToolData,
+            },
+            signal: options.signal,
+        });
+    }
+    /** `GET /v0/agents/:agentId/question` — the open question, or `null`. */
+    async getPendingQuestion(agentId, options = {}) {
+        return await this.#json({
+            method: "GET",
+            path: `v0/agents/${encodeURIComponent(agentId)}/question`,
+            signal: options.signal,
+        });
+    }
+    /**
+     * `POST /v0/agents/:agentId/question/:questionId/answer` — the run resumes.
+     *
+     * Answering is first-write-wins across clients: a second answer is `409`
+     * carrying the question as it now stands.
+     */
+    async answerQuestion(agentId, questionId, request, options = {}) {
+        return await this.#json({
+            method: "POST",
+            path: `v0/agents/${encodeURIComponent(agentId)}/question/${encodeURIComponent(questionId)}/answer`,
+            json: request,
+            signal: options.signal,
+        });
+    }
+    /** `POST /v0/agents/:agentId/abort` — stops the current run. */
+    async abortAgent(agentId, request = {}, options = {}) {
+        return await this.#json({
+            method: "POST",
+            path: `v0/agents/${encodeURIComponent(agentId)}/abort`,
+            json: request,
+            signal: options.signal,
+        });
+    }
+    /** `POST /v0/agents/:agentId/compact` — summarizes older context for the model. */
+    async compactAgent(agentId, request = {}, options = {}) {
+        return await this.#json({
+            method: "POST",
+            path: `v0/agents/${encodeURIComponent(agentId)}/compact`,
+            json: request,
+            signal: options.signal,
+        });
+    }
+    /** `POST /v0/agents/:agentId/read` — clears `unread`. */
+    async markAgentRead(agentId, request = {}, options = {}) {
+        return await this.#json({
+            method: "POST",
+            path: `v0/agents/${encodeURIComponent(agentId)}/read`,
+            json: request,
+            signal: options.signal,
+        });
+    }
+    /** `POST /v0/agents/:agentId/archive` — keeps the history; aborts a running turn. */
+    async archiveAgent(agentId, request = {}, options = {}) {
+        return await this.#json({
+            method: "POST",
+            path: `v0/agents/${encodeURIComponent(agentId)}/archive`,
+            json: request,
+            signal: options.signal,
+        });
+    }
+    /** `POST /v0/agents/:agentId/unarchive` — idempotent. */
+    async unarchiveAgent(agentId, request = {}, options = {}) {
+        return await this.#json({
+            method: "POST",
+            path: `v0/agents/${encodeURIComponent(agentId)}/unarchive`,
+            json: request,
+            signal: options.signal,
+        });
+    }
+    /** `POST /v0/agents/:agentId/reorder` — moves the agent in the list order. */
+    async reorderAgent(agentId, request, options = {}) {
+        return await this.#json({
+            method: "POST",
+            path: `v0/agents/${encodeURIComponent(agentId)}/reorder`,
+            json: request,
+            signal: options.signal,
+        });
+    }
+    /** `PUT /v0/agents/:agentId/draft` — saves or clears the composer draft. */
+    async saveAgentDraft(agentId, request, options = {}) {
+        return await this.#json({
+            method: "PUT",
+            path: `v0/agents/${encodeURIComponent(agentId)}/draft`,
+            json: request,
+            signal: options.signal,
+        });
+    }
+    /** `GET /v0/agents/:agentId/usage` — the agent's whole life, subagents included. */
+    async getAgentUsage(agentId, options = {}) {
+        return await this.#json({
+            method: "GET",
+            path: `v0/agents/${encodeURIComponent(agentId)}/usage`,
+            signal: options.signal,
+        });
+    }
+    /** `GET /v0/agents/:agentId/activity` — every subagent and process it set in motion. */
+    async getAgentActivity(agentId, options = {}) {
+        return await this.#json({
+            method: "GET",
+            path: `v0/agents/${encodeURIComponent(agentId)}/activity`,
+            signal: options.signal,
+        });
+    }
+    /** `DELETE /v0/agents/:agentId/processes/:processId` — stops a running process. */
+    async stopProcess(agentId, processId, options = {}) {
+        return await this.#json({
+            method: "DELETE",
+            path: `v0/agents/${encodeURIComponent(agentId)}/processes/${encodeURIComponent(processId)}`,
+            signal: options.signal,
+        });
+    }
+    /** `GET /v0/usage` — the whole daemon, in rolling windows ending now. */
+    async getUsage(options = {}) {
+        return await this.#json({ method: "GET", path: "v0/usage", signal: options.signal });
+    }
+    // Events
+    /**
+     * `GET /v0/events` — pulls events, oldest first.
+     *
+     * A cursor that fell out of the bounded journal answers `409` with code
+     * `cursor_unavailable`, carrying the cursor to resync from.
+     */
+    async getEvents(query = {}, options = {}) {
+        return await this.#json({
+            method: "GET",
+            path: "v0/events",
+            query: { after: query.after, until: query.until, limit: query.limit },
+            signal: options.signal,
+        });
+    }
+    /**
+     * `GET /v0/events/stream` — the same journal, live.
+     *
+     * The iteration yields the opening `hello` frame and then every event, and
+     * ends when the daemon closes the stream or the signal aborts. One
+     * connection is one iteration: reconnecting is the caller's decision, made
+     * with the last cursor it received and honored through `after` or
+     * `lastEventId`.
+     */
+    async *streamEvents(options = {}) {
+        const response = await this.#send({
+            method: "GET",
+            path: "v0/events/stream",
+            query: { after: options.after },
+            accept: "text/event-stream",
+            lastEventId: options.lastEventId,
+            signal: options.signal,
+        });
+        if (response.body === null) {
+            throw new EventStreamProtocolError("The event stream carried no body.");
+        }
+        yield* readEventStream(response.body);
+    }
+    // Bootstrap
+    /**
+     * `GET /v0/bootstrap/desktop` — one request that gets a client on screen.
+     *
+     * The `cursor` it carries is the newest event as of the snapshot, so a
+     * stream opened from it leaves no window for a change to fall through.
+     */
+    async getDesktopBootstrap(options = {}) {
+        return await this.#json({
+            method: "GET",
+            path: "v0/bootstrap/desktop",
+            signal: options.signal,
+        });
+    }
+    // Making the request
+    async #json(request) {
+        const response = await this.#send(request);
+        return (await response.json());
+    }
+    async #binary(request) {
+        const response = await this.#send({
+            ...request,
+            accept: "image/*",
+            allowNotModified: true,
+        });
+        if (response.status === 304)
+            return null;
+        return {
+            contentType: response.headers.get("content-type") ?? "application/octet-stream",
+            data: await response.arrayBuffer(),
+            etag: response.headers.get("etag"),
+        };
+    }
+    async #send(request) {
+        const headers = {
+            accept: request.accept ?? "application/json",
+            authorization: `Bearer ${this.#token}`,
+        };
+        if (request.ifMatch !== undefined)
+            headers["if-match"] = request.ifMatch;
+        if (request.ifNoneMatch !== undefined)
+            headers["if-none-match"] = request.ifNoneMatch;
+        if (request.lastEventId !== undefined)
+            headers["last-event-id"] = request.lastEventId;
+        let body = null;
+        if (request.binary !== undefined) {
+            headers["content-type"] = request.binary.contentType;
+            body = request.binary.data;
+        }
+        else if (request.json !== undefined) {
+            headers["content-type"] = "application/json; charset=utf-8";
+            body = JSON.stringify(request.json);
+        }
+        const response = await this.#fetch(endpointUrl(this.#endpoint, request.path, request.query), {
+            method: request.method,
+            headers,
+            body,
+            signal: request.signal ?? null,
+        });
+        if (response.ok)
+            return response;
+        if (response.status === 304 && request.allowNotModified === true)
+            return response;
+        throw await readApiError(response);
+    }
+}
+/**
+ * The JSON body of a mutation whose only field is the optional mutation echo.
+ *
+ * Archiving names nothing but the resource itself, so one options object
+ * carries the `If-Match` version, the signal, and the single body field; this
+ * keeps the transport parts out of what is sent.
+ */
+function bodyOf(options) {
+    return options.mutationId === undefined ? {} : { mutationId: options.mutationId };
+}
+//# sourceMappingURL=HappyAgentClient.js.map