@pragma-sh/sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1634 @@
+var import_node_module = require("node:module");
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  runtimeAgentId: () => runtimeAgentId,
+  reportStopped: () => reportStopped,
+  reportStarted: () => reportStarted,
+  reportSessionName: () => reportSessionName,
+  reportMessage: () => reportMessage,
+  reportCleared: () => reportCleared,
+  reportAttention: () => reportAttention,
+  readEnv: () => readEnv,
+  hasPragmaEnvironment: () => hasPragmaEnvironment,
+  bytesToBase64: () => bytesToBase64,
+  base64ToBytes: () => base64ToBytes,
+  awaitAgentDecision: () => awaitAgentDecision,
+  awaitAgentAnswer: () => awaitAgentAnswer,
+  WorkspaceClient: () => WorkspaceClient,
+  WhiteboardsClient: () => WhiteboardsClient,
+  ThemeClient: () => ThemeClient,
+  ScratchpadsClient: () => ScratchpadsClient,
+  PushClient: () => PushClient,
+  PragmaTransportError: () => PragmaTransportError,
+  PragmaGatewayError: () => PragmaGatewayError,
+  PragmaClient: () => PragmaClient,
+  PRAGMA_ENV_KEYS: () => PRAGMA_ENV_KEYS,
+  HealthClient: () => HealthClient,
+  FanoutsClient: () => FanoutsClient,
+  AssetsClient: () => AssetsClient
+});
+module.exports = __toCommonJS(exports_src);
+
+// src/env.ts
+var PRAGMA_ENV_KEYS = {
+  gatewayUrl: "PRAGMA_GATEWAY_URL",
+  gatewayToken: "PRAGMA_GATEWAY_TOKEN",
+  tabId: "PRAGMA_TAB_ID",
+  worktreeId: "PRAGMA_WORKTREE_ID"
+};
+function readEnv(name, env) {
+  const globalProcess = globalThis.process;
+  return env?.[name] ?? globalProcess?.env?.[name];
+}
+function hasPragmaEnvironment(env) {
+  return Boolean(readEnv(PRAGMA_ENV_KEYS.gatewayUrl, env) && readEnv(PRAGMA_ENV_KEYS.gatewayToken, env) && readEnv(PRAGMA_ENV_KEYS.tabId, env) && readEnv(PRAGMA_ENV_KEYS.worktreeId, env));
+}
+
+// src/routes.ts
+var routes = {
+  health: "/v1/health",
+  version: "/v1/version",
+  rpc: (method) => `/v1/rpc/${encodeURIComponent(method)}`,
+  sessions: "/v1/sessions",
+  sessionEvents: (id) => `/v1/sessions/${encodeURIComponent(id)}/events`,
+  sessionInput: (id) => `/v1/sessions/${encodeURIComponent(id)}/input`,
+  sessionResize: (id) => `/v1/sessions/${encodeURIComponent(id)}/resize`,
+  session: (id) => `/v1/sessions/${encodeURIComponent(id)}`,
+  agentReports: "/v1/agents/reports",
+  agentMessages: "/v1/agents/messages",
+  agentAnswers: "/v1/agents/answers",
+  agentDecisions: "/v1/agents/decisions",
+  agentInputs: "/v1/agents/inputs",
+  agentInterrupts: "/v1/agents/interrupts",
+  agentCatalog: "/v1/agents/catalog",
+  agentEvents: "/v1/agents/events",
+  asset: (hash) => `/v1/assets/${encodeURIComponent(hash)}`,
+  theme: "/v1/theme",
+  scratchpads: "/v1/scratchpads",
+  agentsSeen: (tabId) => `/v1/tabs/${encodeURIComponent(tabId)}/agents/seen`,
+  subscription: (event) => `/v1/subscriptions/${encodeURIComponent(event)}`,
+  control: (method) => `/v1/control/${encodeURIComponent(method)}`,
+  pushTokens: "/v1/push/tokens",
+  pushTest: "/v1/push/test",
+  pushPresence: "/v1/push/presence"
+};
+
+// src/errors.ts
+class PragmaGatewayError extends Error {
+  code;
+  httpStatus;
+  details;
+  cause;
+  constructor(message, info) {
+    super(message, { cause: info.cause });
+    this.name = "PragmaGatewayError";
+    this.code = info.code;
+    this.httpStatus = info.httpStatus;
+    this.details = info.details;
+    this.cause = info.cause;
+  }
+}
+
+class PragmaTransportError extends Error {
+  cause;
+  constructor(message, cause) {
+    super(message, { cause });
+    this.name = "PragmaTransportError";
+    this.cause = cause;
+  }
+}
+
+// src/streaming.ts
+async function* ndjsonStream(response, signal) {
+  if (!response.body) {
+    throw new PragmaTransportError("gateway response is not streamable");
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder;
+  let buffered = "";
+  const onAbort = () => {
+    reader.cancel();
+  };
+  signal?.addEventListener("abort", onAbort, { once: true });
+  try {
+    while (true) {
+      if (signal?.aborted) {
+        return;
+      }
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      buffered += decoder.decode(value, { stream: true });
+      let newline = buffered.indexOf(`
+`);
+      while (newline >= 0) {
+        const line = buffered.slice(0, newline).trim();
+        buffered = buffered.slice(newline + 1);
+        if (line) {
+          yield JSON.parse(line);
+        }
+        newline = buffered.indexOf(`
+`);
+      }
+    }
+    buffered += decoder.decode();
+    if (buffered.trim()) {
+      yield JSON.parse(buffered);
+    }
+  } finally {
+    signal?.removeEventListener("abort", onAbort);
+    await reader.cancel().catch(() => {
+      return;
+    });
+  }
+}
+
+// src/transport.ts
+class Transport {
+  baseUrl;
+  token;
+  fetch;
+  headers;
+  constructor(config = {}) {
+    const { baseUrl, token } = requireGatewayConfig(config);
+    this.baseUrl = baseUrl;
+    this.token = token;
+    this.fetch = requireFetch(config.fetch);
+    this.headers = config.headers ?? {};
+  }
+  async request(path, options = {}) {
+    const response = await this.raw(path, options);
+    if (response.status === 204 || response.status === 202) {
+      return;
+    }
+    return parseJson(response);
+  }
+  async raw(path, options = {}) {
+    const headers = {
+      ...this.headers,
+      ...options.headers,
+      authorization: `Bearer ${this.token}`
+    };
+    let body;
+    if (options.rawBody) {
+      body = options.rawBody;
+    } else if (options.body !== undefined) {
+      headers["content-type"] = headers["content-type"] ?? "application/json";
+      body = JSON.stringify(options.body);
+    }
+    let response;
+    try {
+      response = await this.fetch(urlFor(this.baseUrl, path), {
+        method: options.method ?? (body ? "POST" : "GET"),
+        headers,
+        body,
+        signal: options.signal
+      });
+    } catch (error) {
+      throw new PragmaTransportError("failed to reach Pragma gateway", error);
+    }
+    if (!response.ok) {
+      throw await gatewayError(response);
+    }
+    return response;
+  }
+}
+function requireGatewayConfig(config) {
+  const baseUrl = stripTrailingSlash(config.baseUrl ?? readEnv(PRAGMA_ENV_KEYS.gatewayUrl) ?? "");
+  const token = config.token ?? readEnv(PRAGMA_ENV_KEYS.gatewayToken) ?? "";
+  if (!baseUrl || !token) {
+    throw new PragmaTransportError("Pragma gateway baseUrl and token are required");
+  }
+  return { baseUrl, token };
+}
+function requireFetch(fetch) {
+  const resolved = fetch ?? globalThis.fetch?.bind(globalThis);
+  if (!resolved) {
+    throw new PragmaTransportError("global fetch is not available");
+  }
+  return resolved;
+}
+function urlFor(baseUrl, path) {
+  return `${stripTrailingSlash(baseUrl)}${path.startsWith("/") ? path : `/${path}`}`;
+}
+async function parseJson(response) {
+  try {
+    return await response.json();
+  } catch (error) {
+    throw new PragmaTransportError("gateway returned non-JSON response", error);
+  }
+}
+async function gatewayError(response) {
+  let body = {};
+  try {
+    body = await response.json();
+  } catch (error) {
+    throw new PragmaTransportError("gateway returned non-JSON error response", error);
+  }
+  return new PragmaGatewayError(body.message ?? `gateway returned ${response.status}`, {
+    code: body.code ?? "internal",
+    httpStatus: response.status,
+    details: body.details
+  });
+}
+function stripTrailingSlash(value) {
+  return value.replace(/\/+$/, "");
+}
+
+// src/agents-client.ts
+class AgentsClient {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  report(payload, options = {}) {
+    return this.transport.request(routes.agentReports, {
+      method: "POST",
+      body: payload,
+      signal: options.signal
+    });
+  }
+  reportMessage(payload, options = {}) {
+    return this.transport.request(routes.agentMessages, {
+      method: "POST",
+      body: payload,
+      signal: options.signal
+    });
+  }
+  reportDecision(payload, options = {}) {
+    return this.transport.request(routes.agentDecisions, {
+      method: "POST",
+      body: payload,
+      signal: options.signal
+    });
+  }
+  reportAnswer(payload, options = {}) {
+    return this.transport.request(routes.agentAnswers, {
+      method: "POST",
+      body: payload,
+      signal: options.signal
+    });
+  }
+  reportInput(payload, options = {}) {
+    return this.transport.request(routes.agentInputs, {
+      method: "POST",
+      body: payload,
+      signal: options.signal
+    });
+  }
+  reportInterrupt(payload, options = {}) {
+    return this.transport.request(routes.agentInterrupts, {
+      method: "POST",
+      body: payload,
+      signal: options.signal
+    });
+  }
+  reportStarted(options) {
+    return reportWithClient(this, options, "running", null);
+  }
+  reportStopped(options) {
+    return reportWithClient(this, options, "done", null);
+  }
+  reportAttention(options) {
+    return reportWithClient(this, options, "attention", options.kind ?? "question");
+  }
+  reportCleared(options) {
+    return reportWithClient(this, options, "cleared", null);
+  }
+  reportSessionName(options) {
+    return reportWithClient(this, options, null, null, options.name);
+  }
+  catalog(options = {}) {
+    return this.transport.request(routes.agentCatalog, {
+      method: "GET",
+      signal: options.signal
+    });
+  }
+  launch(payload, options = {}) {
+    return this.transport.request(routes.control("agentSessionLaunch"), {
+      method: "POST",
+      body: payload,
+      signal: options.signal
+    });
+  }
+  markAgentsSeen(payload, options = {}) {
+    return this.transport.request(routes.agentsSeen(payload.tabId), {
+      method: "POST",
+      body: {},
+      signal: options.signal
+    });
+  }
+  async connect(options) {
+    const { agent, tabId, worktreeId } = options;
+    const controller = new AbortController;
+    const onAbort = () => controller.abort();
+    options.signal?.addEventListener("abort", onAbort);
+    const readStream = this.readStream.bind(this);
+    async function* iterate() {
+      try {
+        for await (const event of readStream({ signal: controller.signal })) {
+          if (matchesAgentTab(event, agent, tabId)) {
+            yield event;
+          }
+        }
+      } finally {
+        options.signal?.removeEventListener("abort", onAbort);
+      }
+    }
+    const connection = {
+      [Symbol.asyncIterator]: iterate,
+      send: (text, sendOptions = {}) => this.reportInput({
+        agent,
+        worktreeId,
+        tabId,
+        text,
+        ...sendOptions.requestId ? { requestId: sendOptions.requestId } : {}
+      }, { signal: controller.signal }),
+      answer: (requestId, reply) => this.reportAnswer({
+        agent,
+        worktreeId,
+        tabId,
+        requestId,
+        dismissed: reply === null,
+        ...reply !== null ? { answer: reply } : {}
+      }, { signal: controller.signal }),
+      decide: (requestId, approved) => this.reportDecision({ agent, worktreeId, tabId, requestId, approved }, { signal: controller.signal }),
+      interrupt: (requestId) => this.reportInterrupt({
+        agent,
+        worktreeId,
+        tabId,
+        ...requestId ? { requestId } : {}
+      }, { signal: controller.signal }),
+      close: () => controller.abort()
+    };
+    if (options.prompt !== undefined) {
+      await connection.send(options.prompt);
+    }
+    return connection;
+  }
+  async* readStream(options = {}) {
+    const response = await this.transport.raw(routes.agentEvents, { signal: options.signal });
+    yield* ndjsonStream(response, options.signal);
+  }
+  async awaitDecision(params) {
+    const controller = new AbortController;
+    const onAbort = () => controller.abort();
+    params.signal?.addEventListener("abort", onAbort);
+    const timer = params.timeoutMs && params.timeoutMs > 0 ? setTimeout(() => controller.abort(), params.timeoutMs) : undefined;
+    try {
+      for await (const event of this.readStream({ signal: controller.signal })) {
+        if (event.type === "agentDecision" && event.decision.requestId === params.requestId && event.decision.agent === params.agent) {
+          return event.decision.approved;
+        }
+      }
+      return null;
+    } catch {
+      return null;
+    } finally {
+      if (timer) {
+        clearTimeout(timer);
+      }
+      params.signal?.removeEventListener("abort", onAbort);
+    }
+  }
+  async awaitAnswer(params) {
+    const controller = new AbortController;
+    const onAbort = () => controller.abort();
+    params.signal?.addEventListener("abort", onAbort);
+    const timer = params.timeoutMs && params.timeoutMs > 0 ? setTimeout(() => controller.abort(), params.timeoutMs) : undefined;
+    try {
+      for await (const event of this.readStream({ signal: controller.signal })) {
+        if (event.type === "agentAnswer" && event.answer.requestId === params.requestId && event.answer.agent === params.agent) {
+          return event.answer.dismissed ? null : event.answer.answer ?? "";
+        }
+      }
+      return null;
+    } catch {
+      return null;
+    } finally {
+      if (timer) {
+        clearTimeout(timer);
+      }
+      params.signal?.removeEventListener("abort", onAbort);
+    }
+  }
+}
+function matchesAgentTab(event, agent, tabId) {
+  switch (event.type) {
+    case "agent":
+      return event.agent === agent && event.tabId === tabId;
+    case "agentMessage":
+      return event.message.agent === agent && event.message.tabId === tabId;
+    case "agentDecision":
+      return event.decision.agent === agent && event.decision.tabId === tabId;
+    case "agentAnswer":
+      return event.answer.agent === agent && event.answer.tabId === tabId;
+    case "agentInput":
+      return event.input.agent === agent && event.input.tabId === tabId;
+    case "agentInterrupt":
+      return event.interrupt.agent === agent && event.interrupt.tabId === tabId;
+  }
+}
+function reportStarted(options) {
+  return reportWithStatus(options, "running", null);
+}
+function reportStopped(options) {
+  return reportWithStatus(options, "done", null);
+}
+function reportAttention(options) {
+  return reportWithStatus(options, "attention", options.kind ?? "question");
+}
+function reportCleared(options) {
+  return reportWithStatus(options, "cleared", null);
+}
+function reportSessionName(options) {
+  return reportWithStatus(options, null, null, options.name);
+}
+async function reportMessage(options) {
+  if (!options.client && !hasPragmaEnvironment(options.env)) {
+    return;
+  }
+  const agents = options.client?.agents ?? new AgentsClient(new Transport({
+    baseUrl: readEnv(PRAGMA_ENV_KEYS.gatewayUrl, options.env),
+    token: readEnv(PRAGMA_ENV_KEYS.gatewayToken, options.env)
+  }));
+  await reportMessageWithClient(agents, options);
+}
+async function awaitAgentDecision(options) {
+  if (!options.client && !hasPragmaEnvironment(options.env)) {
+    return null;
+  }
+  const agents = options.client?.agents ?? new AgentsClient(new Transport({
+    baseUrl: readEnv(PRAGMA_ENV_KEYS.gatewayUrl, options.env),
+    token: readEnv(PRAGMA_ENV_KEYS.gatewayToken, options.env)
+  }));
+  return agents.awaitDecision({
+    agent: options.agent,
+    requestId: options.requestId,
+    timeoutMs: options.timeoutMs,
+    signal: options.signal
+  });
+}
+async function awaitAgentAnswer(options) {
+  if (!options.client && !hasPragmaEnvironment(options.env)) {
+    return null;
+  }
+  const agents = options.client?.agents ?? new AgentsClient(new Transport({
+    baseUrl: readEnv(PRAGMA_ENV_KEYS.gatewayUrl, options.env),
+    token: readEnv(PRAGMA_ENV_KEYS.gatewayToken, options.env)
+  }));
+  return agents.awaitAnswer({
+    agent: options.agent,
+    requestId: options.requestId,
+    timeoutMs: options.timeoutMs,
+    signal: options.signal
+  });
+}
+async function reportWithStatus(options, status, attentionKind, sessionName) {
+  if (!options.client && !hasPragmaEnvironment(options.env)) {
+    return;
+  }
+  const agents = options.client?.agents ?? new AgentsClient(new Transport({
+    baseUrl: readEnv(PRAGMA_ENV_KEYS.gatewayUrl, options.env),
+    token: readEnv(PRAGMA_ENV_KEYS.gatewayToken, options.env)
+  }));
+  await reportWithClient(agents, options, status, attentionKind, sessionName);
+}
+async function reportWithClient(agents, options, status, attentionKind, sessionName) {
+  const worktreeId = options.worktreeId ?? readEnv(PRAGMA_ENV_KEYS.worktreeId, options.env);
+  const tabId = readEnv(PRAGMA_ENV_KEYS.tabId, options.env);
+  if (!worktreeId || !tabId) {
+    return;
+  }
+  await agents.report(reportPayload(options, { worktreeId, tabId }, status, attentionKind, sessionName), { signal: options.signal });
+}
+function reportPayload(options, routing, status, attentionKind, sessionName) {
+  return {
+    agent: options.agent,
+    worktreeId: routing.worktreeId,
+    tabId: routing.tabId,
+    status,
+    attentionKind,
+    ...sessionName ? { sessionName } : {},
+    ...options.command ? { command: options.command } : {},
+    ...options.question ? { question: options.question } : {},
+    ...options.options && options.options.length > 0 ? { options: options.options } : {},
+    ...options.questions && options.questions.length > 0 ? { questions: options.questions } : {},
+    ...options.requestId ? { requestId: options.requestId } : {}
+  };
+}
+async function reportMessageWithClient(agents, options) {
+  const worktreeId = options.message.worktreeId ?? options.worktreeId ?? readEnv(PRAGMA_ENV_KEYS.worktreeId, options.env);
+  const tabId = options.message.tabId ?? readEnv(PRAGMA_ENV_KEYS.tabId, options.env);
+  if (!worktreeId || !tabId) {
+    return;
+  }
+  await agents.reportMessage({
+    ...options.message,
+    agent: options.message.agent ?? options.agent,
+    worktreeId,
+    tabId
+  }, { signal: options.signal });
+}
+
+// src/encoding.ts
+var BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function bytesToBase64(bytes) {
+  let output = "";
+  for (let index = 0;index < bytes.length; index += 3) {
+    const first = bytes[index] ?? 0;
+    const second = bytes[index + 1] ?? 0;
+    const third = bytes[index + 2] ?? 0;
+    output += BASE64[first >> 2];
+    output += BASE64[(first & 3) << 4 | second >> 4];
+    output += index + 1 < bytes.length ? BASE64[(second & 15) << 2 | third >> 6] : "=";
+    output += index + 2 < bytes.length ? BASE64[third & 63] : "=";
+  }
+  return output;
+}
+function base64ToBytes(value) {
+  const clean = value.replace(/\s/g, "");
+  if (clean.length % 4 !== 0) {
+    throw new TypeError("invalid base64 length");
+  }
+  const bytes = [];
+  for (let index = 0;index < clean.length; index += 4) {
+    const chars = [clean[index], clean[index + 1], clean[index + 2], clean[index + 3]];
+    const values = chars.map((char) => char === "=" ? 0 : BASE64.indexOf(char ?? ""));
+    if (values.some((number) => number < 0)) {
+      throw new TypeError("invalid base64 character");
+    }
+    const first = values[0] ?? 0;
+    const second = values[1] ?? 0;
+    const third = values[2] ?? 0;
+    const fourth = values[3] ?? 0;
+    bytes.push(first << 2 | second >> 4);
+    if (chars[2] !== "=") {
+      bytes.push((second & 15) << 4 | third >> 2);
+    }
+    if (chars[3] !== "=") {
+      bytes.push((third & 3) << 6 | fourth);
+    }
+  }
+  return new Uint8Array(bytes);
+}
+
+// src/assets-client.ts
+class AssetsClient {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async fetch(hash, options = {}) {
+    const response = await this.transport.raw(routes.asset(hash), { signal: options.signal });
+    const mime = response.headers.get("content-type") ?? "application/octet-stream";
+    const bytes = new Uint8Array(await response.arrayBuffer());
+    return { bytes, mime };
+  }
+  async toDataUri(hash, options = {}) {
+    const { bytes, mime } = await this.fetch(hash, options);
+    return `data:${mime};base64,${bytesToBase64(bytes)}`;
+  }
+}
+
+// src/events-client.ts
+class EventsClient {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async* subscribe(event, options = {}) {
+    const query = new URLSearchParams;
+    if (options.cursor) {
+      query.set("cursor", options.cursor);
+    }
+    if (options.worktreeId) {
+      query.set("worktreeId", options.worktreeId);
+    }
+    if (options.cwd) {
+      query.set("cwd", options.cwd);
+    }
+    const suffix = query.toString() ? `?${query}` : "";
+    const response = await this.transport.raw(`${routes.subscription(event)}${suffix}`, {
+      signal: options.signal
+    });
+    for await (const line of ndjsonStream(response, options.signal)) {
+      if (line.type === "snapshot" || line.type === "delta") {
+        yield line;
+      }
+    }
+  }
+}
+
+// src/exec-client.ts
+class ExecClient {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  run(payload) {
+    return this.transport.request(routes.rpc("exec"), {
+      body: { ...payload, env: payload.env ?? [], maxConcurrent: payload.maxConcurrent ?? 1 }
+    });
+  }
+}
+
+// src/fanouts-client.ts
+class FanoutsClient {
+  transport;
+  events;
+  constructor(transport, events) {
+    this.transport = transport;
+    this.events = events;
+  }
+  create(request, options = {}) {
+    return this.rpc("create", request, options);
+  }
+  get(reference, options = {}) {
+    return this.rpc("get", reference, options);
+  }
+  async read(request, options = {}) {
+    const result = await this.rpc("read", request, options);
+    return {
+      fanoutId: result.fanoutId,
+      targets: result.targets.map(({ data, ...target }) => ({
+        ...target,
+        raw: base64ToBytes(data)
+      }))
+    };
+  }
+  send(request, options = {}) {
+    return this.rpc("send", request, options);
+  }
+  retry(request, options = {}) {
+    return this.rpc("retry", request, options);
+  }
+  cancel(reference, options = {}) {
+    return this.rpc("cancel", reference, options);
+  }
+  pick(request, options = {}) {
+    return this.rpc("pick", request, options);
+  }
+  async* subscribe(options = {}) {
+    for await (const event of this.events.subscribe("fanouts", { signal: options.signal })) {
+      const narrowed = this.narrow(event);
+      if (!options.fanoutId) {
+        yield narrowed;
+        continue;
+      }
+      yield {
+        ...narrowed,
+        payload: {
+          fanouts: narrowed.payload.fanouts.filter((fanout) => fanout.id === options.fanoutId)
+        }
+      };
+    }
+  }
+  narrow(event) {
+    return {
+      type: event.type,
+      subscription: event.subscription,
+      payload: event.payload ?? { fanouts: [] }
+    };
+  }
+  rpc(action, payload, options) {
+    return this.transport.request(routes.rpc("fanouts"), {
+      method: "POST",
+      body: { action, ...payload },
+      signal: options.signal
+    });
+  }
+}
+
+// src/fs-client.ts
+class FsClient {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  listDir(payload) {
+    return this.rpc("listDir", payload);
+  }
+  createFile(payload) {
+    return this.rpc("createFile", payload);
+  }
+  createFolder(payload) {
+    return this.rpc("createFolder", payload);
+  }
+  pathExists(payload) {
+    return this.rpc("pathExists", payload);
+  }
+  readFile(payload) {
+    return this.rpc("readFile", payload);
+  }
+  writeFile(payload) {
+    return this.rpc("writeFile", payload);
+  }
+  rename(payload) {
+    return this.rpc("rename", payload);
+  }
+  delete(payload) {
+    return this.rpc("delete", payload);
+  }
+  rpc(op, payload) {
+    return this.transport.request(routes.rpc("filesystem"), { body: { op, ...payload } });
+  }
+}
+
+// src/git-client.ts
+class GitClient {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  worktreeChanges(payload) {
+    return this.rpc("worktreeChanges", payload);
+  }
+  mergedStatus(payload) {
+    return this.rpc("mergedStatus", payload);
+  }
+  fileDiff(payload) {
+    return this.rpc("fileDiff", payload);
+  }
+  discardUnstagedFile(payload) {
+    return this.rpc("discardUnstagedFile", payload);
+  }
+  discardAllUnstaged(payload) {
+    return this.rpc("discardAllUnstaged", payload);
+  }
+  stageFile(payload) {
+    return this.rpc("stageFile", payload);
+  }
+  stageAll(payload) {
+    return this.rpc("stageAll", payload);
+  }
+  unstageFile(payload) {
+    return this.rpc("unstageFile", payload);
+  }
+  unstageAll(payload) {
+    return this.rpc("unstageAll", payload);
+  }
+  commitStaged(payload) {
+    return this.rpc("commitStaged", payload);
+  }
+  mergeWorktreeToParent(payload) {
+    return this.rpc("mergeWorktreeToParent", payload);
+  }
+  prFileDiff(payload) {
+    return this.rpc("prFileDiff", payload);
+  }
+  githubRepoInfo(payload) {
+    return this.rpc("githubRepoInfo", payload);
+  }
+  githubDefaultPrTitle(payload) {
+    return this.rpc("githubDefaultPrTitle", payload);
+  }
+  githubFetchAndSync(payload) {
+    return this.rpc("githubFetchAndSync", payload);
+  }
+  githubPullBranch(payload) {
+    return this.rpc("githubPullBranch", payload);
+  }
+  githubSyncBranch(payload) {
+    return this.rpc("githubSyncBranch", payload);
+  }
+  githubPushBranch(payload) {
+    return this.rpc("githubPushBranch", payload);
+  }
+  githubDeleteRemoteBranch(payload) {
+    return this.rpc("githubDeleteRemoteBranch", payload);
+  }
+  ensurePragmaExcluded(payload) {
+    return this.rpc("ensurePragmaExcluded", payload);
+  }
+  createWorktree(payload) {
+    return this.rpc("createWorktree", payload);
+  }
+  removeWorktree(payload) {
+    return this.rpc("removeWorktree", payload);
+  }
+  deleteBranch(payload) {
+    return this.rpc("deleteBranch", payload);
+  }
+  isDirty(payload) {
+    return this.rpc("isDirty", payload);
+  }
+  rpc(op, payload) {
+    return this.transport.request(routes.rpc("git"), { body: { op, ...payload } });
+  }
+}
+
+// src/health-client.ts
+class HealthClient {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  check(options = {}) {
+    return this.transport.request(routes.health, { signal: options.signal });
+  }
+}
+
+// src/push-client.ts
+class PushClient {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  register(payload, options = {}) {
+    return this.transport.request(routes.pushTokens, {
+      method: "POST",
+      body: payload,
+      signal: options.signal
+    });
+  }
+  unregister(options = {}) {
+    return this.transport.request(routes.pushTokens, {
+      method: "DELETE",
+      body: {},
+      signal: options.signal
+    });
+  }
+  list(options = {}) {
+    return this.transport.request(routes.pushTokens, {
+      method: "GET",
+      signal: options.signal
+    });
+  }
+  test(options = {}) {
+    return this.transport.request(routes.pushTest, {
+      method: "POST",
+      body: {},
+      signal: options.signal
+    });
+  }
+  presence(payload, options = {}) {
+    return this.transport.request(routes.pushPresence, {
+      method: "POST",
+      body: payload,
+      signal: options.signal
+    });
+  }
+}
+
+// ../scratchpad-contract/src/guards.ts
+function matchesShape(value, fields) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const record = value;
+  return Object.entries(fields).every(([field, guard]) => guard(record[field]));
+}
+var isString = (value) => typeof value === "string";
+var isNumber = (value) => typeof value === "number";
+function nullable(guard) {
+  return (value) => value === null || guard(value);
+}
+
+// ../scratchpad-contract/src/comments.ts
+function scratchpadCommentsPath(filePath) {
+  return `${filePath}.comments.json`;
+}
+function parseScratchpadComments(source) {
+  const value = JSON.parse(source);
+  if (!Array.isArray(value))
+    throw new Error("Scratchpad comments must be an array.");
+  return value.filter(isScratchpadComment);
+}
+function serializeScratchpadComments(comments) {
+  return `${JSON.stringify(comments, null, 2)}
+`;
+}
+function createScratchpadComment(block, text, now, id) {
+  return {
+    id,
+    from: 0,
+    to: 0,
+    quote: block.quote,
+    text: text.trim(),
+    createdAt: now,
+    resolvedAt: null,
+    blockIndex: block.index
+  };
+}
+function isScratchpadComment(value) {
+  return matchesShape(value, {
+    id: isString,
+    from: isNumber,
+    to: isNumber,
+    quote: isString,
+    text: isString,
+    createdAt: isNumber,
+    resolvedAt: nullable(isNumber)
+  });
+}
+// ../constants/values.json
+var values_default = {
+  daemon: {
+    protocolVersion: "0.1.0",
+    socketFile: "daemon.sock",
+    lockFile: "server.lock",
+    logFile: "server.log"
+  },
+  gateway: {
+    apiVersion: "0.0.0",
+    discoveryFile: "gateway.json",
+    tokenFile: "gateway-token",
+    devicesFile: "gateway-devices.json",
+    tokenHeader: "authorization",
+    deviceHeaders: {
+      id: "x-pragma-device-id",
+      name: "x-pragma-device-name",
+      platform: "x-pragma-device-platform",
+      appVersion: "x-pragma-app-version"
+    },
+    push: {
+      sendUrl: "https://exp.host/--/api/v2/push/send",
+      batchSize: 100,
+      presenceTtlMs: 90000,
+      tokenPrefixes: [
+        "ExponentPushToken[",
+        "ExpoPushToken["
+      ]
+    },
+    web: {
+      enabled: false,
+      basePath: "/web",
+      manifestFile: "manifest.json",
+      resourceDir: "web"
+    }
+  },
+  platform: {
+    defaultBackend: "native",
+    shells: {
+      macos: "/bin/zsh",
+      linux: "/bin/sh",
+      windows: [
+        "pwsh.exe",
+        "powershell.exe"
+      ]
+    },
+    wsl: {
+      launcher: "wsl.exe",
+      listArgs: [
+        "--list",
+        "--verbose"
+      ],
+      serverBinary: "pragma-server"
+    }
+  },
+  tunnel: {
+    defaultCommand: "ngrok http {port} --log stdout --log-format json",
+    defaultUrlPattern: '(https://[^\\s"]+)'
+  },
+  plugins: {
+    configFileName: ".pragma/config.json",
+    storageScopes: [
+      "global",
+      "project"
+    ]
+  },
+  theme: {
+    fileName: ".pragma/theme.json",
+    modes: [
+      "light",
+      "dark"
+    ]
+  },
+  keybindings: {
+    configFileName: ".pragma/keybindings.json"
+  },
+  bench: {
+    hookGlobal: "__PRAGMA_BENCH__",
+    runnerGlobal: "__PRAGMA_BENCH_RUNNER__",
+    markerPrefix: "PRAGMABENCH",
+    tabTitle: "pragma-bench"
+  },
+  agentStatus: {
+    soundsDirName: ".pragma/assets/sounds",
+    maxSoundSeconds: 5,
+    maxSoundBytes: 5242880,
+    soundExtensions: [
+      "mp3",
+      "wav",
+      "ogg",
+      "oga",
+      "m4a",
+      "aac",
+      "flac",
+      "webm"
+    ],
+    notificationsEnabled: true,
+    notificationText: {
+      doneTitle: "{agent} finished",
+      attentionTitle: "{agent} needs attention",
+      questionTitle: "{agent} is waiting for an answer",
+      commandTitle: "{agent} wants to run a command",
+      locationSeparator: " / ",
+      tabSuffix: ' · tab "{tab}"',
+      unknownLocation: "Open Pragma to continue."
+    }
+  },
+  terminalDefaults: {
+    hiddenDistros: [
+      "docker-desktop",
+      "docker-desktop-data"
+    ],
+    rememberLastShell: false,
+    maxDroppedFileBytes: 10485760,
+    droppedFilesDirName: "pragma-dropped-files",
+    droppedFilesMaxAgeMs: 86400000
+  },
+  tabs: {
+    defaultTitles: {
+      fallback: "Shell",
+      browser: "New tab",
+      log: "Server Logs",
+      scratchpad: "Scratchpad",
+      whiteboard: "Whiteboard",
+      prReview: "PR Review",
+      pluginWebview: "Plugin"
+    }
+  },
+  files: {
+    chunkBytes: 4194304,
+    maxBinaryBytes: 268435456
+  },
+  fanout: {
+    stateFile: "fanouts.json",
+    branchPrefix: "fanout",
+    minMembers: 2,
+    defaultJobs: 4,
+    deliveryTimeoutMs: 15000,
+    envFanoutId: "PRAGMA_FANOUT_ID",
+    envMemberId: "PRAGMA_FANOUT_MEMBER_ID"
+  },
+  scratchpads: {
+    directory: ".pragma/scratchpads",
+    extension: "mdx",
+    frontmatterKey: "pragmaScratchpad",
+    version: 1
+  },
+  whiteboards: {
+    databaseFile: "whiteboards.db",
+    defaultTitle: "Whiteboard",
+    maxTitleChars: 200,
+    maxSceneBytes: 8388608,
+    maxRenderDimension: 4096
+  },
+  protocol: {
+    rpcMethods: [
+      "git",
+      "filesystem",
+      "database",
+      "kanban",
+      "worktrees",
+      "projects",
+      "tabs",
+      "settings",
+      "github",
+      "ai",
+      "exec",
+      "automations",
+      "plugins",
+      "tunnel",
+      "scratchpads",
+      "whiteboards",
+      "wsl",
+      "fanouts"
+    ],
+    events: [
+      "agentStatus",
+      "worktreeChanged",
+      "kanbanChanged",
+      "tabsChanged",
+      "fileChanged",
+      "echoMode",
+      "automationPending",
+      "automationsChanged",
+      "workspace",
+      "fanouts"
+    ],
+    errors: [
+      "invalidPayload",
+      "unsupportedMethod",
+      "notFound",
+      "staleWrite",
+      "permissionDenied",
+      "internal"
+    ]
+  },
+  scripts: {
+    maxConcurrentCommands: 4,
+    configPath: ".pragma/scripts.json",
+    migrationSources: [
+      {
+        id: "superset",
+        label: "Superset",
+        configPaths: [
+          ".superset/config.json"
+        ]
+      },
+      {
+        id: "emdash",
+        label: "Emdash",
+        configPaths: [
+          ".emdash.json"
+        ]
+      },
+      {
+        id: "orca",
+        label: "Orca",
+        configPaths: [
+          "orca.yaml",
+          "orca.yml",
+          ".orca/config.json"
+        ]
+      }
+    ],
+    migrationCommitMessage: "chore(config): add pragma-app.sh config"
+  },
+  agents: {
+    startDelayMs: 500,
+    altScreenExtraWaitMs: 15000,
+    altScreenSettleMs: 500
+  },
+  github: {
+    oauthClientId: "Ov23li1WfY05SeQNp5tk",
+    scopes: [
+      "repo"
+    ],
+    deviceCodeUrl: "https://github.com/login/device/code",
+    deviceVerifyUrl: "https://github.com/login/device",
+    accessTokenUrl: "https://github.com/login/oauth/access_token",
+    apiBaseUrl: "https://api.github.com",
+    homepageUrl: "https://github.com/pragma-sh/pragma",
+    prSignature: {
+      enabled: true,
+      startMarker: "<!-- pragma:pr-signature -->",
+      endMarker: "<!-- /pragma:pr-signature -->",
+      linkLabel: "Open worktree in Pragma",
+      openUrl: "https://pragma-app.sh/open"
+    }
+  },
+  app: {
+    name: "Pragma",
+    identifier: "com.pragma.app",
+    version: "0.1.0"
+  },
+  onboarding: {
+    mediaBaseUrl: "https://pragma-app.sh/media",
+    skill: {
+      id: "pragma",
+      targets: [
+        {
+          id: "all-agents",
+          directory: ".agents/skills",
+          label: "All agents"
+        },
+        {
+          id: "claude-code",
+          directory: ".claude/skills",
+          label: "Claude Code"
+        }
+      ]
+    }
+  },
+  updates: {
+    checkUrl: "https://pragma-app.sh/api/updates",
+    devCheckUrl: "http://localhost:3000/api/updates",
+    pollIntervalMs: 300000,
+    autoDownload: true,
+    manifestFile: "release.json",
+    uiDirName: "ui",
+    buttonLabel: "Install Update",
+    changelogLabel: "View changelog",
+    restartWarningTitle: "This update restarts the app server",
+    restartWarningBody: "Open terminal sessions will stop. Save anything you need before installing.",
+    applyModes: [
+      "reload",
+      "restart"
+    ],
+    platforms: [
+      "darwin-aarch64",
+      "darwin-x86_64",
+      "linux-x86_64-deb",
+      "linux-x86_64-rpm",
+      "linux-x86_64-appimage",
+      "linux-aarch64-deb",
+      "linux-aarch64-rpm",
+      "linux-aarch64-appimage",
+      "windows-x86_64"
+    ]
+  },
+  window: {
+    defaultWidth: 1024,
+    defaultHeight: 768,
+    minWidth: 640,
+    minHeight: 480,
+    titlebarHeight: 38,
+    trafficLightInset: 12
+  },
+  editorLaunchers: {
+    defaultEditorId: "system",
+    options: [
+      {
+        id: "system",
+        name: "File Explorer",
+        brandIcon: "lucide:folder-open",
+        brandColor: "#38bdf8",
+        cliCommand: null
+      },
+      {
+        id: "vscode",
+        name: "VS Code",
+        brandIcon: "simple-icons:visualstudiocode",
+        brandColor: "#007acc",
+        cliCommand: "code"
+      },
+      {
+        id: "cursor",
+        name: "Cursor",
+        brandIcon: "simple-icons:cursor",
+        brandColor: "#ffffff",
+        cliCommand: "cursor"
+      },
+      {
+        id: "windsurf",
+        name: "Windsurf",
+        brandIcon: "simple-icons:windsurf",
+        brandColor: "#00c7be",
+        cliCommand: "windsurf"
+      },
+      {
+        id: "zed",
+        name: "Zed",
+        brandIcon: "simple-icons:zedindustries",
+        brandColor: "#084ccf",
+        cliCommand: "zed"
+      },
+      {
+        id: "sublime-text",
+        name: "Sublime Text",
+        brandIcon: "simple-icons:sublimetext",
+        brandColor: "#ff9800",
+        cliCommand: "subl"
+      },
+      {
+        id: "intellij-idea",
+        name: "IntelliJ IDEA",
+        brandIcon: "simple-icons:intellijidea",
+        brandColor: "#ff2d8f",
+        cliCommand: "idea"
+      }
+    ]
+  }
+};
+
+// ../constants/src/index.ts
+var constants = values_default;
+
+// ../scratchpad-contract/src/document.ts
+var FRONTMATTER_PATTERN = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n)?/;
+function parseScratchpadDocument(source) {
+  const frontmatter = FRONTMATTER_PATTERN.exec(source);
+  if (!frontmatter) {
+    throw new Error("This MDX file is not a managed Pragma scratchpad.");
+  }
+  return {
+    metadata: parseMetadata(metadataLine(frontmatter[1] ?? "")),
+    body: source.slice(frontmatter[0].length),
+    frontmatter: frontmatter[0]
+  };
+}
+function metadataLine(frontmatter) {
+  const key = constants.scratchpads.frontmatterKey;
+  const line = frontmatter.split(/\r?\n/).find((entry) => entry.startsWith(`${key}: `));
+  if (!line)
+    throw new Error("Scratchpad frontmatter is missing managed metadata.");
+  return line.slice(key.length + 2);
+}
+function parseMetadata(json) {
+  const parsed = JSON.parse(json);
+  if (!isScratchpadMetadata(parsed) || parsed.version !== constants.scratchpads.version) {
+    throw new Error("Scratchpad metadata is invalid or uses an unsupported version.");
+  }
+  return parsed;
+}
+function attachScratchpadAgent(source, agent) {
+  const document = parseScratchpadDocument(source);
+  const metadata = {
+    ...document.metadata,
+    agentTabId: agent.tabId,
+    agentId: agent.agentId
+  };
+  const key = constants.scratchpads.frontmatterKey;
+  const nextLine = `${key}: ${JSON.stringify(metadata)}`;
+  const lines = document.frontmatter.split(/\r?\n/);
+  const index = lines.findIndex((line) => line.startsWith(`${key}: `));
+  if (index < 0)
+    throw new Error("Scratchpad frontmatter is missing managed metadata.");
+  lines[index] = nextLine;
+  return `${lines.join(`
+`)}${document.body}`;
+}
+function isScratchpadMetadata(value) {
+  return matchesShape(value, {
+    version: isNumber,
+    id: isString,
+    title: isString,
+    agentTabId: nullable(isString),
+    agentId: nullable(isString),
+    createdAt: isNumber
+  });
+}
+// src/scratchpads-client.ts
+class ScratchpadsClient {
+  transport;
+  fs;
+  agents;
+  constructor(transport, fs, agents) {
+    this.transport = transport;
+    this.fs = fs;
+    this.agents = agents;
+  }
+  getScratchpads(options) {
+    const query = `?root=${encodeURIComponent(options.root)}`;
+    return this.transport.request(`${routes.scratchpads}${query}`, {
+      signal: options.signal
+    });
+  }
+  async getComments(options) {
+    const path = scratchpadCommentsPath(options.filePath);
+    const { root } = options;
+    if (!await this.fs.pathExists({ root, path }))
+      return [];
+    const file = await this.fs.readFile({ root, path });
+    if (file.binary || file.truncated)
+      return [];
+    return parseScratchpadComments(file.text);
+  }
+  async comment(options) {
+    const { root, filePath, block, text } = options;
+    const comment = createScratchpadComment(block, text, options.createdAt ?? Date.now(), options.id ?? randomCommentId());
+    const existing = await this.getComments({ root, filePath });
+    await this.writeComments({ root, filePath }, [...existing, comment]);
+    return comment;
+  }
+  async setComments(options, comments) {
+    await this.writeComments(options, comments);
+  }
+  async attachAgent(options) {
+    const { root, filePath, tabId, agentId } = options;
+    const contents = options.contents ?? await this.readScratchpad(root, filePath);
+    await this.fs.writeFile({
+      root,
+      path: filePath,
+      contents: attachScratchpadAgent(contents, { tabId, agentId })
+    });
+  }
+  async sendAttached(options) {
+    const { root, filePath, worktreeId, text } = options;
+    const contents = options.contents ?? await this.readScratchpad(root, filePath);
+    const { metadata } = parseScratchpadDocument(contents);
+    if (!metadata.agentTabId || !metadata.agentId)
+      return { delivered: false };
+    const agent = runtimeAgentId(metadata.agentId);
+    await this.agents.reportInput({ agent, worktreeId, tabId: metadata.agentTabId, text }, { signal: options.signal });
+    return { delivered: true, agent, tabId: metadata.agentTabId };
+  }
+  async readScratchpad(root, filePath) {
+    const file = await this.fs.readFile({ root, path: filePath });
+    if (file.binary)
+      throw new Error(`Scratchpad ${filePath} is not text.`);
+    if (file.truncated)
+      throw new Error(`Scratchpad ${filePath} was truncated by the host.`);
+    return file.text;
+  }
+  writeComments(options, comments) {
+    return this.fs.writeFile({
+      root: options.root,
+      path: scratchpadCommentsPath(options.filePath),
+      contents: serializeScratchpadComments(comments)
+    });
+  }
+}
+function runtimeAgentId(agentId) {
+  return agentId.split(".").at(-1) ?? agentId;
+}
+function randomCommentId() {
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+
+// src/sessions-client.ts
+class SessionsClient {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  spawn(payload, options = {}) {
+    return this.transport.request(routes.sessions, {
+      method: "POST",
+      body: payload,
+      signal: options.signal
+    });
+  }
+  async* attach(sessionId, options = {}) {
+    const response = await this.transport.raw(routes.sessionEvents(sessionId), {
+      signal: options.signal
+    });
+    yield* ndjsonStream(response, options.signal);
+  }
+  write(sessionId, bytes, options = {}) {
+    return this.transport.request(routes.sessionInput(sessionId), {
+      method: "POST",
+      rawBody: bytes,
+      headers: { "content-type": "application/octet-stream" },
+      signal: options.signal
+    });
+  }
+  resize(sessionId, payload, options = {}) {
+    return this.transport.request(routes.sessionResize(sessionId), {
+      method: "POST",
+      body: payload,
+      signal: options.signal
+    });
+  }
+  kill(sessionId, options = {}) {
+    return this.transport.request(routes.session(sessionId), {
+      method: "DELETE",
+      signal: options.signal
+    });
+  }
+  rename(sessionId, title) {
+    return this.transport.request(routes.control("tabRename"), {
+      method: "POST",
+      body: { tabId: sessionId, title }
+    });
+  }
+  killForCwd(cwd, options = {}) {
+    return this.transport.request(`${routes.sessions}?cwd=${encodeURIComponent(cwd)}`, {
+      method: "DELETE",
+      signal: options.signal
+    });
+  }
+}
+
+// src/theme-client.ts
+class ThemeClient {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  get(options = {}) {
+    const query = options.root ? `?root=${encodeURIComponent(options.root)}` : "";
+    return this.transport.request(`${routes.theme}${query}`, {
+      signal: options.signal
+    });
+  }
+}
+
+// src/whiteboards-client.ts
+class WhiteboardsClient {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  create(input) {
+    return this.rpc("create", input);
+  }
+  get(input) {
+    return this.rpc("get", input);
+  }
+  list(input) {
+    return this.rpc("list", input);
+  }
+  search(input) {
+    return this.rpc("list", input);
+  }
+  edit(input) {
+    return this.rpc("edit", input);
+  }
+  async delete(input) {
+    await this.rpc("delete", input);
+  }
+  async view(input) {
+    const result = await this.rpc("view", input);
+    return base64ToBytes(result.data);
+  }
+  rpc(action, input) {
+    return this.transport.request(routes.rpc("whiteboards"), {
+      method: "POST",
+      body: { action, ...input }
+    });
+  }
+}
+
+// src/workspace-client.ts
+class WorkspaceClient {
+  events;
+  constructor(events) {
+    this.events = events;
+  }
+  async* subscribe(options = {}) {
+    for await (const event of this.events.subscribe("workspace", options)) {
+      yield this.narrow(event);
+    }
+  }
+  narrow(event) {
+    return {
+      type: event.type,
+      subscription: event.subscription,
+      payload: event.payload ?? { projects: [], worktrees: [], tabs: [] }
+    };
+  }
+}
+
+// src/client.ts
+class PragmaClient {
+  fs;
+  git;
+  exec;
+  sessions;
+  agents;
+  assets;
+  events;
+  workspace;
+  fanouts;
+  push;
+  theme;
+  health;
+  scratchpads;
+  whiteboards;
+  transport;
+  constructor(config = {}) {
+    this.transport = new Transport(config);
+    this.fs = new FsClient(this.transport);
+    this.git = new GitClient(this.transport);
+    this.exec = new ExecClient(this.transport);
+    this.sessions = new SessionsClient(this.transport);
+    this.agents = new AgentsClient(this.transport);
+    this.assets = new AssetsClient(this.transport);
+    this.events = new EventsClient(this.transport);
+    this.workspace = new WorkspaceClient(this.events);
+    this.fanouts = new FanoutsClient(this.transport, this.events);
+    this.push = new PushClient(this.transport);
+    this.theme = new ThemeClient(this.transport);
+    this.health = new HealthClient(this.transport);
+    this.scratchpads = new ScratchpadsClient(this.transport, this.fs, this.agents);
+    this.whiteboards = new WhiteboardsClient(this.transport);
+  }
+  rpc(method, payload, options = {}) {
+    return this.transport.request(routes.rpc(method), {
+      method: "POST",
+      body: payload,
+      signal: options.signal
+    });
+  }
+  createBoardDraft(payload, options = {}) {
+    return this.transport.request(routes.control("boardDraftCreate"), {
+      method: "POST",
+      body: payload,
+      signal: options.signal
+    });
+  }
+}