@workerdeck/client 0.6.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tobias Strebitzer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,90 @@
+# @workerdeck/client
+
+Typed WorkerDeck protocol client for browsers and Node: REST session management plus a
+WebSocket attach with auto-reconnect and replay-from-last-seq. Uses the platform's `fetch` and
+`WebSocket`; zero runtime dependencies beyond the wire types.
+
+Part of [WorkerDeck](https://github.com/workerdeck/workerdeck). It speaks the
+[`@workerdeck/protocol`](https://www.npmjs.com/package/@workerdeck/protocol) wire format to a
+running [`@workerdeck/server`](https://www.npmjs.com/package/@workerdeck/server) gateway.
+Layers above build on it:
+[`@workerdeck/react`](https://www.npmjs.com/package/@workerdeck/react) (headless hook +
+transcript reducer) and [`@workerdeck/ui`](https://www.npmjs.com/package/@workerdeck/ui)
+(styled session panel).
+
+## Install
+
+```bash
+npm install @workerdeck/client
+```
+
+Pairs with a running `@workerdeck/server` — the client is just the typed caller.
+
+## Usage
+
+```ts
+import { WorkerDeckClient } from '@workerdeck/client'
+
+const client = new WorkerDeckClient({
+  baseUrl: 'http://127.0.0.1:8787/v1', // ws:// URL is derived from it
+  headers: { authorization: 'Bearer …' }, // REST auth; use buildWsUrl/cookies for WS auth
+})
+
+const session = await client.createSession({
+  cwd: '/srv/checkouts/my-repo',
+  prompt: '/verify-content 42',
+  settingSources: ['user', 'project'],
+})
+
+const handle = client.attach(session.id) // auto-reconnects, replays from last seen seq
+handle.on('attached', (frame) => console.log('snapshot', frame.session.status))
+handle.on('event', (event) => console.log(event.seq, event.type))
+handle.on('connectionChange', (up) => console.log(up ? 'connected' : 'reconnecting'))
+
+handle.send('also run the tests')
+handle.approve(requestId)                // permission decisions
+handle.deny(requestId, 'not this file')
+handle.interrupt()
+handle.setPermissionMode('acceptEdits')
+handle.detach()                          // disconnect without touching the session
+```
+
+`attach()` accepts `{ afterSeq, reconnect }`. On reconnect the handle asks the server for events
+after the last seq it saw, so the stream is gapless and duplicates are dropped; commands sent
+while disconnected are buffered and flushed on reopen. REST surface:
+`createSession` / `listSessions` / `getSession` / `deleteSession`, `resolvePermission` (answer a
+pending approval or `AskUserQuestion` over REST), and `listSdkSessions` (on-disk sessions to feed
+`createSession({ resume })`).
+
+### Job queue
+
+Against a server configured with `queue`:
+
+```ts
+const job = await client.createJob({
+  session: { cwd: '/srv/checkout', prompt: '/verify-content 42' },
+  webhook: { url: 'https://my-app.test/hooks/claude' },
+  attempts: 3,
+})
+await client.getJob(job.id)      // plus listJobs(), cancelJob(id), queueStats()
+
+const queue = client.attachQueue() // read-only live stream over /queue/ws
+queue.on('event', (e) => console.log(e.type, e.job.id))
+queue.on('stats', (s) => console.log(s.running, 'running of', s.maxConcurrency))
+```
+
+The queue stream has no replay: on (re)connect, re-list jobs and treat the stream as updates.
+
+## Runtime
+
+- **Browsers and Node** — built on platform `fetch` and `WebSocket` (global in Node ≥22). Both are
+  injectable (`fetchImpl`, `WebSocketImpl`) for older runtimes, polyfills, and tests.
+- **Zero runtime dependencies** — the only dependency is `@workerdeck/protocol`, which is
+  itself dependency-free wire types.
+- Browsers cannot set WS headers: authenticate the socket with a ticket query param via
+  `buildWsUrl(sessionId, afterSeq)` (and `buildQueueWsUrl`) or with cookies.
+
+## License
+
+MIT © Tobias Strebitzer — see
+[LICENSE](https://github.com/workerdeck/workerdeck/blob/master/LICENSE).

package/build/index.d.mts

@@ -0,0 +1,162 @@
+import { AttachedFrame, CreateJobRequest, CreateProfileRequest, CreateSessionRequest, GetProfileResponse, JobEvent, JobInfo, ListProfilesResponse, PermissionMode, ProfileInfo, QueueStats, ResolvePermissionRequest, SdkSessionSummary, SessionEvent, SessionFileInfo, SessionInfo, SubmitExecutionResultRequest, SubmitExecutionResultResponse, ToolCallRequestFrame, ToolExecutionOutput, UpdateProfileRequest } from "@workerdeck/protocol";
+
+//#region src/index.d.ts
+type ClientOptions = {
+  /** REST base, e.g. "http://127.0.0.1:8787/v1". The ws:// URL is derived from it. */baseUrl: string;
+  /** Extra headers for REST calls (auth). Browsers can't set WS headers — use
+   * `buildWsUrl` (ticket query param) or cookies for WS auth. */
+  headers?: Record<string, string>; /** Override WS URL construction (auth tickets, proxies). */
+  buildWsUrl?: (sessionId: string, afterSeq: number) => string; /** Override the queue WS URL (`{baseUrl}/queue/ws` by default). */
+  buildQueueWsUrl?: () => string; /** Injectable for non-browser environments/tests. Defaults to globalThis.WebSocket. */
+  WebSocketImpl?: typeof WebSocket;
+  fetchImpl?: typeof fetch;
+};
+type AttachOptions = {
+  /** Replay events with seq greater than this. Default 0 (full replay). */afterSeq?: number; /** Auto-reconnect with backoff on unexpected disconnects. Default true. */
+  reconnect?: boolean;
+};
+type SessionHandleEvents = {
+  /** Fired on every (re)attach with the server's session snapshot. */attached: AttachedFrame; /** Every session event, replayed and live, in seq order. */
+  event: SessionEvent;
+  protocolError: string; /** WS connectivity: true on open, false on close. */
+  connectionChange: boolean;
+  /**
+   * The server is asking this client to execute a tool call in its own sandbox.
+   * Answer with {@link SessionHandle.sendToolCallResult} or
+   * {@link SessionHandle.sendToolCallError}, echoing the same `executionId`.
+   * Ignoring it is safe: the server fails the execution at `expiresAt`.
+   */
+  toolCallRequest: ToolCallRequestFrame;
+  /** A bridged call no longer needs an answer (turn interrupted, timed out, or
+   * the session closed) — abandon any work in progress for this executionId. */
+  toolCallCanceled: {
+    executionId: string;
+    reason: string;
+  };
+};
+type Listener<T> = (payload: T) => void;
+declare class SessionHandle {
+  #private;
+  readonly sessionId: string;
+  constructor(client: WorkerDeckClient, sessionId: string, options?: AttachOptions);
+  get lastSeq(): number;
+  on<K extends keyof SessionHandleEvents>(kind: K, listener: Listener<SessionHandleEvents[K]>): () => void;
+  send(text: string): void;
+  approve(requestId: string, updatedInput?: Record<string, unknown>): void;
+  deny(requestId: string, message?: string, interrupt?: boolean): void;
+  interrupt(): void;
+  setPermissionMode(mode: PermissionMode): void;
+  /** Switch the model for subsequent responses; omit `model` for the default. */
+  setModel(model?: string): void;
+  /** Answer a bridged tool call (see the `toolCallRequest` event). */
+  sendToolCallResult(executionId: string, output: ToolExecutionOutput, logs?: string[]): void;
+  /** Report that a bridged tool call could not be executed. The failure is fed
+   * to the model as tool output, so the agent can adapt rather than stall. */
+  sendToolCallError(executionId: string, reason: string, error: string, logs?: string[]): void;
+  /** Ask the server to terminate the session (the handle disconnects too). */
+  closeSession(): void;
+  /** Disconnect this handle without touching the session. */
+  detach(): void;
+}
+type QueueHandleEvents = {
+  /** Fired on every (re)attach with the server's current stats. */attached: QueueStats; /** Every job lifecycle/progress event, live. */
+  event: JobEvent; /** Refreshed stats pushed after job lifecycle changes. */
+  stats: QueueStats; /** WS connectivity: true on open, false on close. */
+  connectionChange: boolean;
+};
+/**
+ * Live view of the server's job queue over `{basePath}/queue/ws`. The stream is
+ * read-only — submit/cancel stay on the REST methods. There is no replay: on
+ * (re)connect, re-list jobs and treat the stream as updates from there.
+ */
+declare class QueueHandle {
+  #private;
+  constructor(client: WorkerDeckClient, options?: {
+    reconnect?: boolean;
+  });
+  on<K extends keyof QueueHandleEvents>(kind: K, listener: Listener<QueueHandleEvents[K]>): () => void;
+  detach(): void;
+}
+declare class WorkerDeckClient {
+  #private;
+  constructor(options: ClientOptions);
+  createSession(request: CreateSessionRequest): Promise<SessionInfo>;
+  listSessions(): Promise<SessionInfo[]>;
+  getSession(id: string): Promise<SessionInfo>;
+  deleteSession(id: string): Promise<SessionInfo>;
+  /** List the files currently in a session's scratch filesystem (deliverables the
+   * agent wrote; see the `file_delivered` event). 404s when the session's engine
+   * has no file store (Claude-engine sessions). */
+  listSessionFiles(sessionId: string): Promise<SessionFileInfo[]>;
+  /** Download one session file as text. */
+  fetchSessionFile(sessionId: string, path: string): Promise<string>;
+  /** Direct download URL for a session file (e.g. an <a download> href). Carries
+   * no headers — on authenticated servers, use fetchSessionFile instead. */
+  sessionFileUrl(sessionId: string, path: string): string;
+  /** Resolve a pending permission over REST — the remote-controller counterpart of the
+   * WS `permission_decision` command (e.g. answering a job's AskUserQuestion from a
+   * webhook consumer; the request rides on job_progress deliveries). Throws if the
+   * request is unknown, already resolved, or expired. */
+  resolvePermission(sessionId: string, requestId: string, decision: ResolvePermissionRequest): Promise<void>;
+  /**
+   * Deliver the result of a deferred tool execution — the callback a remote
+   * worker (or a human) makes when the work a session parked on is done. The
+   * session is rehydrated if its runner was torn down, and the agent loop
+   * continues with this as the tool's output.
+   *
+   * Applied idempotently by `executionId`: a duplicate, or one racing the
+   * execution watchdog, resolves with `applied: false` instead of applying twice.
+   * Throws (404) when no session is waiting on that id.
+   */
+  submitExecutionResult(executionId: string, result: SubmitExecutionResultRequest): Promise<SubmitExecutionResultResponse>;
+  /** List the profiles (named Claude Code config dirs) this server declares, filtered
+   * to what the caller may use. Feed a result's `name` to createSession({ profile }).
+   * Servers predating profiles 404 here — catch and treat as none declared. */
+  /** The profiles this caller may use, plus whether it may create new ones.
+   * Each profile carries `managed: true` when it is store-backed and therefore
+   * editable; profiles declared in server options are not. */
+  listProfiles(): Promise<ListProfilesResponse>;
+  /** One profile plus a fresh, view-only snapshot of its config directory (settings,
+   * skills, agents, commands — env var names only, never values). */
+  getProfile(name: string): Promise<GetProfileResponse>;
+  /**
+   * Create a managed profile. Requires a server with a profile store and a
+   * principal allowed to manage profiles; 409 if the name is already taken by a
+   * managed or a startup-declared profile.
+   */
+  createProfile(profile: CreateProfileRequest): Promise<ProfileInfo>;
+  /** Merge into a managed profile. The name is the route: profiles cannot be
+   * renamed, since sessions and jobs are already pinned to the old one. */
+  updateProfile(name: string, patch: UpdateProfileRequest): Promise<ProfileInfo>;
+  /** Delete a managed profile. Startup-declared profiles are refused (403) —
+   * they live in the server's options. */
+  deleteProfile(name: string): Promise<void>;
+  /** List the Agent SDK's on-disk sessions (for resume across server restarts).
+   * Feed a result's `sessionId` to createSession({ resume }). */
+  listSdkSessions(params?: {
+    dir?: string;
+    limit?: number;
+    offset?: number;
+  }): Promise<SdkSessionSummary[]>;
+  /** Schedule a one-shot run. The returned job's `sessionId` (once running) can be
+   * fed to `attach()` to watch the run live. */
+  createJob(request: CreateJobRequest): Promise<JobInfo>;
+  listJobs(): Promise<JobInfo[]>;
+  getJob(id: string): Promise<JobInfo>;
+  /** Cancel a queued or running job. */
+  cancelJob(id: string): Promise<JobInfo>;
+  queueStats(): Promise<QueueStats>;
+  attach(sessionId: string, options?: AttachOptions): SessionHandle;
+  /** Stream the job queue live (requires the server to be configured with `queue`).
+   * Servers without a queue refuse the socket — check REST first or expect retries. */
+  attachQueue(options?: {
+    reconnect?: boolean;
+  }): QueueHandle;
+  /** @internal used by SessionHandle */
+  openSocket(sessionId: string, afterSeq: number): WebSocket;
+  /** @internal used by QueueHandle */
+  openQueueSocket(): WebSocket;
+}
+//#endregion
+export { AttachOptions, ClientOptions, QueueHandle, QueueHandleEvents, SessionHandle, SessionHandleEvents, WorkerDeckClient };
+//# sourceMappingURL=index.d.mts.map

package/build/index.mjs

@@ -0,0 +1,372 @@
+//#region src/index.ts
+var SessionHandle = class {
+	sessionId;
+	#client;
+	#options;
+	#ws;
+	#listeners = /* @__PURE__ */ new Map();
+	#lastSeq;
+	#closed = false;
+	#retries = 0;
+	#outbox = [];
+	#connectTimer;
+	constructor(client, sessionId, options = {}) {
+		this.#client = client;
+		this.sessionId = sessionId;
+		this.#options = {
+			reconnect: true,
+			...options
+		};
+		this.#lastSeq = options.afterSeq ?? 0;
+		this.#connectTimer = setTimeout(() => this.#connect(), 0);
+	}
+	get lastSeq() {
+		return this.#lastSeq;
+	}
+	on(kind, listener) {
+		let set = this.#listeners.get(kind);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			this.#listeners.set(kind, set);
+		}
+		set.add(listener);
+		return () => set.delete(listener);
+	}
+	send(text) {
+		this.#sendFrame({
+			type: "user_message",
+			text
+		});
+	}
+	approve(requestId, updatedInput) {
+		this.#sendFrame({
+			type: "permission_decision",
+			requestId,
+			behavior: "allow",
+			updatedInput
+		});
+	}
+	deny(requestId, message, interrupt) {
+		this.#sendFrame({
+			type: "permission_decision",
+			requestId,
+			behavior: "deny",
+			message,
+			interrupt
+		});
+	}
+	interrupt() {
+		this.#sendFrame({ type: "interrupt" });
+	}
+	setPermissionMode(mode) {
+		this.#sendFrame({
+			type: "set_permission_mode",
+			mode
+		});
+	}
+	/** Switch the model for subsequent responses; omit `model` for the default. */
+	setModel(model) {
+		this.#sendFrame({
+			type: "set_model",
+			model
+		});
+	}
+	/** Answer a bridged tool call (see the `toolCallRequest` event). */
+	sendToolCallResult(executionId, output, logs) {
+		this.#sendFrame({
+			type: "tool_call_result",
+			executionId,
+			output,
+			logs
+		});
+	}
+	/** Report that a bridged tool call could not be executed. The failure is fed
+	* to the model as tool output, so the agent can adapt rather than stall. */
+	sendToolCallError(executionId, reason, error, logs) {
+		this.#sendFrame({
+			type: "tool_call_error",
+			executionId,
+			reason,
+			error,
+			logs
+		});
+	}
+	/** Ask the server to terminate the session (the handle disconnects too). */
+	closeSession() {
+		this.#sendFrame({ type: "close" });
+		this.detach();
+	}
+	/** Disconnect this handle without touching the session. */
+	detach() {
+		this.#closed = true;
+		clearTimeout(this.#connectTimer);
+		this.#ws?.close();
+		this.#ws = void 0;
+	}
+	#emit(kind, payload) {
+		const set = this.#listeners.get(kind);
+		if (!set) return;
+		for (const listener of set) try {
+			listener(payload);
+		} catch {}
+	}
+	#sendFrame(frame) {
+		const payload = JSON.stringify(frame);
+		if (this.#ws && this.#ws.readyState === 1) this.#ws.send(payload);
+		else this.#outbox.push(payload);
+	}
+	#connect() {
+		if (this.#closed) return;
+		const ws = this.#client.openSocket(this.sessionId, this.#lastSeq);
+		this.#ws = ws;
+		ws.onopen = () => {
+			this.#retries = 0;
+			this.#emit("connectionChange", true);
+			for (const payload of this.#outbox.splice(0)) ws.send(payload);
+		};
+		ws.onmessage = (msg) => {
+			const frame = JSON.parse(String(msg.data));
+			if (frame.type === "attached") this.#emit("attached", frame);
+			else if (frame.type === "event") {
+				if (frame.event.seq <= this.#lastSeq) return;
+				this.#lastSeq = frame.event.seq;
+				this.#emit("event", frame.event);
+			} else if (frame.type === "tool_call_request") this.#emit("toolCallRequest", frame);
+			else if (frame.type === "tool_call_canceled") this.#emit("toolCallCanceled", {
+				executionId: frame.executionId,
+				reason: frame.reason
+			});
+			else if (frame.type === "protocol_error") this.#emit("protocolError", frame.message);
+		};
+		ws.onclose = () => {
+			this.#emit("connectionChange", false);
+			if (this.#closed || !this.#options.reconnect) return;
+			const delay = Math.min(500 * 2 ** this.#retries++, 1e4);
+			this.#connectTimer = setTimeout(() => this.#connect(), delay);
+		};
+		ws.onerror = () => {};
+	}
+};
+/**
+* Live view of the server's job queue over `{basePath}/queue/ws`. The stream is
+* read-only — submit/cancel stay on the REST methods. There is no replay: on
+* (re)connect, re-list jobs and treat the stream as updates from there.
+*/
+var QueueHandle = class {
+	#client;
+	#reconnect;
+	#ws;
+	#listeners = /* @__PURE__ */ new Map();
+	#closed = false;
+	#retries = 0;
+	#connectTimer;
+	constructor(client, options = {}) {
+		this.#client = client;
+		this.#reconnect = options.reconnect ?? true;
+		this.#connectTimer = setTimeout(() => this.#connect(), 0);
+	}
+	on(kind, listener) {
+		let set = this.#listeners.get(kind);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			this.#listeners.set(kind, set);
+		}
+		set.add(listener);
+		return () => set.delete(listener);
+	}
+	detach() {
+		this.#closed = true;
+		clearTimeout(this.#connectTimer);
+		this.#ws?.close();
+		this.#ws = void 0;
+	}
+	#emit(kind, payload) {
+		const set = this.#listeners.get(kind);
+		if (!set) return;
+		for (const listener of set) try {
+			listener(payload);
+		} catch {}
+	}
+	#connect() {
+		if (this.#closed) return;
+		const ws = this.#client.openQueueSocket();
+		this.#ws = ws;
+		ws.onopen = () => {
+			this.#retries = 0;
+			this.#emit("connectionChange", true);
+		};
+		ws.onmessage = (msg) => {
+			const frame = JSON.parse(String(msg.data));
+			if (frame.type === "queue_attached") {
+				this.#emit("attached", frame.stats);
+				this.#emit("stats", frame.stats);
+			} else if (frame.type === "job_event") this.#emit("event", frame.event);
+			else if (frame.type === "queue_stats") this.#emit("stats", frame.stats);
+		};
+		ws.onclose = () => {
+			this.#emit("connectionChange", false);
+			if (this.#closed || !this.#reconnect) return;
+			const delay = Math.min(500 * 2 ** this.#retries++, 1e4);
+			this.#connectTimer = setTimeout(() => this.#connect(), delay);
+		};
+		ws.onerror = () => {};
+	}
+};
+var WorkerDeckClient = class {
+	#options;
+	#fetch;
+	#WebSocketImpl;
+	constructor(options) {
+		this.#options = options;
+		this.#fetch = options.fetchImpl ?? fetch.bind(globalThis);
+		this.#WebSocketImpl = options.WebSocketImpl ?? WebSocket;
+	}
+	async createSession(request) {
+		return (await this.#call("POST", "/sessions", request)).session;
+	}
+	async listSessions() {
+		return (await this.#call("GET", "/sessions")).sessions;
+	}
+	async getSession(id) {
+		return (await this.#call("GET", `/sessions/${encodeURIComponent(id)}`)).session;
+	}
+	async deleteSession(id) {
+		return (await this.#call("DELETE", `/sessions/${encodeURIComponent(id)}`)).session;
+	}
+	/** List the files currently in a session's scratch filesystem (deliverables the
+	* agent wrote; see the `file_delivered` event). 404s when the session's engine
+	* has no file store (Claude-engine sessions). */
+	async listSessionFiles(sessionId) {
+		return (await this.#call("GET", `/sessions/${encodeURIComponent(sessionId)}/files`)).files;
+	}
+	/** Download one session file as text. */
+	async fetchSessionFile(sessionId, path) {
+		const res = await this.#fetch(this.sessionFileUrl(sessionId, path), { headers: this.#options.headers });
+		if (!res.ok) {
+			const payload = await res.json().catch(() => ({}));
+			throw new Error(payload.error ?? `GET file failed with ${res.status}`);
+		}
+		return await res.text();
+	}
+	/** Direct download URL for a session file (e.g. an <a download> href). Carries
+	* no headers — on authenticated servers, use fetchSessionFile instead. */
+	sessionFileUrl(sessionId, path) {
+		const encoded = path.split("/").filter(Boolean).map(encodeURIComponent).join("/");
+		return `${this.#options.baseUrl}/sessions/${encodeURIComponent(sessionId)}/files/${encoded}`;
+	}
+	/** Resolve a pending permission over REST — the remote-controller counterpart of the
+	* WS `permission_decision` command (e.g. answering a job's AskUserQuestion from a
+	* webhook consumer; the request rides on job_progress deliveries). Throws if the
+	* request is unknown, already resolved, or expired. */
+	async resolvePermission(sessionId, requestId, decision) {
+		await this.#call("POST", `/sessions/${encodeURIComponent(sessionId)}/permissions/${encodeURIComponent(requestId)}`, decision);
+	}
+	/**
+	* Deliver the result of a deferred tool execution — the callback a remote
+	* worker (or a human) makes when the work a session parked on is done. The
+	* session is rehydrated if its runner was torn down, and the agent loop
+	* continues with this as the tool's output.
+	*
+	* Applied idempotently by `executionId`: a duplicate, or one racing the
+	* execution watchdog, resolves with `applied: false` instead of applying twice.
+	* Throws (404) when no session is waiting on that id.
+	*/
+	async submitExecutionResult(executionId, result) {
+		return await this.#call("POST", `/executions/${encodeURIComponent(executionId)}/result`, result);
+	}
+	/** List the profiles (named Claude Code config dirs) this server declares, filtered
+	* to what the caller may use. Feed a result's `name` to createSession({ profile }).
+	* Servers predating profiles 404 here — catch and treat as none declared. */
+	/** The profiles this caller may use, plus whether it may create new ones.
+	* Each profile carries `managed: true` when it is store-backed and therefore
+	* editable; profiles declared in server options are not. */
+	async listProfiles() {
+		return await this.#call("GET", "/profiles");
+	}
+	/** One profile plus a fresh, view-only snapshot of its config directory (settings,
+	* skills, agents, commands — env var names only, never values). */
+	async getProfile(name) {
+		return await this.#call("GET", `/profiles/${encodeURIComponent(name)}`);
+	}
+	/**
+	* Create a managed profile. Requires a server with a profile store and a
+	* principal allowed to manage profiles; 409 if the name is already taken by a
+	* managed or a startup-declared profile.
+	*/
+	async createProfile(profile) {
+		return (await this.#call("POST", "/profiles", profile)).profile;
+	}
+	/** Merge into a managed profile. The name is the route: profiles cannot be
+	* renamed, since sessions and jobs are already pinned to the old one. */
+	async updateProfile(name, patch) {
+		return (await this.#call("PATCH", `/profiles/${encodeURIComponent(name)}`, patch)).profile;
+	}
+	/** Delete a managed profile. Startup-declared profiles are refused (403) —
+	* they live in the server's options. */
+	async deleteProfile(name) {
+		await this.#call("DELETE", `/profiles/${encodeURIComponent(name)}`);
+	}
+	/** List the Agent SDK's on-disk sessions (for resume across server restarts).
+	* Feed a result's `sessionId` to createSession({ resume }). */
+	async listSdkSessions(params) {
+		const search = new URLSearchParams();
+		if (params?.dir) search.set("dir", params.dir);
+		if (params?.limit !== void 0) search.set("limit", String(params.limit));
+		if (params?.offset !== void 0) search.set("offset", String(params.offset));
+		const qs = search.size > 0 ? `?${search.toString()}` : "";
+		return (await this.#call("GET", `/sdk-sessions${qs}`)).sdkSessions;
+	}
+	/** Schedule a one-shot run. The returned job's `sessionId` (once running) can be
+	* fed to `attach()` to watch the run live. */
+	async createJob(request) {
+		return (await this.#call("POST", "/jobs", request)).job;
+	}
+	async listJobs() {
+		return (await this.#call("GET", "/jobs")).jobs;
+	}
+	async getJob(id) {
+		return (await this.#call("GET", `/jobs/${encodeURIComponent(id)}`)).job;
+	}
+	/** Cancel a queued or running job. */
+	async cancelJob(id) {
+		return (await this.#call("DELETE", `/jobs/${encodeURIComponent(id)}`)).job;
+	}
+	async queueStats() {
+		return (await this.#call("GET", "/queue")).stats;
+	}
+	attach(sessionId, options) {
+		return new SessionHandle(this, sessionId, options);
+	}
+	/** Stream the job queue live (requires the server to be configured with `queue`).
+	* Servers without a queue refuse the socket — check REST first or expect retries. */
+	attachQueue(options) {
+		return new QueueHandle(this, options);
+	}
+	/** @internal used by SessionHandle */
+	openSocket(sessionId, afterSeq) {
+		const url = this.#options.buildWsUrl?.(sessionId, afterSeq) ?? `${this.#options.baseUrl.replace(/^http/, "ws")}/sessions/${encodeURIComponent(sessionId)}/ws?afterSeq=${afterSeq}`;
+		return new this.#WebSocketImpl(url);
+	}
+	/** @internal used by QueueHandle */
+	openQueueSocket() {
+		const url = this.#options.buildQueueWsUrl?.() ?? `${this.#options.baseUrl.replace(/^http/, "ws")}/queue/ws`;
+		return new this.#WebSocketImpl(url);
+	}
+	async #call(method, path, body) {
+		const res = await this.#fetch(`${this.#options.baseUrl}${path}`, {
+			method,
+			headers: {
+				...body !== void 0 ? { "content-type": "application/json" } : {},
+				...this.#options.headers
+			},
+			body: body !== void 0 ? JSON.stringify(body) : void 0
+		});
+		const payload = await res.json().catch(() => ({}));
+		if (!res.ok) throw new Error(payload.error ?? `${method} ${path} failed with ${res.status}`);
+		return payload;
+	}
+};
+//#endregion
+export { QueueHandle, SessionHandle, WorkerDeckClient };
+
+//# sourceMappingURL=index.mjs.map

package/build/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["#client","#options","#lastSeq","#connectTimer","#connect","#listeners","#sendFrame","#closed","#ws","#outbox","#retries","#emit","#reconnect","#fetch","#WebSocketImpl","#call"],"sources":["../src/index.ts"],"sourcesContent":["import type {\n  AttachedFrame,\n  ClientFrame,\n  CreateJobRequest,\n  CreateProfileRequest,\n  CreateSessionRequest,\n  JobEvent,\n  JobInfo,\n  GetProfileResponse,\n  ListProfilesResponse,\n  ListSessionFilesResponse,\n  PermissionMode,\n  ProfileInfo,\n  QueueServerFrame,\n  QueueStats,\n  ResolvePermissionRequest,\n  SubmitExecutionResultRequest,\n  SubmitExecutionResultResponse,\n  SaveProfileResponse,\n  SdkSessionSummary,\n  ServerFrame,\n  SessionEvent,\n  SessionFileInfo,\n  SessionInfo,\n  ToolCallRequestFrame,\n  ToolExecutionOutput,\n  UpdateProfileRequest,\n} from '@workerdeck/protocol'\n\nexport type ClientOptions = {\n  /** REST base, e.g. \"http://127.0.0.1:8787/v1\". The ws:// URL is derived from it. */\n  baseUrl: string\n  /** Extra headers for REST calls (auth). Browsers can't set WS headers — use\n   * `buildWsUrl` (ticket query param) or cookies for WS auth. */\n  headers?: Record<string, string>\n  /** Override WS URL construction (auth tickets, proxies). */\n  buildWsUrl?: (sessionId: string, afterSeq: number) => string\n  /** Override the queue WS URL (`{baseUrl}/queue/ws` by default). */\n  buildQueueWsUrl?: () => string\n  /** Injectable for non-browser environments/tests. Defaults to globalThis.WebSocket. */\n  WebSocketImpl?: typeof WebSocket\n  fetchImpl?: typeof fetch\n}\n\nexport type AttachOptions = {\n  /** Replay events with seq greater than this. Default 0 (full replay). */\n  afterSeq?: number\n  /** Auto-reconnect with backoff on unexpected disconnects. Default true. */\n  reconnect?: boolean\n}\n\nexport type SessionHandleEvents = {\n  /** Fired on every (re)attach with the server's session snapshot. */\n  attached: AttachedFrame\n  /** Every session event, replayed and live, in seq order. */\n  event: SessionEvent\n  protocolError: string\n  /** WS connectivity: true on open, false on close. */\n  connectionChange: boolean\n  /**\n   * The server is asking this client to execute a tool call in its own sandbox.\n   * Answer with {@link SessionHandle.sendToolCallResult} or\n   * {@link SessionHandle.sendToolCallError}, echoing the same `executionId`.\n   * Ignoring it is safe: the server fails the execution at `expiresAt`.\n   */\n  toolCallRequest: ToolCallRequestFrame\n  /** A bridged call no longer needs an answer (turn interrupted, timed out, or\n   * the session closed) — abandon any work in progress for this executionId. */\n  toolCallCanceled: { executionId: string; reason: string }\n}\n\ntype Listener<T> = (payload: T) => void\n\nexport class SessionHandle {\n  readonly sessionId: string\n  #client: WorkerDeckClient\n  #options: Required<Pick<AttachOptions, 'reconnect'>> & AttachOptions\n  #ws: WebSocket | undefined\n  #listeners = new Map<keyof SessionHandleEvents, Set<Listener<never>>>()\n  #lastSeq: number\n  #closed = false\n  #retries = 0\n  #outbox: string[] = []\n  #connectTimer: ReturnType<typeof setTimeout> | undefined\n\n  constructor(client: WorkerDeckClient, sessionId: string, options: AttachOptions = {}) {\n    this.#client = client\n    this.sessionId = sessionId\n    this.#options = { reconnect: true, ...options }\n    this.#lastSeq = options.afterSeq ?? 0\n    // Deferred a tick so an attach that is detached in the same tick (React\n    // StrictMode's throwaway dev mount) never opens a socket — closing a\n    // WebSocket mid-upgrade breaks proxies (vite logs EPIPE) for nothing.\n    this.#connectTimer = setTimeout(() => this.#connect(), 0)\n  }\n\n  get lastSeq(): number {\n    return this.#lastSeq\n  }\n\n  on<K extends keyof SessionHandleEvents>(\n    kind: K,\n    listener: Listener<SessionHandleEvents[K]>,\n  ): () => void {\n    let set = this.#listeners.get(kind)\n    if (!set) {\n      set = new Set()\n      this.#listeners.set(kind, set)\n    }\n    set.add(listener as Listener<never>)\n    return () => set.delete(listener as Listener<never>)\n  }\n\n  send(text: string): void {\n    this.#sendFrame({ type: 'user_message', text })\n  }\n\n  approve(requestId: string, updatedInput?: Record<string, unknown>): void {\n    this.#sendFrame({ type: 'permission_decision', requestId, behavior: 'allow', updatedInput })\n  }\n\n  deny(requestId: string, message?: string, interrupt?: boolean): void {\n    this.#sendFrame({ type: 'permission_decision', requestId, behavior: 'deny', message, interrupt })\n  }\n\n  interrupt(): void {\n    this.#sendFrame({ type: 'interrupt' })\n  }\n\n  setPermissionMode(mode: PermissionMode): void {\n    this.#sendFrame({ type: 'set_permission_mode', mode })\n  }\n\n  /** Switch the model for subsequent responses; omit `model` for the default. */\n  setModel(model?: string): void {\n    this.#sendFrame({ type: 'set_model', model })\n  }\n\n  /** Answer a bridged tool call (see the `toolCallRequest` event). */\n  sendToolCallResult(executionId: string, output: ToolExecutionOutput, logs?: string[]): void {\n    this.#sendFrame({ type: 'tool_call_result', executionId, output, logs })\n  }\n\n  /** Report that a bridged tool call could not be executed. The failure is fed\n   * to the model as tool output, so the agent can adapt rather than stall. */\n  sendToolCallError(executionId: string, reason: string, error: string, logs?: string[]): void {\n    this.#sendFrame({ type: 'tool_call_error', executionId, reason, error, logs })\n  }\n\n  /** Ask the server to terminate the session (the handle disconnects too). */\n  closeSession(): void {\n    this.#sendFrame({ type: 'close' })\n    this.detach()\n  }\n\n  /** Disconnect this handle without touching the session. */\n  detach(): void {\n    this.#closed = true\n    clearTimeout(this.#connectTimer)\n    this.#ws?.close()\n    this.#ws = undefined\n  }\n\n  #emit<K extends keyof SessionHandleEvents>(kind: K, payload: SessionHandleEvents[K]): void {\n    const set = this.#listeners.get(kind)\n    if (!set) return\n    for (const listener of set) {\n      try {\n        ;(listener as Listener<SessionHandleEvents[K]>)(payload)\n      } catch {\n        // listener errors must not break the stream\n      }\n    }\n  }\n\n  #sendFrame(frame: ClientFrame): void {\n    const payload = JSON.stringify(frame)\n    // readyState 1 === OPEN (avoid touching the WebSocket global; impl may be injected)\n    if (this.#ws && this.#ws.readyState === 1) this.#ws.send(payload)\n    else this.#outbox.push(payload)\n  }\n\n  #connect(): void {\n    if (this.#closed) return\n    const ws = this.#client.openSocket(this.sessionId, this.#lastSeq)\n    this.#ws = ws\n    ws.onopen = () => {\n      this.#retries = 0\n      this.#emit('connectionChange', true)\n      for (const payload of this.#outbox.splice(0)) ws.send(payload)\n    }\n    ws.onmessage = (msg: MessageEvent) => {\n      const frame = JSON.parse(String(msg.data)) as ServerFrame\n      if (frame.type === 'attached') {\n        this.#emit('attached', frame)\n      } else if (frame.type === 'event') {\n        if (frame.event.seq <= this.#lastSeq) return\n        this.#lastSeq = frame.event.seq\n        this.#emit('event', frame.event)\n      } else if (frame.type === 'tool_call_request') {\n        this.#emit('toolCallRequest', frame)\n      } else if (frame.type === 'tool_call_canceled') {\n        this.#emit('toolCallCanceled', { executionId: frame.executionId, reason: frame.reason })\n      } else if (frame.type === 'protocol_error') {\n        this.#emit('protocolError', frame.message)\n      }\n    }\n    ws.onclose = () => {\n      this.#emit('connectionChange', false)\n      if (this.#closed || !this.#options.reconnect) return\n      const delay = Math.min(500 * 2 ** this.#retries++, 10_000)\n      this.#connectTimer = setTimeout(() => this.#connect(), delay)\n    }\n    ws.onerror = () => {\n      // onclose follows; reconnect handled there\n    }\n  }\n}\n\nexport type QueueHandleEvents = {\n  /** Fired on every (re)attach with the server's current stats. */\n  attached: QueueStats\n  /** Every job lifecycle/progress event, live. */\n  event: JobEvent\n  /** Refreshed stats pushed after job lifecycle changes. */\n  stats: QueueStats\n  /** WS connectivity: true on open, false on close. */\n  connectionChange: boolean\n}\n\n/**\n * Live view of the server's job queue over `{basePath}/queue/ws`. The stream is\n * read-only — submit/cancel stay on the REST methods. There is no replay: on\n * (re)connect, re-list jobs and treat the stream as updates from there.\n */\nexport class QueueHandle {\n  #client: WorkerDeckClient\n  #reconnect: boolean\n  #ws: WebSocket | undefined\n  #listeners = new Map<keyof QueueHandleEvents, Set<Listener<never>>>()\n  #closed = false\n  #retries = 0\n  #connectTimer: ReturnType<typeof setTimeout> | undefined\n\n  constructor(client: WorkerDeckClient, options: { reconnect?: boolean } = {}) {\n    this.#client = client\n    this.#reconnect = options.reconnect ?? true\n    // Deferred a tick for the same StrictMode reason as SessionHandle.\n    this.#connectTimer = setTimeout(() => this.#connect(), 0)\n  }\n\n  on<K extends keyof QueueHandleEvents>(\n    kind: K,\n    listener: Listener<QueueHandleEvents[K]>,\n  ): () => void {\n    let set = this.#listeners.get(kind)\n    if (!set) {\n      set = new Set()\n      this.#listeners.set(kind, set)\n    }\n    set.add(listener as Listener<never>)\n    return () => set.delete(listener as Listener<never>)\n  }\n\n  detach(): void {\n    this.#closed = true\n    clearTimeout(this.#connectTimer)\n    this.#ws?.close()\n    this.#ws = undefined\n  }\n\n  #emit<K extends keyof QueueHandleEvents>(kind: K, payload: QueueHandleEvents[K]): void {\n    const set = this.#listeners.get(kind)\n    if (!set) return\n    for (const listener of set) {\n      try {\n        ;(listener as Listener<QueueHandleEvents[K]>)(payload)\n      } catch {\n        // listener errors must not break the stream\n      }\n    }\n  }\n\n  #connect(): void {\n    if (this.#closed) return\n    const ws = this.#client.openQueueSocket()\n    this.#ws = ws\n    ws.onopen = () => {\n      this.#retries = 0\n      this.#emit('connectionChange', true)\n    }\n    ws.onmessage = (msg: MessageEvent) => {\n      const frame = JSON.parse(String(msg.data)) as QueueServerFrame\n      if (frame.type === 'queue_attached') {\n        this.#emit('attached', frame.stats)\n        this.#emit('stats', frame.stats)\n      } else if (frame.type === 'job_event') {\n        this.#emit('event', frame.event)\n      } else if (frame.type === 'queue_stats') {\n        this.#emit('stats', frame.stats)\n      }\n    }\n    ws.onclose = () => {\n      this.#emit('connectionChange', false)\n      if (this.#closed || !this.#reconnect) return\n      const delay = Math.min(500 * 2 ** this.#retries++, 10_000)\n      this.#connectTimer = setTimeout(() => this.#connect(), delay)\n    }\n    ws.onerror = () => {\n      // onclose follows; reconnect handled there\n    }\n  }\n}\n\nexport class WorkerDeckClient {\n  #options: ClientOptions\n  #fetch: typeof fetch\n  #WebSocketImpl: typeof WebSocket\n\n  constructor(options: ClientOptions) {\n    this.#options = options\n    this.#fetch = options.fetchImpl ?? fetch.bind(globalThis)\n    this.#WebSocketImpl = options.WebSocketImpl ?? WebSocket\n  }\n\n  async createSession(request: CreateSessionRequest): Promise<SessionInfo> {\n    const body = await this.#call('POST', '/sessions', request)\n    return (body as { session: SessionInfo }).session\n  }\n\n  async listSessions(): Promise<SessionInfo[]> {\n    const body = await this.#call('GET', '/sessions')\n    return (body as { sessions: SessionInfo[] }).sessions\n  }\n\n  async getSession(id: string): Promise<SessionInfo> {\n    const body = await this.#call('GET', `/sessions/${encodeURIComponent(id)}`)\n    return (body as { session: SessionInfo }).session\n  }\n\n  async deleteSession(id: string): Promise<SessionInfo> {\n    const body = await this.#call('DELETE', `/sessions/${encodeURIComponent(id)}`)\n    return (body as { session: SessionInfo }).session\n  }\n\n  /** List the files currently in a session's scratch filesystem (deliverables the\n   * agent wrote; see the `file_delivered` event). 404s when the session's engine\n   * has no file store (Claude-engine sessions). */\n  async listSessionFiles(sessionId: string): Promise<SessionFileInfo[]> {\n    const body = await this.#call('GET', `/sessions/${encodeURIComponent(sessionId)}/files`)\n    return (body as ListSessionFilesResponse).files\n  }\n\n  /** Download one session file as text. */\n  async fetchSessionFile(sessionId: string, path: string): Promise<string> {\n    const res = await this.#fetch(this.sessionFileUrl(sessionId, path), {\n      headers: this.#options.headers,\n    })\n    if (!res.ok) {\n      const payload = (await res.json().catch(() => ({}))) as { error?: string }\n      throw new Error(payload.error ?? `GET file failed with ${res.status}`)\n    }\n    return await res.text()\n  }\n\n  /** Direct download URL for a session file (e.g. an <a download> href). Carries\n   * no headers — on authenticated servers, use fetchSessionFile instead. */\n  sessionFileUrl(sessionId: string, path: string): string {\n    const encoded = path\n      .split('/')\n      .filter(Boolean)\n      .map(encodeURIComponent)\n      .join('/')\n    return `${this.#options.baseUrl}/sessions/${encodeURIComponent(sessionId)}/files/${encoded}`\n  }\n\n  /** Resolve a pending permission over REST — the remote-controller counterpart of the\n   * WS `permission_decision` command (e.g. answering a job's AskUserQuestion from a\n   * webhook consumer; the request rides on job_progress deliveries). Throws if the\n   * request is unknown, already resolved, or expired. */\n  async resolvePermission(\n    sessionId: string,\n    requestId: string,\n    decision: ResolvePermissionRequest,\n  ): Promise<void> {\n    await this.#call(\n      'POST',\n      `/sessions/${encodeURIComponent(sessionId)}/permissions/${encodeURIComponent(requestId)}`,\n      decision,\n    )\n  }\n\n  /**\n   * Deliver the result of a deferred tool execution — the callback a remote\n   * worker (or a human) makes when the work a session parked on is done. The\n   * session is rehydrated if its runner was torn down, and the agent loop\n   * continues with this as the tool's output.\n   *\n   * Applied idempotently by `executionId`: a duplicate, or one racing the\n   * execution watchdog, resolves with `applied: false` instead of applying twice.\n   * Throws (404) when no session is waiting on that id.\n   */\n  async submitExecutionResult(\n    executionId: string,\n    result: SubmitExecutionResultRequest,\n  ): Promise<SubmitExecutionResultResponse> {\n    return (await this.#call(\n      'POST',\n      `/executions/${encodeURIComponent(executionId)}/result`,\n      result,\n    )) as SubmitExecutionResultResponse\n  }\n\n  /** List the profiles (named Claude Code config dirs) this server declares, filtered\n   * to what the caller may use. Feed a result's `name` to createSession({ profile }).\n   * Servers predating profiles 404 here — catch and treat as none declared. */\n  /** The profiles this caller may use, plus whether it may create new ones.\n   * Each profile carries `managed: true` when it is store-backed and therefore\n   * editable; profiles declared in server options are not. */\n  async listProfiles(): Promise<ListProfilesResponse> {\n    return (await this.#call('GET', '/profiles')) as ListProfilesResponse\n  }\n\n  /** One profile plus a fresh, view-only snapshot of its config directory (settings,\n   * skills, agents, commands — env var names only, never values). */\n  async getProfile(name: string): Promise<GetProfileResponse> {\n    return (await this.#call('GET', `/profiles/${encodeURIComponent(name)}`)) as GetProfileResponse\n  }\n\n  /**\n   * Create a managed profile. Requires a server with a profile store and a\n   * principal allowed to manage profiles; 409 if the name is already taken by a\n   * managed or a startup-declared profile.\n   */\n  async createProfile(profile: CreateProfileRequest): Promise<ProfileInfo> {\n    const body = await this.#call('POST', '/profiles', profile)\n    return (body as SaveProfileResponse).profile\n  }\n\n  /** Merge into a managed profile. The name is the route: profiles cannot be\n   * renamed, since sessions and jobs are already pinned to the old one. */\n  async updateProfile(name: string, patch: UpdateProfileRequest): Promise<ProfileInfo> {\n    const body = await this.#call('PATCH', `/profiles/${encodeURIComponent(name)}`, patch)\n    return (body as SaveProfileResponse).profile\n  }\n\n  /** Delete a managed profile. Startup-declared profiles are refused (403) —\n   * they live in the server's options. */\n  async deleteProfile(name: string): Promise<void> {\n    await this.#call('DELETE', `/profiles/${encodeURIComponent(name)}`)\n  }\n\n  /** List the Agent SDK's on-disk sessions (for resume across server restarts).\n   * Feed a result's `sessionId` to createSession({ resume }). */\n  async listSdkSessions(params?: {\n    dir?: string\n    limit?: number\n    offset?: number\n  }): Promise<SdkSessionSummary[]> {\n    const search = new URLSearchParams()\n    if (params?.dir) search.set('dir', params.dir)\n    if (params?.limit !== undefined) search.set('limit', String(params.limit))\n    if (params?.offset !== undefined) search.set('offset', String(params.offset))\n    const qs = search.size > 0 ? `?${search.toString()}` : ''\n    const body = await this.#call('GET', `/sdk-sessions${qs}`)\n    return (body as { sdkSessions: SdkSessionSummary[] }).sdkSessions\n  }\n\n  // -- Job queue (requires the server to be configured with `queue`) ----------\n\n  /** Schedule a one-shot run. The returned job's `sessionId` (once running) can be\n   * fed to `attach()` to watch the run live. */\n  async createJob(request: CreateJobRequest): Promise<JobInfo> {\n    const body = await this.#call('POST', '/jobs', request)\n    return (body as { job: JobInfo }).job\n  }\n\n  async listJobs(): Promise<JobInfo[]> {\n    const body = await this.#call('GET', '/jobs')\n    return (body as { jobs: JobInfo[] }).jobs\n  }\n\n  async getJob(id: string): Promise<JobInfo> {\n    const body = await this.#call('GET', `/jobs/${encodeURIComponent(id)}`)\n    return (body as { job: JobInfo }).job\n  }\n\n  /** Cancel a queued or running job. */\n  async cancelJob(id: string): Promise<JobInfo> {\n    const body = await this.#call('DELETE', `/jobs/${encodeURIComponent(id)}`)\n    return (body as { job: JobInfo }).job\n  }\n\n  async queueStats(): Promise<QueueStats> {\n    const body = await this.#call('GET', '/queue')\n    return (body as { stats: QueueStats }).stats\n  }\n\n  attach(sessionId: string, options?: AttachOptions): SessionHandle {\n    return new SessionHandle(this, sessionId, options)\n  }\n\n  /** Stream the job queue live (requires the server to be configured with `queue`).\n   * Servers without a queue refuse the socket — check REST first or expect retries. */\n  attachQueue(options?: { reconnect?: boolean }): QueueHandle {\n    return new QueueHandle(this, options)\n  }\n\n  /** @internal used by SessionHandle */\n  openSocket(sessionId: string, afterSeq: number): WebSocket {\n    const url =\n      this.#options.buildWsUrl?.(sessionId, afterSeq) ??\n      `${this.#options.baseUrl.replace(/^http/, 'ws')}/sessions/${encodeURIComponent(sessionId)}/ws?afterSeq=${afterSeq}`\n    return new this.#WebSocketImpl(url)\n  }\n\n  /** @internal used by QueueHandle */\n  openQueueSocket(): WebSocket {\n    const url =\n      this.#options.buildQueueWsUrl?.() ??\n      `${this.#options.baseUrl.replace(/^http/, 'ws')}/queue/ws`\n    return new this.#WebSocketImpl(url)\n  }\n\n  async #call(method: string, path: string, body?: unknown): Promise<unknown> {\n    const res = await this.#fetch(`${this.#options.baseUrl}${path}`, {\n      method,\n      headers: {\n        ...(body !== undefined ? { 'content-type': 'application/json' } : {}),\n        ...this.#options.headers,\n      },\n      body: body !== undefined ? JSON.stringify(body) : undefined,\n    })\n    const payload = (await res.json().catch(() => ({}))) as { error?: string }\n    if (!res.ok) {\n      throw new Error(payload.error ?? `${method} ${path} failed with ${res.status}`)\n    }\n    return payload\n  }\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@workerdeck/client",
+  "version": "0.6.0",
+  "type": "module",
+  "description": "Typed WorkerDeck protocol client for browsers and Node: REST session management plus a WebSocket attach with auto-reconnect and replay-from-last-seq. Uses the platform's fetch and WebSocket; zero runtime deps.",
+  "license": "MIT",
+  "main": "./build/index.mjs",
+  "types": "./build/index.d.mts",
+  "files": [
+    "build"
+  ],
+  "exports": {
+    ".": {
+      "@workerdeck/source": "./src/index.ts",
+      "types": "./build/index.d.mts",
+      "default": "./build/index.mjs"
+    }
+  },
+  "dependencies": {
+    "@workerdeck/protocol": "0.6.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "@types/ws": "^8.18.1",
+    "rimraf": "^6.1.3",
+    "tsdown": "^0.21.10",
+    "vitest": "^3.2.7",
+    "ws": "^8.21.1",
+    "@workerdeck/server": "0.6.0",
+    "@workerdeck/core": "0.6.0"
+  },
+  "author": "Tobias Strebitzer",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/workerdeck/workerdeck.git",
+    "directory": "packages/client"
+  },
+  "homepage": "https://workerdeck.github.io/workerdeck/",
+  "bugs": "https://github.com/workerdeck/workerdeck/issues",
+  "keywords": [
+    "claude",
+    "claude-code",
+    "anthropic",
+    "agent",
+    "client",
+    "websocket",
+    "browser"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "clean": "rimraf build",
+    "build": "tsdown",
+    "typecheck": "tsgo -p tsconfig.json && tsgo -p tsconfig.test.json",
+    "test": "vitest run"
+  }
+}