@backmatter/studio 0.0.1

package/src/api.ts

@@ -0,0 +1,833 @@
+// packages/studio/src/api.ts
+import { encodeDocLocale } from "@backmatter/core";
+import { replicaQuery, type ReplicaCache } from "./replica/cache";
+import type { ReplicaBody } from "./replica/types";
+import { apiCredentials, apiHeaders, apiUrl, reportUnauthorized } from "./studio-config";
+
+export type ApiError = Error & {
+  status: number;
+  code?: string;
+  details?: string[];
+};
+
+async function api<T>(path: string, init?: RequestInit): Promise<T> {
+  const res = await fetch(apiUrl(path), {
+    credentials: apiCredentials(),
+    ...init,
+    headers: {
+      "Content-Type": "application/json",
+      ...apiHeaders(),
+      ...(init?.headers ?? {}),
+    },
+  });
+  if (!res.ok) {
+    const body = (await res.json().catch(() => ({}))) as {
+      error?: string;
+      details?: string[];
+    };
+    if (res.status === 401 || res.status === 426) reportUnauthorized(res.status, body.error);
+    const code = body.error ?? `request failed: ${res.status}`;
+    const detailSuffix =
+      Array.isArray(body.details) && body.details.length > 0
+        ? `: ${body.details.join(", ")}`
+        : "";
+    const err = new Error(`${code}${detailSuffix}`) as ApiError;
+    err.status = res.status;
+    err.code = body.error;
+    err.details = body.details;
+    throw err;
+  }
+  return res.json() as Promise<T>;
+}
+
+export async function fetchAuthConfig() {
+  const res = await fetch(apiUrl("/auth/config"));
+  if (!res.ok) throw new Error(`auth config failed: ${res.status}`);
+  return res.json() as Promise<{ github: boolean }>;
+}
+
+export async function fetchMe() {
+  const res = await fetch(apiUrl("/me"), { credentials: apiCredentials(), headers: apiHeaders() });
+  if (res.status === 401) return null;
+  if (res.status === 426) {
+    const body = (await res.json().catch(() => ({}))) as { error?: string };
+    reportUnauthorized(426, body.error);
+    return null;
+  }
+  if (!res.ok) throw new Error(`me failed: ${res.status}`);
+  return res.json() as Promise<{
+    user: {
+      id: string;
+      email: string;
+      name: string;
+    };
+  }>;
+}
+
+export function createWorkspace(name: string) {
+  return api<{
+    workspace: {
+      id: string;
+      name: string;
+      slug: string;
+      role: string;
+    };
+  }>("/workspaces", {
+    method: "POST",
+    body: JSON.stringify({ name }),
+  });
+}
+
+export type WorkspaceSummary = {
+  id: string;
+  name: string;
+  slug: string;
+  role: string;
+};
+
+export type WorkspaceMember = {
+  userId: string;
+  role: string;
+  name: string;
+  email: string;
+};
+
+export type WorkspaceInvitation = {
+  id: string;
+  email: string;
+  role: string;
+  expiresAt: string;
+};
+
+export function fetchWorkspacePeople(workspaceId: string) {
+  return api<{ members: WorkspaceMember[]; invitations: WorkspaceInvitation[] }>(
+    `/workspaces/${workspaceId}/members`,
+  );
+}
+
+export function inviteWorkspaceMember(
+  workspaceId: string,
+  input: { email: string; role: string },
+) {
+  return api<{ ok: true }>(`/workspaces/${workspaceId}/invitations`, {
+    method: "POST",
+    body: JSON.stringify(input),
+  });
+}
+
+export function changeWorkspaceMemberRole(
+  workspaceId: string,
+  userId: string,
+  role: string,
+) {
+  return api<{ ok: true }>(`/workspaces/${workspaceId}/members/${userId}`, {
+    method: "PATCH",
+    body: JSON.stringify({ role }),
+  });
+}
+
+export function removeWorkspaceMember(workspaceId: string, userId: string) {
+  return api<{ ok: true }>(`/workspaces/${workspaceId}/members/${userId}`, {
+    method: "DELETE",
+  });
+}
+
+export function revokeWorkspaceInvitation(workspaceId: string, invitationId: string) {
+  return api<{ ok: true }>(
+    `/workspaces/${workspaceId}/invitations/${invitationId}`,
+    { method: "DELETE" },
+  );
+}
+
+export function acceptWorkspaceInvitation(token: string) {
+  return api<{ ok: true; workspaceId: string; slug: string }>("/invitations/accept", {
+    method: "POST",
+    body: JSON.stringify({ token }),
+  });
+}
+
+export function fetchAllWorkspaces() {
+  return api<{ workspaces: WorkspaceSummary[] }>("/workspaces");
+}
+
+export type WorkspaceDetail = {
+  id: string;
+  name: string;
+  slug: string;
+  role: string;
+  githubInstallationId: string | null;
+  githubRepoFullName: string | null;
+  githubDefaultBranch: string | null;
+  contentRoot: string | null;
+  githubDirectory: string | null;
+  locales: string[];
+  siteUrls: string[];
+  /** Last `@backmatter/studio` version each site reported, keyed by origin. */
+  studioVersions?: Record<string, { version: string; seenAt: string }>;
+  hasContentToken: boolean;
+  hasPreviewToken: boolean;
+  hasHostToken: boolean;
+};
+
+export function fetchWorkspace(workspaceId: string) {
+  return api<{ workspace: WorkspaceDetail }>(`/workspaces/${workspaceId}`);
+}
+
+export function fetchReplica(workspaceId: string, cache?: ReplicaCache) {
+  const query = cache ? `?${replicaQuery(cache)}` : "";
+  return api<ReplicaBody>(`/workspaces/${workspaceId}/replica${query}`);
+}
+
+export function patchWorkspace(
+  workspaceId: string,
+  input: { siteUrls: string[] },
+) {
+  return api<{ workspace: WorkspaceDetail }>(`/workspaces/${workspaceId}`, {
+    method: "PATCH",
+    body: JSON.stringify(input),
+  });
+}
+
+export function rotateContentToken(workspaceId: string) {
+  return api<{
+    token: string;
+    workspace: {
+      id: string;
+      hasContentToken: boolean;
+      hasPreviewToken: boolean;
+      hasHostToken: boolean;
+    };
+  }>(`/workspaces/${workspaceId}/content-token`, { method: "POST" });
+}
+
+export function rotatePreviewToken(workspaceId: string) {
+  return api<{
+    token: string;
+    workspace: {
+      id: string;
+      hasContentToken: boolean;
+      hasPreviewToken: boolean;
+      hasHostToken: boolean;
+    };
+  }>(`/workspaces/${workspaceId}/preview-token`, { method: "POST" });
+}
+
+export function rotateHostToken(workspaceId: string) {
+  return api<{
+    token: string;
+    workspace: {
+      id: string;
+      hasContentToken: boolean;
+      hasPreviewToken: boolean;
+      hasHostToken: boolean;
+    };
+  }>(`/workspaces/${workspaceId}/host-token`, { method: "POST" });
+}
+
+export function createPreviewTicket(
+  workspaceId: string,
+  input: { redirect: string; branch?: string | null; tree?: string | null },
+) {
+  return api<{ ticket: string; expiresInMs: number }>(`/workspaces/${workspaceId}/preview-ticket`, {
+    method: "POST",
+    body: JSON.stringify({
+      redirect: input.redirect,
+      ...(input.branch ? { branch: input.branch } : {}),
+      ...(input.tree ? { tree: input.tree } : {}),
+    }),
+  });
+}
+
+export function githubInstallUrl(workspaceId: string) {
+  return apiUrl(`/workspaces/${workspaceId}/github/install`);
+}
+
+export type GithubInstallationChoice = {
+  id: string;
+  account: string | null;
+};
+
+export function attachGithubInstallation(
+  workspaceId: string,
+  installationId?: string,
+) {
+  return api<{
+    installationId: string | null;
+    installations: GithubInstallationChoice[];
+    installUrl: string | null;
+  }>(`/workspaces/${workspaceId}/github/installation`, {
+    method: "POST",
+    body: JSON.stringify(installationId ? { installationId } : {}),
+  });
+}
+
+export function fetchGithubRepos(workspaceId: string) {
+  return api<{
+    repos: Array<{ fullName: string; defaultBranch: string }>;
+  }>(`/workspaces/${workspaceId}/github/repos`);
+}
+
+export function bindGithub(
+  workspaceId: string,
+  input: {
+    repoFullName: string;
+    defaultBranch: string;
+    githubDirectory?: string | null;
+  },
+) {
+  return api<{ workspace: unknown; import: unknown }>(
+    `/workspaces/${workspaceId}/github`,
+    {
+      method: "PUT",
+      body: JSON.stringify(input),
+    },
+  );
+}
+
+export function unbindGithub(workspaceId: string) {
+  return api<{ workspace: WorkspaceDetail }>(
+    `/workspaces/${workspaceId}/github`,
+    { method: "DELETE" },
+  );
+}
+
+export type SchemaField = {
+  kind: string;
+  required?: boolean;
+  relationTo?: string;
+  object?: string;
+  fields?: Record<string, SchemaField>;
+  /** Studio input name from `field.text({ input })`; see `defineStudio`. */
+  input?: string;
+};
+
+export type BlockSnapshot = {
+  name: string;
+  fields: Record<string, SchemaField>;
+};
+
+export type SchemaPayload = {
+  version: number;
+  models: Array<{
+    type: string;
+    path: string;
+    route?: string | false;
+    singleton?: boolean;
+    indexSlug?: string;
+    format?: "mdx" | "page";
+    fields: Record<string, SchemaField>;
+  }>;
+  blocks?: BlockSnapshot[];
+  /** In-content blocks from the client `richtext/` directory. */
+  richtext?: BlockSnapshot[];
+  objects?: Array<{ name: string; fields: Record<string, SchemaField> }>;
+};
+
+export function fetchSchema(workspaceId: string) {
+  return api<{
+    schema: {
+      id: string;
+      version: number;
+      branch?: string;
+      payload: SchemaPayload;
+    } | null;
+    branch?: string;
+  }>(`/workspaces/${workspaceId}/schema`);
+}
+
+/** Uncommitted file state against branch HEAD. */
+export type ChangeStatus = "modified" | "added" | "conflict" | "deleted";
+/** Per-doc status in lists; `clean` = identical to HEAD. */
+export type DocStatus = "clean" | ChangeStatus;
+
+export type GitChange = {
+  locale: string;
+  type: string;
+  slug: string;
+  status: ChangeStatus;
+};
+
+export type GitHead = { sha: string; updatedAt: string };
+
+/** `git status` for the current user on their checked-out branch. */
+export type GitState = {
+  defaultBranch: string;
+  currentBranch: string;
+  branches: Array<{ name: string }>;
+  /** Set when GitHub could not list branches. Status still returns local changes. */
+  githubError?: "installation_missing" | "github_list_failed" | null;
+  head: GitHead | null;
+  changes: GitChange[];
+};
+
+export function countConflicts(state: Pick<GitState, "changes"> | null | undefined) {
+  return (state?.changes ?? []).filter((c) => c.status === "conflict").length;
+}
+
+export function fetchGit(workspaceId: string) {
+  return api<GitState>(`/workspaces/${workspaceId}/git`);
+}
+
+export function checkoutBranch(workspaceId: string, branch: string) {
+  return api<{ currentBranch: string; import: unknown }>(
+    `/workspaces/${workspaceId}/git/checkout`,
+    {
+      method: "POST",
+      body: JSON.stringify({ branch }),
+    },
+  );
+}
+
+export function createGitBranch(
+  workspaceId: string,
+  input: { name: string; from?: string },
+) {
+  return api<{ currentBranch: string; from: string; import: unknown }>(
+    `/workspaces/${workspaceId}/git/branches`,
+    {
+      method: "POST",
+      body: JSON.stringify(input),
+    },
+  );
+}
+
+export type CommitResult = {
+  commitSha: string;
+  message: string;
+  branch: string;
+  files: Array<{
+    locale: string;
+    type: string;
+    slug: string;
+    githubPath: string;
+    githubSha: string;
+  }>;
+};
+
+/** Commit every uncommitted file in my working tree on the checked-out branch. */
+export function commitWorkspace(workspaceId: string, message?: string) {
+  return api<CommitResult>(`/workspaces/${workspaceId}/git/commit`, {
+    method: "POST",
+    body: JSON.stringify(message?.trim() ? { message: message.trim() } : {}),
+  });
+}
+
+/** Default commit message the server uses when none is given (mirrored for the placeholder). */
+export function defaultCommitMessage(changes: GitChange[]) {
+  if (changes.length === 1) {
+    const f = changes[0]!;
+    return `backmatter: update ${f.type}/${f.slug} (${f.locale})`;
+  }
+  return `backmatter: update ${changes.length} files`;
+}
+
+/** Something about the workspace (branch, schema, binding) changed; reload everything. */
+export function notifyWorkspaceChanged() {
+  window.dispatchEvent(new Event("backmatter:workspace-changed"));
+}
+
+export type TreeChangeDetail = {
+  workspaceId: string;
+  locale: string;
+  type: string;
+  slug: string;
+  status?: DocStatus;
+  /** Drop the doc from the local list instead of changing its status. */
+  remove?: boolean;
+};
+
+/** My working tree changed (save, revert, resolve, commit); refresh statuses. */
+export function notifyTreeChanged(detail?: TreeChangeDetail) {
+  window.dispatchEvent(
+    new CustomEvent<TreeChangeDetail>("backmatter:tree-changed", { detail }),
+  );
+}
+
+/** Branch HEAD moved (teammate push, pull, commit); clean docs should reload. */
+export function notifyHeadChanged() {
+  window.dispatchEvent(new Event("backmatter:head-changed"));
+}
+
+/**
+ * A commit just landed. Mark those files clean (or drop deletes) before the
+ * replica refetch returns, so the top bar count updates on this frame.
+ */
+export function publishCommittedFiles(
+  workspaceId: string,
+  files: Array<{ locale: string; type: string; slug: string; githubSha: string }>,
+) {
+  for (const file of files) {
+    notifyTreeChanged({
+      workspaceId,
+      locale: file.locale,
+      type: file.type,
+      slug: file.slug,
+      ...(file.githubSha ? { status: "clean" } : { remove: true }),
+    });
+  }
+  notifyHeadChanged();
+}
+
+export function putSchema(workspaceId: string, payload: SchemaPayload) {
+  return api<{
+    schema: { id: string; version: number; payload: SchemaPayload };
+  }>(`/workspaces/${workspaceId}/schema`, {
+    method: "PUT",
+    body: JSON.stringify(payload),
+  });
+}
+
+export type ImportResult = {
+  imported: number;
+  deleted: number;
+  skipped: number;
+  errors: string[];
+  headSha: string | null;
+};
+
+/** Full re-import of the checked-out branch from GitHub. Recovery for a missed webhook. */
+export async function importContent(workspaceId: string) {
+  const body = await api<{ result: ImportResult }>(
+    `/workspaces/${workspaceId}/content/import`,
+    { method: "POST", signal: AbortSignal.timeout(90_000) },
+  );
+  if (body.result.errors.length > 0) {
+    const err = new Error(body.result.errors.join("; ")) as ApiError;
+    err.status = 502;
+    err.code = "github_import_failed";
+    throw err;
+  }
+  return body;
+}
+
+export const pullFromGithub = importContent;
+
+export type DocListItem = {
+  locale: string;
+  type: string;
+  slug: string;
+  status: DocStatus;
+};
+
+export { encodeDocLocale };
+
+export function docApiPath(
+  workspaceId: string,
+  locale: string,
+  type: string,
+  slug: string,
+  suffix = "",
+) {
+  return `/workspaces/${workspaceId}/docs/${encodeURIComponent(encodeDocLocale(locale))}/${encodeURIComponent(type)}/${encodeURIComponent(slug)}${suffix}`;
+}
+
+export function fetchDocs(workspaceId: string) {
+  return api<{ docs: DocListItem[] }>(`/workspaces/${workspaceId}/docs`);
+}
+
+export function fetchDoc(
+  workspaceId: string,
+  locale: string,
+  type: string,
+  slug: string,
+) {
+  return api<{
+    doc: {
+      locale: string;
+      type: string;
+      slug: string;
+      branch: string;
+      /** Working tree owner (my user id), for preview URLs. */
+      tree: string;
+      source: ContentSource;
+      status: DocStatus;
+      headSha: string | null;
+      frontmatter: Record<string, unknown>;
+      body: string;
+      raw: string;
+      model: {
+        type: string;
+        path: string;
+        format?: "mdx" | "page";
+        fields: Record<
+          string,
+          { kind: string; required?: boolean; relationTo?: string }
+        >;
+      } | null;
+      parseError?: string | null;
+    };
+  }>(docApiPath(workspaceId, locale, type, slug));
+}
+
+/** `head` = committed on the branch; `tree` = my uncommitted working copy. */
+export type ContentSource = "head" | "tree";
+
+/** Save into my working tree (autosave). */
+export function saveDoc(
+  workspaceId: string,
+  locale: string,
+  type: string,
+  slug: string,
+  input: { frontmatter: Record<string, unknown>; body: string },
+) {
+  return api<{
+    doc: {
+      locale: string;
+      type: string;
+      slug: string;
+      source: "tree";
+      status: DocStatus;
+      headSha: string | null;
+      raw: string;
+    };
+  }>(docApiPath(workspaceId, locale, type, slug), {
+    method: "PUT",
+    body: JSON.stringify(input),
+  });
+}
+
+/** Drop my uncommitted copy; the doc reads from HEAD again. */
+export function revertDoc(
+  workspaceId: string,
+  locale: string,
+  type: string,
+  slug: string,
+) {
+  return api<{ ok: true }>(
+    docApiPath(workspaceId, locale, type, slug, "/tree"),
+    { method: "DELETE" },
+  );
+}
+
+/** Resolve a conflict: keep mine (rebase onto the new HEAD) or take theirs (revert). */
+export function resolveDoc(
+  workspaceId: string,
+  locale: string,
+  type: string,
+  slug: string,
+  strategy: "mine" | "theirs",
+) {
+  return api<{ ok: true; status: DocStatus; headSha: string | null }>(
+    docApiPath(workspaceId, locale, type, slug, "/resolve"),
+    { method: "POST", body: JSON.stringify({ strategy }) },
+  );
+}
+
+// ---------------------------------------------------------------------------
+// AI chat
+// ---------------------------------------------------------------------------
+
+export type AiModelInfo = { id: string; provider: string; label: string };
+export type AiTier = "ask" | "content" | "developer";
+
+export function fetchAiModels(workspaceId: string) {
+  return api<{ models: AiModelInfo[]; defaultModel: string | null; tier: AiTier }>(
+    `/workspaces/${workspaceId}/ai/models`,
+  );
+}
+
+export type ChatThread = {
+  id: string;
+  workspaceId: string;
+  userId: string;
+  branch: string;
+  title: string;
+  createdAt: string;
+  updatedAt: string;
+};
+
+export type ChatChangeStatus = "applied" | "kept" | "undone";
+
+export type ChatChangeDiff = {
+  added: number;
+  removed: number;
+  renamedFrom?: string;
+  hunks: Array<{
+    oldStart: number;
+    oldLines: number;
+    newStart: number;
+    newLines: number;
+    lines: string[];
+  }>;
+};
+
+export type ChatChangeSummary = {
+  id: string;
+  threadId: string;
+  messageId: string | null;
+  workspaceId: string;
+  userId: string;
+  branch: string;
+  resourceKind: "content";
+  locale: string;
+  type: string;
+  slug: string;
+  op: "write" | "create";
+  beforeSource: ContentSource | null;
+  diff: ChatChangeDiff | null;
+  status: ChatChangeStatus;
+  createdAt: string;
+  /** Present on tool outputs only. */
+  summary?: string;
+};
+
+export function fetchThreads(workspaceId: string) {
+  return api<{ threads: ChatThread[] }>(`/workspaces/${workspaceId}/ai/threads`);
+}
+
+export function createThread(workspaceId: string, title?: string) {
+  return api<{ thread: ChatThread }>(`/workspaces/${workspaceId}/ai/threads`, {
+    method: "POST",
+    body: JSON.stringify(title ? { title } : {}),
+  });
+}
+
+export function fetchThread(workspaceId: string, threadId: string) {
+  return api<{
+    thread: ChatThread;
+    messages: unknown[];
+    changes: ChatChangeSummary[];
+  }>(`/workspaces/${workspaceId}/ai/threads/${threadId}`);
+}
+
+export function renameThread(workspaceId: string, threadId: string, title: string) {
+  return api<{ thread: ChatThread }>(
+    `/workspaces/${workspaceId}/ai/threads/${threadId}`,
+    { method: "PATCH", body: JSON.stringify({ title }) },
+  );
+}
+
+export function deleteThread(workspaceId: string, threadId: string) {
+  return api<{ ok: true }>(`/workspaces/${workspaceId}/ai/threads/${threadId}`, {
+    method: "DELETE",
+  });
+}
+
+export function aiMessagesUrl(workspaceId: string, threadId: string) {
+  return apiUrl(`/workspaces/${workspaceId}/ai/threads/${threadId}/messages`);
+}
+
+export function keepChange(workspaceId: string, changeId: string) {
+  return api<{ change: ChatChangeSummary }>(
+    `/workspaces/${workspaceId}/ai/changes/${changeId}/keep`,
+    { method: "POST" },
+  );
+}
+
+export function undoChange(workspaceId: string, changeId: string) {
+  return api<{ change: ChatChangeSummary }>(
+    `/workspaces/${workspaceId}/ai/changes/${changeId}/undo`,
+    { method: "POST" },
+  );
+}
+
+export function keepAllChanges(workspaceId: string, threadId: string, messageId: string) {
+  return api<{ changes: ChatChangeSummary[] }>(
+    `/workspaces/${workspaceId}/ai/threads/${threadId}/messages/${messageId}/changes/keep-all`,
+    { method: "POST" },
+  );
+}
+
+export function undoAllChanges(workspaceId: string, threadId: string, messageId: string) {
+  return api<{ changes: ChatChangeSummary[] }>(
+    `/workspaces/${workspaceId}/ai/threads/${threadId}/messages/${messageId}/changes/undo-all`,
+    { method: "POST" },
+  );
+}
+
+export type McpStatus = "unknown" | "connected" | "error" | "needs_auth";
+export type McpScope = "user" | "workspace";
+
+export type McpToolCache = {
+  name: string;
+  description: string;
+  enabled: boolean;
+};
+
+export type McpConnector = {
+  id: string;
+  scope: McpScope;
+  userId: string | null;
+  workspaceId: string | null;
+  name: string;
+  slug: string;
+  url: string;
+  enabled: boolean;
+  status: McpStatus;
+  statusError: string | null;
+  lastSeenAt: string | null;
+  tools: McpToolCache[];
+  createdBy: string;
+  createdAt: string;
+  updatedAt: string;
+  toolCount: number;
+};
+
+export type McpWriteBody = {
+  name?: string;
+  url?: string;
+  headers?: Record<string, string>;
+  enabled?: boolean;
+  tools?: Array<{ name: string; enabled: boolean }>;
+};
+
+export function fetchUserMcp() {
+  return api<{ connectors: McpConnector[] }>("/me/mcp");
+}
+
+export function createUserMcp(body: McpWriteBody) {
+  return api<{ connector: McpConnector }>("/me/mcp", {
+    method: "POST",
+    body: JSON.stringify(body),
+  });
+}
+
+export function updateUserMcp(id: string, body: McpWriteBody) {
+  return api<{ connector: McpConnector }>(`/me/mcp/${id}`, {
+    method: "PATCH",
+    body: JSON.stringify(body),
+  });
+}
+
+export function deleteUserMcp(id: string) {
+  return api<{ ok: true }>(`/me/mcp/${id}`, { method: "DELETE" });
+}
+
+export function testUserMcp(id: string) {
+  return api<{ connector: McpConnector }>(`/me/mcp/${id}/test`, { method: "POST" });
+}
+
+export function fetchWorkspaceMcp(workspaceId: string) {
+  return api<{ connectors: McpConnector[] }>(`/workspaces/${workspaceId}/mcp`);
+}
+
+export function createWorkspaceMcp(workspaceId: string, body: McpWriteBody) {
+  return api<{ connector: McpConnector }>(`/workspaces/${workspaceId}/mcp`, {
+    method: "POST",
+    body: JSON.stringify(body),
+  });
+}
+
+export function updateWorkspaceMcp(
+  workspaceId: string,
+  id: string,
+  body: McpWriteBody,
+) {
+  return api<{ connector: McpConnector }>(`/workspaces/${workspaceId}/mcp/${id}`, {
+    method: "PATCH",
+    body: JSON.stringify(body),
+  });
+}
+
+export function deleteWorkspaceMcp(workspaceId: string, id: string) {
+  return api<{ ok: true }>(`/workspaces/${workspaceId}/mcp/${id}`, {
+    method: "DELETE",
+  });
+}
+
+export function testWorkspaceMcp(workspaceId: string, id: string) {
+  return api<{ connector: McpConnector }>(
+    `/workspaces/${workspaceId}/mcp/${id}/test`,
+    { method: "POST" },
+  );
+}