ccnew 0.1.10

package/src/lib/client.ts

@@ -0,0 +1,726 @@
+import type {
+  AppSnapshot,
+  McpServer,
+  PlatformId,
+  PlatformRouting,
+  PlatformSnapshot,
+  PresetProfile,
+  ProbeResult,
+  PromptProfile,
+  Provider,
+  RoutingSnapshot,
+  SkillProfile,
+  SkillRepo
+} from "../types";
+
+const STORAGE_KEY = "fml-control-state";
+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 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[];
+  presets?: PresetProfile[];
+  routing?: RoutingSnapshot;
+};
+
+type ProbePlatformResponse = {
+  snapshot?: AppSnapshot;
+  results: ProbeResult[];
+  best?: ProbeResult | null;
+  failover?: {
+    previousProviderId?: string;
+    nextProviderId?: string;
+  } | null;
+};
+
+type ProbeCandidateResponse = {
+  result: ProbeResult | null;
+};
+
+type OpenPathResponse = {
+  ok: true;
+  targetPath: string;
+};
+
+type ImportExportPresetResponse = {
+  canceled?: boolean;
+  filePath?: string;
+  targetPath?: string;
+  count?: number;
+  snapshot?: AppSnapshot;
+};
+
+function now() {
+  return new Date().toISOString();
+}
+
+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 sanitizeModels(models?: string[]) {
+  if (!Array.isArray(models) || models.length === 0) {
+    return [...DEFAULT_MODELS];
+  }
+
+  return [...new Set(models.map((item) => `${item || ""}`.trim()).filter(Boolean))];
+}
+
+function getDesktopBridge(): DesktopBridge | null {
+  if (typeof window === "undefined") {
+    return null;
+  }
+
+  return window.marchDesktop ?? null;
+}
+
+function createStoredProvider(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,
+    createdAt: now(),
+    updatedAt: now(),
+    health: "unknown",
+    lastLatency: null,
+    lastCheckedAt: null,
+    lastError: null,
+    failoverRank: isActive ? 0 : 1,
+    failoverRole: isActive ? "primary" : "fallback",
+    costTier: "medium"
+  };
+}
+
+function createRouting(platforms: StoredPlatform[]): RoutingSnapshot {
+  const platformStates: PlatformRouting[] = platforms.map((platform) => {
+    const activeProvider = platform.providers.find((provider) => provider.isActive) || platform.providers[0] || null;
+    return {
+      platform: platform.id,
+      proxyMode: "provider-base-url",
+      autoFailover: false,
+      failoverThresholdMs: 1800,
+      maxConsecutiveFailures: 2,
+      primaryProviderId: activeProvider?.id || null,
+      fallbackProviderIds: platform.providers.filter((provider) => provider.id !== activeProvider?.id).map((provider) => provider.id),
+      lastFailoverAt: null,
+      providerStates: platform.providers.map((provider, index) => ({
+        providerId: provider.id,
+        failoverRank: provider.id === activeProvider?.id ? 0 : index + 1,
+        role: provider.id === activeProvider?.id ? "primary" : "fallback",
+        health: provider.health,
+        lastLatency: provider.lastLatency,
+        lastCheckedAt: provider.lastCheckedAt,
+        lastError: provider.lastError,
+        consecutiveFailures: 0,
+        costTier: provider.costTier
+      }))
+    };
+  });
+
+  return {
+    budgetMode: "tiered",
+    monthlyBudgetUsd: null,
+    platforms: platformStates
+  };
+}
+
+function createInitialState(): StoredSnapshot {
+  const platforms: StoredPlatform[] = [
+    {
+      id: "codex",
+      label: "Codex",
+      currentProviderName: "fhl",
+      providerCount: 1,
+      targetFiles: ["~/.codex/config.toml", "~/.codex/auth.json"],
+      providers: [createStoredProvider("fhl", "https://www.fhl.mom", "gpt-5.4", "", true)]
+    },
+    {
+      id: "opencode",
+      label: "OpenCode",
+      currentProviderName: "fhl",
+      providerCount: 1,
+      targetFiles: ["~/.config/opencode/opencode.json", "~/.config/opencode/AGENTS.md"],
+      providers: [createStoredProvider("fhl", "https://www.fhl.mom", "gpt-5.4", "", true)]
+    },
+    {
+      id: "openclaw",
+      label: "OpenClaw",
+      currentProviderName: "fhl",
+      providerCount: 1,
+      targetFiles: ["~/.openclaw/openclaw.json", "~/.openclaw/agents/main/agent/models.json"],
+      providers: [createStoredProvider("fhl", "https://www.fhl.mom/v1", "gpt-5.4", "", true)]
+    }
+  ];
+
+  return {
+    appName: "ccon",
+    version: "0.1.10",
+    generatedAt: now(),
+    models: [...DEFAULT_MODELS],
+    platforms,
+    mcpServers: [],
+    prompts: [],
+    skills: [],
+    skillRepos: [],
+    presets: [],
+    routing: createRouting(platforms)
+  };
+}
+
+function loadStoredState(): StoredSnapshot {
+  const fallback = createInitialState();
+  const raw = localStorage.getItem(STORAGE_KEY);
+  if (!raw) {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(fallback));
+    return fallback;
+  }
+
+  try {
+    const parsed = JSON.parse(raw) as Partial<StoredSnapshot>;
+    return {
+      ...fallback,
+      ...parsed,
+      models: sanitizeModels(parsed.models ?? fallback.models),
+      platforms: Array.isArray(parsed.platforms) ? parsed.platforms : fallback.platforms,
+      mcpServers: Array.isArray(parsed.mcpServers) ? parsed.mcpServers : fallback.mcpServers,
+      prompts: Array.isArray(parsed.prompts) ? parsed.prompts : fallback.prompts,
+      skills: Array.isArray(parsed.skills) ? parsed.skills : fallback.skills,
+      skillRepos: Array.isArray(parsed.skillRepos) ? parsed.skillRepos : fallback.skillRepos,
+      presets: Array.isArray(parsed.presets) ? parsed.presets : fallback.presets,
+      routing: parsed.routing ?? fallback.routing
+    };
+  } catch {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(fallback));
+    return fallback;
+  }
+}
+
+function saveStoredState(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) => ({
+        ...provider,
+        maskedApiKey: maskApiKey(provider.apiKey)
+      }))
+    }))
+  };
+}
+
+function toStoredPlatform(platform: PlatformSnapshot): StoredPlatform {
+  return {
+    ...platform,
+    providers: platform.providers.map((provider) => ({
+      ...provider,
+      apiKey: ""
+    }))
+  };
+}
+
+function persistPublicSnapshot(snapshot: AppSnapshot) {
+  const current = loadStoredState();
+  const next: StoredSnapshot = {
+    ...current,
+    ...snapshot,
+    platforms: snapshot.platforms.map(toStoredPlatform)
+  };
+
+  saveStoredState(next);
+  return snapshot;
+}
+
+async function getSnapshotInternal(): Promise<AppSnapshot> {
+  const bridge = getDesktopBridge();
+  if (bridge) {
+    const response = (await bridge.getSnapshot()) as DesktopSnapshotResponse;
+    const snapshot: AppSnapshot = {
+      appName: response.appName || "ccon",
+      version: response.version || "0.1.10",
+      generatedAt: response.generatedAt || now(),
+      models: sanitizeModels((response.models || []).map((item) => (typeof item === "string" ? item : item?.id || "")).filter(Boolean)),
+      platforms: response.platforms || [],
+      mcpServers: response.mcpServers || [],
+      prompts: response.prompts || [],
+      skills: response.skills || [],
+      skillRepos: response.skillRepos || [],
+      presets: response.presets || [],
+      routing:
+        response.routing ||
+        createRouting(
+          (response.platforms || []).map((platform) => toStoredPlatform(platform))
+        )
+    };
+
+    persistPublicSnapshot(snapshot);
+    return snapshot;
+  }
+
+  return toPublic(loadStoredState());
+}
+
+function getLocalPlatform(snapshot: StoredSnapshot, platformId: PlatformId) {
+  const platform = snapshot.platforms.find((item) => item.id === platformId);
+  if (!platform) {
+    throw new Error(`Platform not found: ${platformId}`);
+  }
+
+  return platform;
+}
+
+function setLocalActiveProvider(platform: StoredPlatform, providerId: string) {
+  platform.providers = platform.providers.map((provider) => ({
+    ...provider,
+    isActive: provider.id === providerId,
+    failoverRole: provider.id === providerId ? "primary" : "fallback",
+    failoverRank: provider.id === providerId ? 0 : provider.failoverRank || 1
+  }));
+}
+
+function updateLocalRouting(snapshot: StoredSnapshot, platformId: PlatformId) {
+  const platform = getLocalPlatform(snapshot, platformId);
+  const routingPlatform = snapshot.routing.platforms.find((item) => item.platform === platformId);
+  const active = platform.providers.find((provider) => provider.isActive) || platform.providers[0] || null;
+
+  if (!routingPlatform) {
+    snapshot.routing = createRouting(snapshot.platforms);
+    return;
+  }
+
+  routingPlatform.primaryProviderId = active?.id || null;
+  routingPlatform.fallbackProviderIds = platform.providers.filter((provider) => provider.id !== active?.id).map((provider) => provider.id);
+  routingPlatform.providerStates = platform.providers.map((provider, index) => ({
+    providerId: provider.id,
+    failoverRank: provider.id === active?.id ? 0 : index + 1,
+    role: provider.id === active?.id ? "primary" : "fallback",
+    health: provider.health,
+    lastLatency: provider.lastLatency,
+    lastCheckedAt: provider.lastCheckedAt,
+    lastError: provider.lastError,
+    consecutiveFailures: 0,
+    costTier: provider.costTier
+  }));
+}
+
+export const client = {
+  getSnapshot: getSnapshotInternal,
+
+  async saveProvider(input: { platform: PlatformId; name: string; baseUrl: string; apiKey: string; model: string }) {
+    const bridge = getDesktopBridge();
+    if (bridge) {
+      await bridge.saveProvider(input);
+      return getSnapshotInternal();
+    }
+
+    const snapshot = loadStoredState();
+    const platform = getLocalPlatform(snapshot, input.platform);
+    const match = platform.providers.find((provider) => provider.name.trim().toLowerCase() === input.name.trim().toLowerCase());
+    if (match) {
+      match.baseUrl = input.baseUrl;
+      match.apiKey = input.apiKey;
+      match.model = input.model;
+      match.updatedAt = now();
+      setLocalActiveProvider(platform, match.id);
+    } else {
+      const created = createStoredProvider(input.name, input.baseUrl, input.model, input.apiKey, true);
+      platform.providers.unshift(created);
+      setLocalActiveProvider(platform, created.id);
+    }
+    updateLocalRouting(snapshot, input.platform);
+    saveStoredState(snapshot);
+    return toPublic(snapshot);
+  },
+
+  async activateProvider(input: { platform: PlatformId; providerId: string }) {
+    const bridge = getDesktopBridge();
+    if (bridge) {
+      await bridge.activateProvider(input);
+      return getSnapshotInternal();
+    }
+
+    const snapshot = loadStoredState();
+    const platform = getLocalPlatform(snapshot, input.platform);
+    setLocalActiveProvider(platform, input.providerId);
+    updateLocalRouting(snapshot, input.platform);
+    saveStoredState(snapshot);
+    return toPublic(snapshot);
+  },
+
+  async probePlatform(platformId: PlatformId): Promise<ProbePlatformResponse> {
+    const bridge = getDesktopBridge();
+    if (bridge) {
+      const response = (await bridge.probePlatform({ platform: platformId })) as ProbePlatformResponse;
+      if (response.snapshot) {
+        persistPublicSnapshot(response.snapshot);
+      } else {
+        await getSnapshotInternal();
+      }
+      return response;
+    }
+
+    const snapshot = loadStoredState();
+    const platform = getLocalPlatform(snapshot, platformId);
+    const results = platform.providers.map((provider, index) => ({
+      baseUrl: provider.baseUrl,
+      ok: true,
+      latency: 90 + index * 33
+    }));
+    platform.providers = platform.providers.map((provider, index) => ({
+      ...provider,
+      health: "healthy",
+      lastLatency: results[index]?.latency ?? null,
+      lastCheckedAt: now()
+    }));
+    updateLocalRouting(snapshot, platformId);
+    saveStoredState(snapshot);
+    return {
+      results,
+      best: results[0] || null,
+      snapshot: toPublic(snapshot),
+      failover: null
+    };
+  },
+
+  async probeCandidate(input: { platform: PlatformId; baseUrl: string }): Promise<ProbeCandidateResponse> {
+    const bridge = getDesktopBridge();
+    if (bridge) {
+      return (await bridge.probeCandidate(input)) as ProbeCandidateResponse;
+    }
+
+    return {
+      result: input.baseUrl.trim()
+        ? {
+            baseUrl: input.baseUrl.trim(),
+            ok: true,
+            latency: 120
+          }
+        : null
+    };
+  },
+
+  async savePreset(input: { name: string; providerName: string; commonBaseUrl: string; openclawBaseUrl: string; model: string }) {
+    const bridge = getDesktopBridge();
+    if (bridge) {
+      await bridge.savePreset(input);
+      return getSnapshotInternal();
+    }
+
+    const snapshot = loadStoredState();
+    const payload: PresetProfile = {
+      ...input,
+      source: "custom",
+      readonly: false,
+      createdAt: now(),
+      updatedAt: now()
+    };
+    const index = snapshot.presets.findIndex((preset) => preset.name.toLowerCase() === input.name.trim().toLowerCase());
+    if (index >= 0) {
+      snapshot.presets[index] = { ...snapshot.presets[index], ...payload, updatedAt: now() };
+    } else {
+      snapshot.presets.unshift(payload);
+    }
+    saveStoredState(snapshot);
+    return toPublic(snapshot);
+  },
+
+  async deletePreset(input: { name: string }) {
+    const bridge = getDesktopBridge();
+    if (bridge) {
+      await bridge.deletePreset(input);
+      return getSnapshotInternal();
+    }
+
+    const snapshot = loadStoredState();
+    snapshot.presets = snapshot.presets.filter((preset) => preset.name.toLowerCase() !== input.name.trim().toLowerCase());
+    saveStoredState(snapshot);
+    return toPublic(snapshot);
+  },
+
+  async applyPreset(input: { name: string }) {
+    const bridge = getDesktopBridge();
+    if (bridge) {
+      await bridge.applyPreset(input);
+      return getSnapshotInternal();
+    }
+
+    const snapshot = loadStoredState();
+    const preset = snapshot.presets.find((item) => item.name.toLowerCase() === input.name.trim().toLowerCase());
+    if (!preset) {
+      throw new Error("Preset not found");
+    }
+
+    for (const platform of DEFAULT_PLATFORMS) {
+      const target = getLocalPlatform(snapshot, platform);
+      const active = target.providers.find((provider) => provider.isActive) || target.providers[0] || null;
+      const apiKey = active?.apiKey || "";
+      if (!apiKey) {
+        continue;
+      }
+      const provider = createStoredProvider(
+        preset.providerName,
+        platform === "openclaw" ? preset.openclawBaseUrl : preset.commonBaseUrl,
+        preset.model,
+        apiKey,
+        true
+      );
+      target.providers = [provider, ...target.providers.filter((item) => item.name.toLowerCase() !== preset.providerName.toLowerCase())];
+      setLocalActiveProvider(target, provider.id);
+      updateLocalRouting(snapshot, platform);
+    }
+
+    saveStoredState(snapshot);
+    return toPublic(snapshot);
+  },
+
+  async importPresets(): Promise<ImportExportPresetResponse> {
+    const bridge = getDesktopBridge();
+    if (bridge) {
+      const response = (await bridge.importPresets()) as ImportExportPresetResponse;
+      await getSnapshotInternal();
+      return response;
+    }
+
+    return { canceled: true };
+  },
+
+  async exportPresets(): Promise<ImportExportPresetResponse> {
+    const bridge = getDesktopBridge();
+    if (bridge) {
+      return (await bridge.exportPresets()) as ImportExportPresetResponse;
+    }
+
+    return { canceled: true };
+  },
+
+  async updateRouting(input: {
+    platform: PlatformId;
+    autoFailover?: boolean;
+    failoverThresholdMs?: number;
+    maxConsecutiveFailures?: number;
+    monthlyBudgetUsd?: number | null;
+    budgetMode?: "tiered" | "manual";
+  }) {
+    const bridge = getDesktopBridge();
+    if (bridge) {
+      await bridge.updateRouting(input);
+      return getSnapshotInternal();
+    }
+
+    const snapshot = loadStoredState();
+    const routingPlatform = snapshot.routing.platforms.find((item) => item.platform === input.platform);
+    if (routingPlatform) {
+      routingPlatform.autoFailover = typeof input.autoFailover === "boolean" ? input.autoFailover : routingPlatform.autoFailover;
+      routingPlatform.failoverThresholdMs = input.failoverThresholdMs ?? routingPlatform.failoverThresholdMs;
+      routingPlatform.maxConsecutiveFailures = input.maxConsecutiveFailures ?? routingPlatform.maxConsecutiveFailures;
+    }
+    if (input.monthlyBudgetUsd !== undefined) {
+      snapshot.routing.monthlyBudgetUsd = input.monthlyBudgetUsd;
+    }
+    if (input.budgetMode) {
+      snapshot.routing.budgetMode = input.budgetMode;
+    }
+    saveStoredState(snapshot);
+    return toPublic(snapshot);
+  },
+
+  async toggleMcpServer(input: { serverId: string; platform: PlatformId }) {
+    const bridge = getDesktopBridge();
+    if (bridge) {
+      await bridge.toggleMcp(input);
+      return getSnapshotInternal();
+    }
+
+    const snapshot = loadStoredState();
+    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]
+          }
+    );
+    saveStoredState(snapshot);
+    return toPublic(snapshot);
+  },
+
+  async upsertMcp(
+    input: McpServer & {
+      envText?: string;
+      headersText?: string;
+    }
+  ) {
+    const bridge = getDesktopBridge();
+    if (bridge) {
+      await bridge.upsertMcp(input);
+      return getSnapshotInternal();
+    }
+
+    const snapshot = loadStoredState();
+    const index = snapshot.mcpServers.findIndex((item) => item.id === input.id);
+    if (index >= 0) {
+      snapshot.mcpServers[index] = input;
+    } else {
+      snapshot.mcpServers.unshift(input);
+    }
+    saveStoredState(snapshot);
+    return toPublic(snapshot);
+  },
+
+  async deleteMcp(input: { serverId: string }) {
+    const bridge = getDesktopBridge();
+    if (bridge) {
+      await bridge.deleteMcp(input);
+      return getSnapshotInternal();
+    }
+
+    const snapshot = loadStoredState();
+    snapshot.mcpServers = snapshot.mcpServers.filter((item) => item.id !== input.serverId);
+    saveStoredState(snapshot);
+    return toPublic(snapshot);
+  },
+
+  async togglePrompt(input: { promptId: string }) {
+    const bridge = getDesktopBridge();
+    if (bridge) {
+      await bridge.togglePrompt(input);
+      return getSnapshotInternal();
+    }
+
+    const snapshot = loadStoredState();
+    snapshot.prompts = snapshot.prompts.map((prompt) =>
+      prompt.id === input.promptId ? { ...prompt, enabled: !prompt.enabled, updatedAt: now() } : prompt
+    );
+    saveStoredState(snapshot);
+    return toPublic(snapshot);
+  },
+
+  async upsertPrompt(input: PromptProfile) {
+    const bridge = getDesktopBridge();
+    if (bridge) {
+      await bridge.upsertPrompt(input);
+      return getSnapshotInternal();
+    }
+
+    const snapshot = loadStoredState();
+    const index = snapshot.prompts.findIndex((item) => item.id === input.id);
+    if (index >= 0) {
+      snapshot.prompts[index] = input;
+    } else {
+      snapshot.prompts.unshift(input);
+    }
+    saveStoredState(snapshot);
+    return toPublic(snapshot);
+  },
+
+  async deletePrompt(input: { promptId: string }) {
+    const bridge = getDesktopBridge();
+    if (bridge) {
+      await bridge.deletePrompt(input);
+      return getSnapshotInternal();
+    }
+
+    const snapshot = loadStoredState();
+    snapshot.prompts = snapshot.prompts.filter((item) => item.id !== input.promptId);
+    saveStoredState(snapshot);
+    return toPublic(snapshot);
+  },
+
+  async toggleSkillRepo(input: { repoId: string }) {
+    const bridge = getDesktopBridge();
+    if (bridge) {
+      await bridge.toggleSkillRepo(input);
+      return getSnapshotInternal();
+    }
+
+    const snapshot = loadStoredState();
+    snapshot.skillRepos = snapshot.skillRepos.map((repo) => (repo.id === input.repoId ? { ...repo, enabled: !repo.enabled } : repo));
+    saveStoredState(snapshot);
+    return toPublic(snapshot);
+  },
+
+  async upsertSkill(input: SkillProfile) {
+    const bridge = getDesktopBridge();
+    if (bridge) {
+      await bridge.upsertSkill(input);
+      return getSnapshotInternal();
+    }
+
+    const snapshot = loadStoredState();
+    const index = snapshot.skills.findIndex((item) => item.id === input.id);
+    if (index >= 0) {
+      snapshot.skills[index] = input;
+    } else {
+      snapshot.skills.unshift(input);
+    }
+    saveStoredState(snapshot);
+    return toPublic(snapshot);
+  },
+
+  async deleteSkill(input: { skillId: string }) {
+    const bridge = getDesktopBridge();
+    if (bridge) {
+      await bridge.deleteSkill(input);
+      return getSnapshotInternal();
+    }
+
+    const snapshot = loadStoredState();
+    snapshot.skills = snapshot.skills.filter((item) => item.id !== input.skillId);
+    saveStoredState(snapshot);
+    return toPublic(snapshot);
+  },
+
+  async openPath(input: { targetPath: string }) {
+    const bridge = getDesktopBridge();
+    if (!bridge) {
+      throw new Error("当前模式不支持打开文件位置");
+    }
+
+    return (await bridge.openPath(input.targetPath)) as OpenPathResponse;
+  }
+};