@hachej/boring-workspace 0.1.54 → 0.1.56

package/dist/bridge-client.d.ts

@@ -0,0 +1,68 @@
+import { k as WorkspaceBridgeErrorCode } from './workspace-bridge-rpc-A98RA5o6.js';
+export { o as WORKSPACE_BRIDGE_DISABLED_ENV, p as WORKSPACE_BRIDGE_REFRESH_TOKEN_ENV, q as WORKSPACE_BRIDGE_TOKEN_ENV, r as WORKSPACE_BRIDGE_TOKEN_URL_ENV, s as WORKSPACE_BRIDGE_URL_ENV, i as WorkspaceBridgeCallFailure, a as WorkspaceBridgeCallRequest, b as WorkspaceBridgeCallResponse, j as WorkspaceBridgeCallSuccess, c as WorkspaceBridgeError } from './workspace-bridge-rpc-A98RA5o6.js';
+
+declare enum WorkspaceBridgeClientErrorCode {
+    Config = "WORKSPACE_BRIDGE_CLIENT_CONFIG_ERROR",
+    InvalidResponse = "WORKSPACE_BRIDGE_INVALID_RESPONSE",
+    Transport = "WORKSPACE_BRIDGE_TRANSPORT_ERROR",
+    Timeout = "WORKSPACE_BRIDGE_TIMEOUT",
+    Aborted = "WORKSPACE_BRIDGE_ABORTED",
+    HttpError = "WORKSPACE_BRIDGE_HTTP_ERROR"
+}
+interface WorkspaceBridgeTokenProviderContext {
+    /** True when the previous attempt failed with a 401 and the client is retrying once. */
+    refresh: boolean;
+    /** Aborts when the per-attempt timeout or caller AbortSignal fires. */
+    signal?: AbortSignal;
+}
+type WorkspaceBridgeTokenProvider = (context: WorkspaceBridgeTokenProviderContext) => string | Promise<string>;
+type WorkspaceBridgeClientToken = string | WorkspaceBridgeTokenProvider;
+interface WorkspaceBridgeClientOptions {
+    url: string;
+    token: WorkspaceBridgeClientToken;
+    fetch?: typeof fetch;
+    /** Default per-attempt timeout. Defaults to 30s. */
+    defaultTimeoutMs?: number;
+}
+interface WorkspaceBridgeClientCallOptions {
+    requestId?: string;
+    idempotencyKey?: string;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+declare class WorkspaceBridgeClientConfigError extends Error {
+    readonly code = WorkspaceBridgeClientErrorCode.Config;
+    readonly missingVar?: string;
+    constructor(message: string, options?: {
+        missingVar?: string;
+    });
+}
+declare class WorkspaceBridgeClientError extends Error {
+    readonly code: WorkspaceBridgeErrorCode | WorkspaceBridgeClientErrorCode;
+    readonly status?: number;
+    readonly requestId?: string;
+    constructor(message: string, options: {
+        code: WorkspaceBridgeErrorCode | WorkspaceBridgeClientErrorCode;
+        status?: number;
+        requestId?: string;
+        cause?: unknown;
+    });
+}
+declare class WorkspaceBridgeClient {
+    readonly url: string;
+    private readonly token;
+    private readonly fetchImpl;
+    private readonly defaultTimeoutMs;
+    constructor(options: WorkspaceBridgeClientOptions);
+    static fromEnv(env?: Record<string, string | undefined>, options?: {
+        fetch?: typeof fetch;
+        token?: WorkspaceBridgeClientToken;
+        defaultTimeoutMs?: number;
+    }): WorkspaceBridgeClient;
+    call<TOutput = unknown, TInput = unknown>(op: string, input: TInput, options?: WorkspaceBridgeClientCallOptions): Promise<TOutput>;
+    private callOnce;
+    private resolveToken;
+    private shouldRetryWithFreshToken;
+}
+
+export { WorkspaceBridgeClient, type WorkspaceBridgeClientCallOptions, WorkspaceBridgeClientConfigError, WorkspaceBridgeClientError, WorkspaceBridgeClientErrorCode, type WorkspaceBridgeClientOptions, type WorkspaceBridgeClientToken, WorkspaceBridgeErrorCode, type WorkspaceBridgeTokenProvider, type WorkspaceBridgeTokenProviderContext };

package/dist/bridge-client.js

@@ -0,0 +1,370 @@
+// src/shared/workspace-bridge-rpc.ts
+var WORKSPACE_BRIDGE_URL_ENV = "BORING_WORKSPACE_BRIDGE_URL";
+var WORKSPACE_BRIDGE_TOKEN_ENV = "BORING_WORKSPACE_BRIDGE_TOKEN";
+var WORKSPACE_BRIDGE_TOKEN_URL_ENV = "BORING_WORKSPACE_BRIDGE_TOKEN_URL";
+var WORKSPACE_BRIDGE_REFRESH_TOKEN_ENV = "BORING_WORKSPACE_BRIDGE_REFRESH_TOKEN";
+var WORKSPACE_BRIDGE_DISABLED_ENV = "BORING_WORKSPACE_BRIDGE_DISABLED";
+var WorkspaceBridgeErrorCode = /* @__PURE__ */ ((WorkspaceBridgeErrorCode2) => {
+  WorkspaceBridgeErrorCode2["OpNotFound"] = "BRIDGE_OP_NOT_FOUND";
+  WorkspaceBridgeErrorCode2["DuplicateOp"] = "BRIDGE_DUPLICATE_OP";
+  WorkspaceBridgeErrorCode2["CallerNotAllowed"] = "BRIDGE_CALLER_NOT_ALLOWED";
+  WorkspaceBridgeErrorCode2["AuthRequired"] = "BRIDGE_AUTH_REQUIRED";
+  WorkspaceBridgeErrorCode2["CapabilityDenied"] = "BRIDGE_CAPABILITY_DENIED";
+  WorkspaceBridgeErrorCode2["ResourceScopeDenied"] = "BRIDGE_RESOURCE_SCOPE_DENIED";
+  WorkspaceBridgeErrorCode2["SchemaInvalid"] = "BRIDGE_SCHEMA_INVALID";
+  WorkspaceBridgeErrorCode2["OutputSchemaInvalid"] = "BRIDGE_OUTPUT_SCHEMA_INVALID";
+  WorkspaceBridgeErrorCode2["InputTooLarge"] = "BRIDGE_INPUT_TOO_LARGE";
+  WorkspaceBridgeErrorCode2["OutputTooLarge"] = "BRIDGE_OUTPUT_TOO_LARGE";
+  WorkspaceBridgeErrorCode2["Timeout"] = "BRIDGE_TIMEOUT";
+  WorkspaceBridgeErrorCode2["HandlerFailed"] = "BRIDGE_HANDLER_FAILED";
+  WorkspaceBridgeErrorCode2["IdempotencyRequired"] = "BRIDGE_IDEMPOTENCY_REQUIRED";
+  WorkspaceBridgeErrorCode2["IdempotencyConflict"] = "BRIDGE_IDEMPOTENCY_CONFLICT";
+  WorkspaceBridgeErrorCode2["ReplayRejected"] = "BRIDGE_REPLAY_REJECTED";
+  WorkspaceBridgeErrorCode2["RateLimited"] = "BRIDGE_RATE_LIMITED";
+  WorkspaceBridgeErrorCode2["InvalidToken"] = "BRIDGE_INVALID_TOKEN";
+  WorkspaceBridgeErrorCode2["ExpiredToken"] = "BRIDGE_EXPIRED_TOKEN";
+  WorkspaceBridgeErrorCode2["InvalidRequest"] = "BRIDGE_INVALID_REQUEST";
+  WorkspaceBridgeErrorCode2["UnsupportedRuntime"] = "BRIDGE_UNSUPPORTED_RUNTIME";
+  return WorkspaceBridgeErrorCode2;
+})(WorkspaceBridgeErrorCode || {});
+
+// src/bridge-client/index.ts
+var WorkspaceBridgeClientErrorCode = /* @__PURE__ */ ((WorkspaceBridgeClientErrorCode2) => {
+  WorkspaceBridgeClientErrorCode2["Config"] = "WORKSPACE_BRIDGE_CLIENT_CONFIG_ERROR";
+  WorkspaceBridgeClientErrorCode2["InvalidResponse"] = "WORKSPACE_BRIDGE_INVALID_RESPONSE";
+  WorkspaceBridgeClientErrorCode2["Transport"] = "WORKSPACE_BRIDGE_TRANSPORT_ERROR";
+  WorkspaceBridgeClientErrorCode2["Timeout"] = "WORKSPACE_BRIDGE_TIMEOUT";
+  WorkspaceBridgeClientErrorCode2["Aborted"] = "WORKSPACE_BRIDGE_ABORTED";
+  WorkspaceBridgeClientErrorCode2["HttpError"] = "WORKSPACE_BRIDGE_HTTP_ERROR";
+  return WorkspaceBridgeClientErrorCode2;
+})(WorkspaceBridgeClientErrorCode || {});
+var WorkspaceBridgeClientConfigError = class extends Error {
+  code = "WORKSPACE_BRIDGE_CLIENT_CONFIG_ERROR" /* Config */;
+  missingVar;
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "WorkspaceBridgeClientConfigError";
+    this.missingVar = options.missingVar;
+  }
+};
+var WorkspaceBridgeClientError = class extends Error {
+  code;
+  status;
+  requestId;
+  constructor(message, options) {
+    super(message);
+    this.name = "WorkspaceBridgeClientError";
+    this.code = options.code;
+    this.status = options.status;
+    this.requestId = options.requestId;
+    if (options.cause !== void 0) {
+      ;
+      this.cause = options.cause;
+    }
+  }
+};
+var WorkspaceBridgeClient = class _WorkspaceBridgeClient {
+  url;
+  token;
+  fetchImpl;
+  defaultTimeoutMs;
+  constructor(options) {
+    this.url = normalizeBridgeUrl(options.url);
+    this.token = options.token;
+    this.fetchImpl = options.fetch ?? globalThis.fetch;
+    this.defaultTimeoutMs = options.defaultTimeoutMs ?? 3e4;
+    assertTimeoutMs(this.defaultTimeoutMs, "defaultTimeoutMs");
+    if (!this.fetchImpl) {
+      throw new WorkspaceBridgeClientConfigError("WorkspaceBridge client requires a fetch implementation");
+    }
+  }
+  static fromEnv(env = readProcessEnv(), options = {}) {
+    const disabled = env[WORKSPACE_BRIDGE_DISABLED_ENV];
+    if (disabled) {
+      throw new WorkspaceBridgeClientConfigError(`WorkspaceBridge runtime env is disabled: ${disabled}`);
+    }
+    const url = requireEnv(env, WORKSPACE_BRIDGE_URL_ENV);
+    const token = options.token ?? tokenFromEnv(env, options.fetch ?? globalThis.fetch);
+    return new _WorkspaceBridgeClient({ url, token, fetch: options.fetch, defaultTimeoutMs: options.defaultTimeoutMs });
+  }
+  async call(op, input, options = {}) {
+    const request = {
+      op,
+      input,
+      ...options.requestId ? { requestId: options.requestId } : {},
+      ...options.idempotencyKey ? { idempotencyKey: options.idempotencyKey } : {}
+    };
+    try {
+      return await this.callOnce(request, options, false);
+    } catch (error) {
+      if (this.shouldRetryWithFreshToken(error)) {
+        return await this.callOnce(request, options, true);
+      }
+      throw error;
+    }
+  }
+  async callOnce(request, options, refreshToken) {
+    const timeoutMs = options.timeoutMs ?? this.defaultTimeoutMs;
+    assertTimeoutMs(timeoutMs, "timeoutMs");
+    const abort = createAbortController({ signal: options.signal, timeoutMs });
+    try {
+      const token = await runWithAbort(() => this.resolveToken(refreshToken, abort.signal), abort);
+      const response = await runWithAbort(() => this.fetchImpl(this.url, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          authorization: `Bearer ${token}`
+        },
+        body: JSON.stringify(request),
+        signal: abort.signal
+      }), abort);
+      const body = await readJsonResponse(response, abort);
+      const envelope = parseBridgeEnvelope(body);
+      if (!envelope) {
+        if (!httpOk(response)) {
+          throw new WorkspaceBridgeClientError(httpErrorMessage(response, body), {
+            code: "WORKSPACE_BRIDGE_HTTP_ERROR" /* HttpError */,
+            status: response.status
+          });
+        }
+        throw new WorkspaceBridgeClientError("WorkspaceBridge response envelope was invalid", {
+          code: "WORKSPACE_BRIDGE_INVALID_RESPONSE" /* InvalidResponse */,
+          status: response.status
+        });
+      }
+      if (!envelope.ok) {
+        throw new WorkspaceBridgeClientError(envelope.error.message, {
+          code: envelope.error.code,
+          status: response.status,
+          requestId: envelope.requestId
+        });
+      }
+      if (!httpOk(response)) {
+        throw new WorkspaceBridgeClientError(httpErrorMessage(response, body), {
+          code: "WORKSPACE_BRIDGE_HTTP_ERROR" /* HttpError */,
+          status: response.status,
+          requestId: envelope.requestId
+        });
+      }
+      return envelope.output;
+    } catch (error) {
+      if (error instanceof WorkspaceBridgeClientError || error instanceof WorkspaceBridgeClientConfigError) throw error;
+      throw fetchError(error, abort);
+    } finally {
+      abort.cleanup();
+    }
+  }
+  async resolveToken(refresh, signal) {
+    const value = typeof this.token === "function" ? await this.token({ refresh, signal }) : this.token;
+    if (!value) {
+      throw new WorkspaceBridgeClientConfigError("WorkspaceBridge token provider returned an empty token");
+    }
+    return value;
+  }
+  shouldRetryWithFreshToken(error) {
+    if (typeof this.token !== "function") return false;
+    return error instanceof WorkspaceBridgeClientError && error.status === 401;
+  }
+};
+function tokenFromEnv(env, fetchImpl) {
+  const initialToken = requireEnv(env, WORKSPACE_BRIDGE_TOKEN_ENV);
+  const tokenUrl = env[WORKSPACE_BRIDGE_TOKEN_URL_ENV];
+  const refreshToken = env[WORKSPACE_BRIDGE_REFRESH_TOKEN_ENV];
+  if (!tokenUrl && !refreshToken) return initialToken;
+  if (!tokenUrl) {
+    throw new WorkspaceBridgeClientConfigError(`WorkspaceBridge client missing required env var ${WORKSPACE_BRIDGE_TOKEN_URL_ENV}`, { missingVar: WORKSPACE_BRIDGE_TOKEN_URL_ENV });
+  }
+  if (!refreshToken) {
+    throw new WorkspaceBridgeClientConfigError(`WorkspaceBridge client missing required env var ${WORKSPACE_BRIDGE_REFRESH_TOKEN_ENV}`, { missingVar: WORKSPACE_BRIDGE_REFRESH_TOKEN_ENV });
+  }
+  if (!fetchImpl) {
+    throw new WorkspaceBridgeClientConfigError("WorkspaceBridge refresh token provider requires a fetch implementation");
+  }
+  const normalizedTokenUrl = normalizeBridgeUrl(tokenUrl);
+  let cachedToken = initialToken;
+  return async ({ refresh, signal }) => {
+    if (!refresh) return cachedToken;
+    cachedToken = await fetchRefreshedToken({ tokenUrl: normalizedTokenUrl, refreshToken, fetchImpl, signal });
+    return cachedToken;
+  };
+}
+async function fetchRefreshedToken(options) {
+  const response = await options.fetchImpl(options.tokenUrl, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${options.refreshToken}`
+    },
+    body: "{}",
+    signal: options.signal
+  });
+  const body = await response.json();
+  if (isTokenResponse(body)) return body.token;
+  const envelope = parseBridgeEnvelope(body);
+  if (envelope && !envelope.ok) {
+    throw new WorkspaceBridgeClientError(envelope.error.message, {
+      code: envelope.error.code,
+      status: response.status,
+      requestId: envelope.requestId
+    });
+  }
+  if (!httpOk(response)) {
+    throw new WorkspaceBridgeClientError(httpErrorMessage(response, body), {
+      code: "WORKSPACE_BRIDGE_HTTP_ERROR" /* HttpError */,
+      status: response.status
+    });
+  }
+  throw new WorkspaceBridgeClientError("WorkspaceBridge token response envelope was invalid", {
+    code: "WORKSPACE_BRIDGE_INVALID_RESPONSE" /* InvalidResponse */,
+    status: response.status
+  });
+}
+function isTokenResponse(value) {
+  return !!value && typeof value === "object" && value.ok === true && typeof value.token === "string";
+}
+function requireEnv(env, name) {
+  const value = env[name];
+  if (!value) {
+    throw new WorkspaceBridgeClientConfigError(`WorkspaceBridge client missing required env var ${name}`, { missingVar: name });
+  }
+  return value;
+}
+function normalizeBridgeUrl(value) {
+  try {
+    return new URL(value).toString();
+  } catch {
+    throw new WorkspaceBridgeClientConfigError(`WorkspaceBridge client env var ${WORKSPACE_BRIDGE_URL_ENV} is not a valid URL`);
+  }
+}
+function readProcessEnv() {
+  return globalThis.process?.env ?? {};
+}
+function assertTimeoutMs(value, name) {
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new WorkspaceBridgeClientConfigError(`WorkspaceBridge client ${name} must be a positive finite number`);
+  }
+}
+function createAbortController(options) {
+  const controller = new AbortController();
+  let timedOut = false;
+  let callerAborted = Boolean(options.signal?.aborted);
+  const abortFromCaller = () => {
+    callerAborted = true;
+    controller.abort(options.signal?.reason);
+  };
+  if (options.signal?.aborted) abortFromCaller();
+  else options.signal?.addEventListener("abort", abortFromCaller, { once: true });
+  const timeout = setTimeout(() => {
+    timedOut = true;
+    controller.abort(new Error("WorkspaceBridge request timed out"));
+  }, options.timeoutMs);
+  return {
+    signal: controller.signal,
+    timedOut: () => timedOut,
+    callerAborted: () => callerAborted,
+    cleanup: () => {
+      clearTimeout(timeout);
+      options.signal?.removeEventListener("abort", abortFromCaller);
+    }
+  };
+}
+function fetchError(error, abort) {
+  if (abort.timedOut()) {
+    return new WorkspaceBridgeClientError("WorkspaceBridge request timed out", {
+      code: "WORKSPACE_BRIDGE_TIMEOUT" /* Timeout */,
+      cause: error
+    });
+  }
+  if (abort.callerAborted()) {
+    return new WorkspaceBridgeClientError("WorkspaceBridge request was aborted", {
+      code: "WORKSPACE_BRIDGE_ABORTED" /* Aborted */,
+      cause: error
+    });
+  }
+  return new WorkspaceBridgeClientError("WorkspaceBridge transport failed", {
+    code: "WORKSPACE_BRIDGE_TRANSPORT_ERROR" /* Transport */,
+    cause: error
+  });
+}
+async function runWithAbort(operation, abort) {
+  if (abort.signal.aborted) throw fetchError(void 0, abort);
+  return await new Promise((resolve, reject) => {
+    let settled = false;
+    const cleanup = () => abort.signal.removeEventListener("abort", onAbort);
+    const settle = (callback) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      callback();
+    };
+    const onAbort = () => settle(() => reject(fetchError(void 0, abort)));
+    abort.signal.addEventListener("abort", onAbort, { once: true });
+    Promise.resolve().then(operation).then(
+      (value) => settle(() => resolve(value)),
+      (error) => settle(() => reject(error))
+    );
+  });
+}
+async function readJsonResponse(response, abort) {
+  try {
+    return await runWithAbort(() => response.json(), abort);
+  } catch (error) {
+    if (error instanceof WorkspaceBridgeClientError) throw error;
+    if (abort.timedOut() || abort.callerAborted()) throw fetchError(error, abort);
+    throw new WorkspaceBridgeClientError("WorkspaceBridge response was not valid JSON", {
+      code: "WORKSPACE_BRIDGE_INVALID_RESPONSE" /* InvalidResponse */,
+      status: response.status,
+      cause: error
+    });
+  }
+}
+function parseBridgeEnvelope(value) {
+  if (!value || typeof value !== "object") return null;
+  const raw = value;
+  const requestId = raw.requestId === void 0 || typeof raw.requestId === "string" ? raw.requestId : void 0;
+  if (raw.ok === true) {
+    return {
+      ok: true,
+      op: typeof raw.op === "string" ? raw.op : "",
+      ...requestId ? { requestId } : {},
+      output: raw.output
+    };
+  }
+  if (raw.ok === false && raw.error && typeof raw.error === "object") {
+    const error = raw.error;
+    if (typeof error.message !== "string" || !isWorkspaceBridgeErrorCode(error.code)) return null;
+    return {
+      ok: false,
+      op: typeof raw.op === "string" ? raw.op : "",
+      ...requestId ? { requestId } : {},
+      error: { code: error.code, message: error.message }
+    };
+  }
+  return null;
+}
+var WORKSPACE_BRIDGE_ERROR_CODES = new Set(Object.values(WorkspaceBridgeErrorCode));
+function isWorkspaceBridgeErrorCode(value) {
+  return typeof value === "string" && WORKSPACE_BRIDGE_ERROR_CODES.has(value);
+}
+function httpOk(response) {
+  return typeof response.ok === "boolean" ? response.ok : response.status >= 200 && response.status < 300;
+}
+function httpErrorMessage(response, body) {
+  if (body && typeof body === "object" && typeof body.message === "string") {
+    return body.message;
+  }
+  const statusText = typeof response.statusText === "string" && response.statusText ? ` ${response.statusText}` : "";
+  return `WorkspaceBridge HTTP ${response.status}${statusText}`;
+}
+export {
+  WORKSPACE_BRIDGE_DISABLED_ENV,
+  WORKSPACE_BRIDGE_REFRESH_TOKEN_ENV,
+  WORKSPACE_BRIDGE_TOKEN_ENV,
+  WORKSPACE_BRIDGE_TOKEN_URL_ENV,
+  WORKSPACE_BRIDGE_URL_ENV,
+  WorkspaceBridgeClient,
+  WorkspaceBridgeClientConfigError,
+  WorkspaceBridgeClientError,
+  WorkspaceBridgeClientErrorCode,
+  WorkspaceBridgeErrorCode
+};

package/dist/plugin.d.ts

@@ -2,7 +2,7 @@ import { ComponentType, ReactNode } from 'react';
 import { P as PaneProps, a as PanelConfig, S as SurfaceOpenRequest, c as SurfacePanelResolution } from './surface-DmIalUmP.js';
 export { W as WORKSPACE_OPEN_PATH_SURFACE_KIND } from './surface-DmIalUmP.js';
 export { B as BoringPackageBoringField, a as BoringPackagePiField, b as BoringPackagePiSource, c as BoringPackagePiSourceObject, d as BoringPluginManifestErrorCode, e as BoringPluginManifestIssue, f as BoringPluginManifestValidationResult, g as BoringPluginPackageJson, i as isSafePluginRelativePath, h as isValidBoringPluginId, v as validateBoringPluginManifest } from './manifest-C2vVgH_e.js';
-import { a as UiCommand, C as CommandResult, U as UiBridge } from './ui-bridge-LeBuZqfA.js';
+import { a as UiCommand, C as CommandResult, U as UiBridge } from './ui-bridge-BbuUZ5iC.js';
 import 'dockview-react';
 
 type CatalogBadge = {
@@ -54,6 +54,8 @@ interface PluginProviderProps {
     authHeaders?: Record<string, string>;
     onAuthError?: (statusCode: number) => void;
     apiTimeout?: number;
+    activeSessionId?: string | null;
+    openSessionIds?: readonly string[];
     children: ReactNode;
 }
 type PluginProvider = ComponentType<PluginProviderProps>;