march-control-cli 0.1.3

package/src/lib/client.ts

@@ -0,0 +1,944 @@
+import type {
+  AppSnapshot,
+  McpServer,
+  PlatformId,
+  PlatformSnapshot,
+  ProbeResult,
+  PromptProfile,
+  Provider,
+  SkillProfile,
+  SkillRepo
+} from "../types";
+
+const STORAGE_KEY = "march-control-state";
+const API_PREFIX = "/api";
+const DEFAULT_MODELS = ["gpt-5.4", "gpt-5.3-codex", "gpt-5.2", "gpt-5.2-codex", "gpt-5.1-codex-mini", "gpt-5.1-codex-max"];
+const DEFAULT_PLATFORMS: PlatformId[] = ["codex", "opencode", "openclaw"];
+
+type StoredProvider = Omit<Provider, "maskedApiKey"> & { apiKey: string };
+type StoredPlatform = Omit<PlatformSnapshot, "providers"> & { providers: StoredProvider[] };
+type StoredSnapshot = Omit<AppSnapshot, "platforms"> & { platforms: StoredPlatform[] };
+
+type PlatformsApiResponse = {
+  appName?: string;
+  version?: string;
+  generatedAt?: string;
+  models?: string[];
+  platforms: PlatformSnapshot[];
+  mcpServers?: McpServer[];
+  prompts?: PromptProfile[];
+  skills?: SkillProfile[];
+  skillRepos?: SkillRepo[];
+};
+
+type ProbePlatformApiResponse = {
+  results: ProbeResult[];
+  best?: ProbeResult | null;
+};
+
+type ProbeCandidateApiResponse = {
+  result: ProbeResult | null;
+};
+
+type OpenPathApiResponse = {
+  ok: true;
+  targetPath: string;
+};
+
+type DesktopBridge = NonNullable<Window["marchDesktop"]>;
+
+type DesktopSnapshotResponse = {
+  appName?: string;
+  version?: string;
+  generatedAt?: string;
+  models?: Array<string | { id?: string }>;
+  platforms: PlatformSnapshot[];
+  mcpServers?: McpServer[];
+  prompts?: PromptProfile[];
+  skills?: SkillProfile[];
+  skillRepos?: SkillRepo[];
+};
+
+function getDesktopBridge(): DesktopBridge | null {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  return window.marchDesktop ?? null;
+}
+
+function normalizeBridgeModels(models?: Array<string | { id?: string }>) {
+  if (!Array.isArray(models)) {
+    return undefined;
+  }
+
+  return models
+    .map((item) => (typeof item === "string" ? item : `${item?.id || ""}`))
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+class ApiUnavailableError extends Error {
+  constructor(message = "本地 API 不可用") {
+    super(message);
+    this.name = "ApiUnavailableError";
+  }
+}
+
+function isApiUnavailable(error: unknown): error is ApiUnavailableError {
+  return error instanceof ApiUnavailableError;
+}
+
+function maskApiKey(apiKey: string) {
+  if (!apiKey) return "(empty)";
+  if (apiKey.length <= 8) return `${apiKey.slice(0, 2)}***${apiKey.slice(-2)}`;
+  return `${apiKey.slice(0, 4)}***${apiKey.slice(-4)}`;
+}
+
+function now() {
+  return new Date().toISOString();
+}
+
+function sanitizeModels(models?: string[]) {
+  if (!Array.isArray(models) || models.length === 0) {
+    return [...DEFAULT_MODELS];
+  }
+
+  const deduped = [...new Set(models.map((item) => `${item || ""}`.trim()).filter(Boolean))];
+  return deduped.length > 0 ? deduped : [...DEFAULT_MODELS];
+}
+
+function sanitizePlatforms(platforms?: PlatformId[]) {
+  if (!Array.isArray(platforms) || platforms.length === 0) {
+    return [...DEFAULT_PLATFORMS];
+  }
+
+  const allowed = new Set<PlatformId>(DEFAULT_PLATFORMS);
+  const deduped = [...new Set(platforms)].filter((item): item is PlatformId => allowed.has(item));
+  return deduped.length > 0 ? deduped : [...DEFAULT_PLATFORMS];
+}
+
+function createProvider(name: string, baseUrl: string, model: string, apiKey: string, isActive: boolean): StoredProvider {
+  return {
+    id: `${name.toLowerCase()}-${Math.random().toString(36).slice(2, 8)}`,
+    name,
+    baseUrl,
+    model,
+    apiKey,
+    isActive,
+    updatedAt: now()
+  };
+}
+
+function createMcpServer(
+  id: string,
+  name: string,
+  description: string,
+  tags: string[],
+  enabledPlatforms: PlatformId[],
+  homepage?: string
+): McpServer {
+  return { id, name, description, tags, enabledPlatforms, homepage };
+}
+
+function createPrompt(
+  id: string,
+  appType: PromptProfile["appType"],
+  name: string,
+  description: string,
+  content: string,
+  enabled: boolean
+): PromptProfile {
+  return { id, appType, name, description, content, enabled, updatedAt: now() };
+}
+
+function createSkill(id: string, name: string, description: string, directory: string, enabledPlatforms: PlatformId[]): SkillProfile {
+  return { id, name, description, directory, enabledPlatforms };
+}
+
+function createSkillRepo(id: string, owner: string, name: string, branch: string, enabled: boolean): SkillRepo {
+  return { id, owner, name, branch, enabled };
+}
+
+function createInitialState(): StoredSnapshot {
+  return {
+    appName: "March 控制台",
+    version: "0.3.0-alpha",
+    generatedAt: now(),
+    models: [...DEFAULT_MODELS],
+    platforms: [
+      {
+        id: "codex",
+        label: "Codex",
+        currentProviderName: "March CN",
+        providerCount: 2,
+        targetFiles: ["~/.codex/config.toml", "~/.codex/auth.json"],
+        providers: [
+          createProvider("March CN", "https://gmncode.cn", "gpt-5.4", "sk-live-demo-march-cn", true),
+          createProvider("OpenAI Official", "https://api.openai.com", "gpt-5.4", "sk-live-demo-openai", false)
+        ]
+      },
+      {
+        id: "opencode",
+        label: "OpenCode",
+        currentProviderName: "March CN",
+        providerCount: 2,
+        targetFiles: ["~/.config/opencode/opencode.json"],
+        providers: [
+          createProvider("March CN", "https://gmncode.cn", "gpt-5.4", "sk-live-demo-march-cn", true),
+          createProvider("Backup Relay", "https://relay.example.com", "gpt-5.3-codex", "sk-live-demo-backup", false)
+        ]
+      },
+      {
+        id: "openclaw",
+        label: "OpenClaw",
+        currentProviderName: "March CN",
+        providerCount: 1,
+        targetFiles: ["~/.openclaw/openclaw.json", "~/.openclaw/agents/main/agent/models.json"],
+        providers: [createProvider("March CN", "https://gmncode.cn/v1", "gpt-5.4", "sk-live-demo-march-cn", true)]
+      }
+    ],
+    mcpServers: [
+      createMcpServer("filesystem", "文件系统", "已挂载工作区根目录，可读写", ["files", "storage"], ["codex", "opencode", "openclaw"]),
+      createMcpServer("browser", "浏览器", "可访问文档、版本发布和参考资料", ["web", "docs"], ["codex", "openclaw"]),
+      createMcpServer("git", "Git", "可读取仓库元数据与分支关系", ["code", "history"], ["codex", "opencode", "openclaw"]),
+      createMcpServer("shell", "命令行", "可在工作区边界内执行本地命令", ["terminal"], ["codex", "opencode"])
+    ],
+    prompts: [
+      createPrompt(
+        "default-coding",
+        "global",
+        "默认编码",
+        "用于开发实现、调试和仓库级改动。",
+        "优先做可落地实现、Provider 流程和直接代码修改，减少空泛规划。",
+        true
+      ),
+      createPrompt(
+        "ui-review",
+        "codex",
+        "界面评审",
+        "用于视觉比对、布局评估和细节打磨。",
+        "按目标参考评审当前界面，识别间距、密度、交互和品牌表达差距。",
+        false
+      ),
+      createPrompt(
+        "provider-setup",
+        "openclaw",
+        "Provider 配置",
+        "用于中转配置、路由切换和安装流程。",
+        "重点检查 Provider 连通性、路由健康度、代理设置和目标配置文件。",
+        true
+      )
+    ],
+    skills: [
+      createSkill("openai-docs", "openai-docs", "查询 OpenAI 官方文档", "~/.codex/skills/.system/openai-docs", ["codex"]),
+      createSkill("plugin-creator", "plugin-creator", "创建并生成 Codex 插件骨架", "~/.codex/skills/.system/plugin-creator", ["codex"]),
+      createSkill("skill-installer", "skill-installer", "从精选来源安装技能", "~/.codex/skills/.system/skill-installer", ["codex"]),
+      createSkill("xianyu-keyword-research", "xianyu-keyword-research", "构建闲鱼关键词结构化词池", "~/.codex/skills/xianyu-keyword-research", [
+        "codex",
+        "openclaw"
+      ])
+    ],
+    skillRepos: [
+      createSkillRepo("anthropics-skills", "anthropics", "skills", "main", true),
+      createSkillRepo("composio-awesome-claude-skills", "ComposioHQ", "awesome-claude-skills", "master", true),
+      createSkillRepo("cexll-myclaude", "cexll", "myclaude", "master", true),
+      createSkillRepo("jimliu-baoyu-skills", "JimLiu", "baoyu-skills", "main", true)
+    ]
+  };
+}
+
+function loadState(): StoredSnapshot {
+  const raw = localStorage.getItem(STORAGE_KEY);
+  if (!raw) {
+    const next = createInitialState();
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(next));
+    return next;
+  }
+
+  try {
+    const parsed = JSON.parse(raw) as Partial<StoredSnapshot>;
+    const fallback = createInitialState();
+    return {
+      ...fallback,
+      ...parsed,
+      models: sanitizeModels(parsed.models ?? fallback.models),
+      platforms: parsed.platforms ?? fallback.platforms,
+      mcpServers: parsed.mcpServers ?? fallback.mcpServers,
+      prompts: parsed.prompts ?? fallback.prompts,
+      skills: parsed.skills ?? fallback.skills,
+      skillRepos: parsed.skillRepos ?? fallback.skillRepos
+    } as StoredSnapshot;
+  } catch {
+    const next = createInitialState();
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(next));
+    return next;
+  }
+}
+
+function saveState(snapshot: StoredSnapshot) {
+  localStorage.setItem(
+    STORAGE_KEY,
+    JSON.stringify({
+      ...snapshot,
+      generatedAt: now(),
+      models: sanitizeModels(snapshot.models),
+      platforms: snapshot.platforms.map((platform) => ({
+        ...platform,
+        providerCount: platform.providers.length,
+        currentProviderName: platform.providers.find((provider) => provider.isActive)?.name || null
+      }))
+    })
+  );
+}
+
+function toPublic(snapshot: StoredSnapshot): AppSnapshot {
+  return {
+    ...snapshot,
+    models: sanitizeModels(snapshot.models),
+    platforms: snapshot.platforms.map((platform) => ({
+      ...platform,
+      providerCount: platform.providers.length,
+      currentProviderName: platform.providers.find((provider) => provider.isActive)?.name || null,
+      providers: platform.providers.map((provider) => ({
+        id: provider.id,
+        name: provider.name,
+        baseUrl: provider.baseUrl,
+        model: provider.model,
+        maskedApiKey: maskApiKey(provider.apiKey),
+        isActive: provider.isActive,
+        updatedAt: provider.updatedAt
+      }))
+    }))
+  };
+}
+
+function normalizeLivePlatform(platform: PlatformSnapshot): PlatformSnapshot {
+  return {
+    id: platform.id,
+    label: platform.label,
+    currentProviderName: platform.currentProviderName || null,
+    providerCount: platform.providerCount,
+    targetFiles: Array.isArray(platform.targetFiles) ? platform.targetFiles : [],
+    providers: platform.providers.map((provider) => ({
+      id: provider.id,
+      name: provider.name,
+      baseUrl: provider.baseUrl,
+      model: provider.model,
+      maskedApiKey: provider.maskedApiKey || "(hidden)",
+      isActive: provider.isActive,
+      updatedAt: provider.updatedAt || now()
+    }))
+  };
+}
+
+function toStoredPlatforms(platforms: PlatformSnapshot[]): StoredPlatform[] {
+  return platforms.map((platform) => ({
+    id: platform.id,
+    label: platform.label,
+    currentProviderName: platform.currentProviderName || null,
+    providerCount: platform.providerCount,
+    targetFiles: Array.isArray(platform.targetFiles) ? platform.targetFiles : [],
+    providers: platform.providers.map((provider) => ({
+      id: provider.id,
+      name: provider.name,
+      baseUrl: provider.baseUrl,
+      model: provider.model,
+      apiKey: "",
+      isActive: provider.isActive,
+      updatedAt: provider.updatedAt || now()
+    }))
+  }));
+}
+
+function withLiveSnapshot(snapshot: StoredSnapshot, livePlatforms: PlatformSnapshot[]): AppSnapshot {
+  const base = toPublic(snapshot);
+  return {
+    ...base,
+    platforms: livePlatforms
+  };
+}
+
+function getPlatform(snapshot: StoredSnapshot, platformId: PlatformId) {
+  const platform = snapshot.platforms.find((item) => item.id === platformId);
+  if (!platform) throw new Error(`Platform not found: ${platformId}`);
+  return platform;
+}
+
+async function readApiError(response: Response) {
+  let fallback = `Request failed (${response.status})`;
+  const text = await response.text();
+  if (!text) {
+    return fallback;
+  }
+
+  try {
+    const parsed = JSON.parse(text) as { error?: string; message?: string };
+    return parsed.error || parsed.message || fallback;
+  } catch {
+    fallback = text.trim() || fallback;
+    return fallback;
+  }
+}
+
+async function requestApi<T>(path: string, options: RequestInit = {}): Promise<T> {
+  const headers = new Headers(options.headers ?? {});
+  if (options.body !== undefined && !headers.has("Content-Type")) {
+    headers.set("Content-Type", "application/json");
+  }
+
+  let response: Response;
+  try {
+    response = await fetch(`${API_PREFIX}${path}`, { ...options, headers });
+  } catch {
+    throw new ApiUnavailableError();
+  }
+
+  if (!response.ok) {
+    if (response.status === 404 || response.status === 405) {
+      throw new ApiUnavailableError();
+    }
+    throw new Error(await readApiError(response));
+  }
+
+  if (response.status === 204) {
+    return undefined as T;
+  }
+
+  return (await response.json()) as T;
+}
+
+function localSaveProvider(input: { platform: PlatformId; name: string; baseUrl: string; apiKey: string; model: string }) {
+  const snapshot = loadState();
+  const platform = getPlatform(snapshot, input.platform);
+  const existing = platform.providers.find((provider) => provider.name.trim().toLowerCase() === input.name.trim().toLowerCase());
+
+  platform.providers = platform.providers.map((provider) => ({ ...provider, isActive: false }));
+
+  if (existing) {
+    existing.baseUrl = input.baseUrl;
+    existing.apiKey = input.apiKey;
+    existing.model = input.model;
+    existing.updatedAt = now();
+    existing.isActive = true;
+  } else {
+    platform.providers.unshift(createProvider(input.name.trim(), input.baseUrl.trim(), input.model.trim(), input.apiKey.trim(), true));
+  }
+
+  saveState(snapshot);
+  return toPublic(snapshot);
+}
+
+function localActivateProvider(input: { platform: PlatformId; providerId: string }) {
+  const snapshot = loadState();
+  const platform = getPlatform(snapshot, input.platform);
+  platform.providers = platform.providers.map((provider) => ({ ...provider, isActive: provider.id === input.providerId }));
+  saveState(snapshot);
+  return toPublic(snapshot);
+}
+
+function localProbePlatform(platformId: PlatformId) {
+  const snapshot = loadState();
+  const platform = getPlatform(snapshot, platformId);
+  const results: ProbeResult[] = platform.providers.map((provider, index) => ({
+    baseUrl: provider.baseUrl,
+    ok: true,
+    latency: 68 + index * 17 + Math.floor(Math.random() * 35)
+  }));
+  return results.sort((left, right) => left.latency - right.latency);
+}
+
+function localUpsertMcp(input: {
+  id?: string;
+  name: string;
+  description: string;
+  tags: string[];
+  enabledPlatforms: PlatformId[];
+  homepage?: string;
+}) {
+  const snapshot = loadState();
+  const payload: McpServer = {
+    id: `${input.id || `mcp-${Date.now().toString(36)}`}`.trim(),
+    name: input.name.trim(),
+    description: input.description.trim(),
+    tags: Array.isArray(input.tags) ? [...new Set(input.tags.map((item) => `${item}`.trim()).filter(Boolean))] : [],
+    homepage: `${input.homepage || ""}`.trim() || undefined,
+    enabledPlatforms: sanitizePlatforms(input.enabledPlatforms)
+  };
+
+  const index = snapshot.mcpServers.findIndex((item) => item.id === payload.id);
+  if (index >= 0) {
+    snapshot.mcpServers[index] = payload;
+  } else {
+    snapshot.mcpServers.unshift(payload);
+  }
+
+  saveState(snapshot);
+  return toPublic(snapshot);
+}
+
+function localDeleteMcp(input: { serverId: string }) {
+  const snapshot = loadState();
+  snapshot.mcpServers = snapshot.mcpServers.filter((item) => item.id !== input.serverId);
+  saveState(snapshot);
+  return toPublic(snapshot);
+}
+
+function localUpsertPrompt(input: {
+  id?: string;
+  appType: "global" | PlatformId;
+  name: string;
+  description: string;
+  content: string;
+  enabled: boolean;
+}) {
+  const snapshot = loadState();
+  const payload = {
+    id: `${input.id || `prompt-${Date.now().toString(36)}`}`.trim(),
+    appType: input.appType,
+    name: input.name.trim(),
+    description: input.description.trim(),
+    content: input.content.trim(),
+    enabled: Boolean(input.enabled),
+    updatedAt: now()
+  };
+
+  const index = snapshot.prompts.findIndex((item) => item.id === payload.id);
+  if (index >= 0) {
+    snapshot.prompts[index] = payload;
+  } else {
+    snapshot.prompts.unshift(payload);
+  }
+
+  saveState(snapshot);
+  return toPublic(snapshot);
+}
+
+function localDeletePrompt(input: { promptId: string }) {
+  const snapshot = loadState();
+  snapshot.prompts = snapshot.prompts.filter((item) => item.id !== input.promptId);
+  saveState(snapshot);
+  return toPublic(snapshot);
+}
+
+function localUpsertSkill(input: {
+  id?: string;
+  name: string;
+  description: string;
+  directory: string;
+  enabledPlatforms: PlatformId[];
+}) {
+  const snapshot = loadState();
+  const payload: SkillProfile = {
+    id: `${input.id || `skill-${Date.now().toString(36)}`}`.trim(),
+    name: input.name.trim(),
+    description: input.description.trim(),
+    directory: input.directory.trim(),
+    enabledPlatforms: sanitizePlatforms(input.enabledPlatforms)
+  };
+
+  const index = snapshot.skills.findIndex((item) => item.id === payload.id);
+  if (index >= 0) {
+    snapshot.skills[index] = payload;
+  } else {
+    snapshot.skills.unshift(payload);
+  }
+
+  saveState(snapshot);
+  return toPublic(snapshot);
+}
+
+function localDeleteSkill(input: { skillId: string }) {
+  const snapshot = loadState();
+  snapshot.skills = snapshot.skills.filter((item) => item.id !== input.skillId);
+  saveState(snapshot);
+  return toPublic(snapshot);
+}
+
+async function getSnapshotInternal(): Promise<AppSnapshot> {
+  const snapshot = loadState();
+  const desktopBridge = getDesktopBridge();
+
+  if (desktopBridge) {
+    const response = (await desktopBridge.getSnapshot()) as DesktopSnapshotResponse;
+    const livePlatforms = response.platforms.map(normalizeLivePlatform);
+    const nextSnapshot: StoredSnapshot = {
+      ...snapshot,
+      appName: response.appName || snapshot.appName,
+      version: response.version || snapshot.version,
+      generatedAt: response.generatedAt || now(),
+      models: sanitizeModels(normalizeBridgeModels(response.models) ?? snapshot.models),
+      platforms: toStoredPlatforms(livePlatforms),
+      mcpServers: Array.isArray(response.mcpServers) ? response.mcpServers : snapshot.mcpServers,
+      prompts: Array.isArray(response.prompts) ? response.prompts : snapshot.prompts,
+      skills: Array.isArray(response.skills) ? response.skills : snapshot.skills,
+      skillRepos: Array.isArray(response.skillRepos) ? response.skillRepos : snapshot.skillRepos
+    };
+    saveState(nextSnapshot);
+    return withLiveSnapshot(nextSnapshot, livePlatforms);
+  }
+
+  try {
+    const response = await requestApi<PlatformsApiResponse>("/platforms");
+    const livePlatforms = response.platforms.map(normalizeLivePlatform);
+    const nextSnapshot: StoredSnapshot = {
+      ...snapshot,
+      appName: response.appName || snapshot.appName,
+      version: response.version || snapshot.version,
+      generatedAt: response.generatedAt || now(),
+      models: sanitizeModels(response.models ?? snapshot.models),
+      platforms: toStoredPlatforms(livePlatforms),
+      mcpServers: Array.isArray(response.mcpServers) ? response.mcpServers : snapshot.mcpServers,
+      prompts: Array.isArray(response.prompts) ? response.prompts : snapshot.prompts,
+      skills: Array.isArray(response.skills) ? response.skills : snapshot.skills,
+      skillRepos: Array.isArray(response.skillRepos) ? response.skillRepos : snapshot.skillRepos
+    };
+    saveState(nextSnapshot);
+    return withLiveSnapshot(nextSnapshot, livePlatforms);
+  } catch (error) {
+    if (!isApiUnavailable(error)) {
+      throw error;
+    }
+    return toPublic(snapshot);
+  }
+}
+
+export const client = {
+  getSnapshot: getSnapshotInternal,
+
+  async saveProvider(input: { platform: PlatformId; name: string; baseUrl: string; apiKey: string; model: string }) {
+    const desktopBridge = getDesktopBridge();
+    if (desktopBridge) {
+      await desktopBridge.saveProvider(input);
+      return getSnapshotInternal();
+    }
+
+    try {
+      await requestApi<{ snapshot: PlatformSnapshot }>("/save-provider", {
+        method: "POST",
+        body: JSON.stringify(input)
+      });
+      return getSnapshotInternal();
+    } catch (error) {
+      if (!isApiUnavailable(error)) {
+        throw error;
+      }
+      return localSaveProvider(input);
+    }
+  },
+
+  async activateProvider(input: { platform: PlatformId; providerId: string }) {
+    const desktopBridge = getDesktopBridge();
+    if (desktopBridge) {
+      await desktopBridge.activateProvider(input);
+      return getSnapshotInternal();
+    }
+
+    try {
+      await requestApi<{ snapshot: PlatformSnapshot }>("/activate-provider", {
+        method: "POST",
+        body: JSON.stringify(input)
+      });
+      return getSnapshotInternal();
+    } catch (error) {
+      if (!isApiUnavailable(error)) {
+        throw error;
+      }
+      return localActivateProvider(input);
+    }
+  },
+
+  async toggleMcpServer(input: { serverId: string; platform: PlatformId }) {
+    const desktopBridge = getDesktopBridge();
+    if (desktopBridge) {
+      await desktopBridge.toggleMcp(input);
+      return getSnapshotInternal();
+    }
+
+    try {
+      await requestApi<{ snapshot: AppSnapshot }>("/toggle-mcp", {
+        method: "POST",
+        body: JSON.stringify(input)
+      });
+      return getSnapshotInternal();
+    } catch (error) {
+      if (!isApiUnavailable(error)) {
+        throw error;
+      }
+
+      const snapshot = loadState();
+      snapshot.mcpServers = snapshot.mcpServers.map((server) =>
+        server.id !== input.serverId
+          ? server
+          : {
+              ...server,
+              enabledPlatforms: server.enabledPlatforms.includes(input.platform)
+                ? server.enabledPlatforms.filter((platform) => platform !== input.platform)
+                : [...server.enabledPlatforms, input.platform]
+            }
+      );
+      saveState(snapshot);
+      return toPublic(snapshot);
+    }
+  },
+
+  async upsertMcp(input: {
+    id?: string;
+    name: string;
+    description: string;
+    tags: string[];
+    enabledPlatforms: PlatformId[];
+    homepage?: string;
+  }) {
+    const desktopBridge = getDesktopBridge();
+    if (desktopBridge) {
+      await desktopBridge.upsertMcp(input);
+      return getSnapshotInternal();
+    }
+
+    try {
+      await requestApi<{ snapshot: AppSnapshot }>("/upsert-mcp", {
+        method: "POST",
+        body: JSON.stringify(input)
+      });
+      return getSnapshotInternal();
+    } catch (error) {
+      if (!isApiUnavailable(error)) {
+        throw error;
+      }
+      return localUpsertMcp(input);
+    }
+  },
+
+  async deleteMcp(input: { serverId: string }) {
+    const desktopBridge = getDesktopBridge();
+    if (desktopBridge) {
+      await desktopBridge.deleteMcp(input);
+      return getSnapshotInternal();
+    }
+
+    try {
+      await requestApi<{ snapshot: AppSnapshot }>("/delete-mcp", {
+        method: "POST",
+        body: JSON.stringify(input)
+      });
+      return getSnapshotInternal();
+    } catch (error) {
+      if (!isApiUnavailable(error)) {
+        throw error;
+      }
+      return localDeleteMcp(input);
+    }
+  },
+
+  async togglePrompt(input: { promptId: string }) {
+    const desktopBridge = getDesktopBridge();
+    if (desktopBridge) {
+      await desktopBridge.togglePrompt(input);
+      return getSnapshotInternal();
+    }
+
+    try {
+      await requestApi<{ snapshot: AppSnapshot }>("/toggle-prompt", {
+        method: "POST",
+        body: JSON.stringify(input)
+      });
+      return getSnapshotInternal();
+    } catch (error) {
+      if (!isApiUnavailable(error)) {
+        throw error;
+      }
+
+      const snapshot = loadState();
+      snapshot.prompts = snapshot.prompts.map((prompt) =>
+        prompt.id === input.promptId ? { ...prompt, enabled: !prompt.enabled, updatedAt: now() } : prompt
+      );
+      saveState(snapshot);
+      return toPublic(snapshot);
+    }
+  },
+
+  async upsertPrompt(input: {
+    id?: string;
+    appType: "global" | PlatformId;
+    name: string;
+    description: string;
+    content: string;
+    enabled: boolean;
+  }) {
+    const desktopBridge = getDesktopBridge();
+    if (desktopBridge) {
+      await desktopBridge.upsertPrompt(input);
+      return getSnapshotInternal();
+    }
+
+    try {
+      await requestApi<{ snapshot: AppSnapshot }>("/upsert-prompt", {
+        method: "POST",
+        body: JSON.stringify(input)
+      });
+      return getSnapshotInternal();
+    } catch (error) {
+      if (!isApiUnavailable(error)) {
+        throw error;
+      }
+      return localUpsertPrompt(input);
+    }
+  },
+
+  async deletePrompt(input: { promptId: string }) {
+    const desktopBridge = getDesktopBridge();
+    if (desktopBridge) {
+      await desktopBridge.deletePrompt(input);
+      return getSnapshotInternal();
+    }
+
+    try {
+      await requestApi<{ snapshot: AppSnapshot }>("/delete-prompt", {
+        method: "POST",
+        body: JSON.stringify(input)
+      });
+      return getSnapshotInternal();
+    } catch (error) {
+      if (!isApiUnavailable(error)) {
+        throw error;
+      }
+      return localDeletePrompt(input);
+    }
+  },
+
+  async toggleSkillRepo(input: { repoId: string }) {
+    const desktopBridge = getDesktopBridge();
+    if (desktopBridge) {
+      await desktopBridge.toggleSkillRepo(input);
+      return getSnapshotInternal();
+    }
+
+    try {
+      await requestApi<{ snapshot: AppSnapshot }>("/toggle-skill-repo", {
+        method: "POST",
+        body: JSON.stringify(input)
+      });
+      return getSnapshotInternal();
+    } catch (error) {
+      if (!isApiUnavailable(error)) {
+        throw error;
+      }
+
+      const snapshot = loadState();
+      snapshot.skillRepos = snapshot.skillRepos.map((repo) => (repo.id === input.repoId ? { ...repo, enabled: !repo.enabled } : repo));
+      saveState(snapshot);
+      return toPublic(snapshot);
+    }
+  },
+
+  async upsertSkill(input: {
+    id?: string;
+    name: string;
+    description: string;
+    directory: string;
+    enabledPlatforms: PlatformId[];
+  }) {
+    const desktopBridge = getDesktopBridge();
+    if (desktopBridge) {
+      await desktopBridge.upsertSkill(input);
+      return getSnapshotInternal();
+    }
+
+    try {
+      await requestApi<{ snapshot: AppSnapshot }>("/upsert-skill", {
+        method: "POST",
+        body: JSON.stringify(input)
+      });
+      return getSnapshotInternal();
+    } catch (error) {
+      if (!isApiUnavailable(error)) {
+        throw error;
+      }
+      return localUpsertSkill(input);
+    }
+  },
+
+  async deleteSkill(input: { skillId: string }) {
+    const desktopBridge = getDesktopBridge();
+    if (desktopBridge) {
+      await desktopBridge.deleteSkill(input);
+      return getSnapshotInternal();
+    }
+
+    try {
+      await requestApi<{ snapshot: AppSnapshot }>("/delete-skill", {
+        method: "POST",
+        body: JSON.stringify(input)
+      });
+      return getSnapshotInternal();
+    } catch (error) {
+      if (!isApiUnavailable(error)) {
+        throw error;
+      }
+      return localDeleteSkill(input);
+    }
+  },
+
+  async probePlatform(platformId: PlatformId) {
+    const desktopBridge = getDesktopBridge();
+    if (desktopBridge) {
+      const response = (await desktopBridge.probePlatform({ platform: platformId })) as ProbePlatformApiResponse;
+      return response.results ?? [];
+    }
+
+    try {
+      const response = await requestApi<ProbePlatformApiResponse>("/probe-platform", {
+        method: "POST",
+        body: JSON.stringify({ platform: platformId })
+      });
+      return response.results;
+    } catch (error) {
+      if (!isApiUnavailable(error)) {
+        throw error;
+      }
+      return localProbePlatform(platformId);
+    }
+  },
+
+  async probeCandidate(input: { platform: PlatformId; baseUrl: string }) {
+    const desktopBridge = getDesktopBridge();
+    if (desktopBridge) {
+      return (await desktopBridge.probeCandidate(input)) as ProbeCandidateApiResponse;
+    }
+
+    try {
+      return await requestApi<ProbeCandidateApiResponse>("/probe-candidate", {
+        method: "POST",
+        body: JSON.stringify(input)
+      });
+    } catch (error) {
+      if (!isApiUnavailable(error)) {
+        throw error;
+      }
+      return { result: null };
+    }
+  },
+
+  async openPath(input: { targetPath: string }) {
+    const desktopBridge = getDesktopBridge();
+    if (desktopBridge) {
+      const response = (await desktopBridge.openPath(input.targetPath)) as OpenPathApiResponse;
+      return {
+        ok: true,
+        targetPath: response.targetPath || input.targetPath
+      };
+    }
+
+    try {
+      return await requestApi<OpenPathApiResponse>("/open-path", {
+        method: "POST",
+        body: JSON.stringify(input)
+      });
+    } catch (error) {
+      if (!isApiUnavailable(error)) {
+        throw error;
+      }
+      throw new Error("当前模式不支持打开文件位置");
+    }
+  }
+};