ccnew 0.1.10

package/core/desktop-service.js

@@ -0,0 +1,403 @@
+import { applyProvider, applyStoredProvider } from "./apply.js";
+import {
+  DEFAULT_BASE_URL,
+  DEFAULT_OPENCLAW_BASE_URL,
+  DEFAULT_PRIMARY_MODEL,
+  DEFAULT_PROVIDER_NAME,
+  MODEL_DEFINITIONS,
+  PLATFORM_META,
+  SUPPORTED_PLATFORMS
+} from "./constants.js";
+import {
+  deleteMcpServerFromDesktop as deleteMcpInState,
+  deletePromptFromDesktop as deletePromptInState,
+  deleteSkillFromDesktop as deleteSkillInState,
+  getDesktopState,
+  toggleMcpServerForPlatform,
+  togglePromptFromDesktop as togglePromptInState,
+  toggleSkillRepoFromDesktop as toggleSkillRepoInState,
+  upsertMcpServerFromDesktop as upsertMcpInState,
+  upsertPromptFromDesktop as upsertPromptInState,
+  upsertSkillFromDesktop as upsertSkillInState
+} from "./desktop-state.js";
+import { getPlatformTargetFiles } from "./paths.js";
+import {
+  buildRoutingSnapshot,
+  ensureRoutingProviders,
+  maybeFailoverPlatform,
+  recordProbeResults,
+  setPrimaryProvider,
+  upsertPlatformRouting
+} from "./routing.js";
+import { getBestProbeResult, probeBaseUrls } from "./probe.js";
+import { getPreset, listPresets, removePreset, upsertPreset } from "./presets.js";
+import { getCurrentProvider, listProviders } from "./store.js";
+import { buildOpenClawBaseUrl, maskApiKey, normalizeBaseUrl, readJson, writeJson } from "./utils.js";
+
+function serializeProvider(provider, currentProviderId, routingState) {
+  return {
+    id: provider.id,
+    name: provider.name,
+    baseUrl: provider.baseUrl,
+    model: provider.model || DEFAULT_PRIMARY_MODEL,
+    maskedApiKey: maskApiKey(provider.apiKey),
+    createdAt: provider.createdAt || null,
+    updatedAt: provider.updatedAt || null,
+    isActive: provider.id === currentProviderId,
+    health: routingState?.health || "unknown",
+    lastLatency: routingState?.lastLatency ?? null,
+    lastCheckedAt: routingState?.lastCheckedAt || null,
+    lastError: routingState?.lastError || null,
+    failoverRank: Number.isFinite(routingState?.failoverRank) ? routingState.failoverRank : null,
+    failoverRole: routingState?.role || "standby",
+    costTier: routingState?.costTier || "unknown"
+  };
+}
+
+function buildRoutingContexts() {
+  return SUPPORTED_PLATFORMS.map((platform) => {
+    const providers = listProviders(platform);
+    const currentProvider = getCurrentProvider(platform);
+    ensureRoutingProviders(platform, providers, currentProvider?.id || null);
+    return {
+      platform,
+      providers,
+      currentProviderId: currentProvider?.id || null
+    };
+  });
+}
+
+function buildPlatformSnapshot(platform, routingPlatform) {
+  const providers = listProviders(platform);
+  const currentProvider = getCurrentProvider(platform);
+
+  return {
+    id: platform,
+    label: PLATFORM_META[platform].label,
+    command: PLATFORM_META[platform].command,
+    defaultBaseUrl: platform === "openclaw" ? DEFAULT_OPENCLAW_BASE_URL : DEFAULT_BASE_URL,
+    defaultProviderName: DEFAULT_PROVIDER_NAME,
+    currentProviderId: currentProvider?.id || null,
+    currentProviderName: currentProvider?.name || null,
+    providerCount: providers.length,
+    targetFiles: getPlatformTargetFiles(platform),
+    providers: providers.map((provider) =>
+      serializeProvider(
+        provider,
+        currentProvider?.id || null,
+        routingPlatform?.providerStates?.find((item) => item.providerId === provider.id)
+      )
+    )
+  };
+}
+
+function validatePlatform(platform) {
+  if (!SUPPORTED_PLATFORMS.includes(platform)) {
+    throw new Error(`Unsupported platform: ${platform}`);
+  }
+}
+
+function buildInputForPlatform(platform, input) {
+  const name = `${input?.name || DEFAULT_PROVIDER_NAME}`.trim() || DEFAULT_PROVIDER_NAME;
+  const apiKey = `${input?.apiKey || ""}`.trim();
+  const fallbackBaseUrl = platform === "openclaw" ? DEFAULT_OPENCLAW_BASE_URL : DEFAULT_BASE_URL;
+  const baseUrl = normalizeBaseUrl(`${input?.baseUrl || fallbackBaseUrl}`.trim());
+  const model = `${input?.model || DEFAULT_PRIMARY_MODEL}`.trim() || DEFAULT_PRIMARY_MODEL;
+
+  if (!apiKey) {
+    throw new Error("API Key 不能为空");
+  }
+
+  return {
+    name,
+    apiKey,
+    baseUrl,
+    model
+  };
+}
+
+export function getDesktopSnapshot() {
+  const desktopState = getDesktopState();
+  const routing = buildRoutingSnapshot(buildRoutingContexts());
+
+  return {
+    appName: "ccon",
+    version: "0.1.10",
+    generatedAt: new Date().toISOString(),
+    models: MODEL_DEFINITIONS,
+    platforms: SUPPORTED_PLATFORMS.map((platform) =>
+      buildPlatformSnapshot(
+        platform,
+        routing.platforms.find((item) => item.platform === platform)
+      )
+    ),
+    mcpServers: desktopState.mcpServers,
+    prompts: desktopState.prompts,
+    skills: desktopState.skills,
+    skillRepos: desktopState.skillRepos,
+    presets: listPresets(),
+    routing
+  };
+}
+
+export function saveProviderFromDesktop(platform, input, options = {}) {
+  validatePlatform(platform);
+  const providerInput = buildInputForPlatform(platform, input);
+  const result = applyProvider(platform, providerInput, {
+    backup: options.backup !== false,
+    overwrite: options.overwrite === true,
+    activate: options.activate !== false
+  });
+  const providers = listProviders(platform);
+  setPrimaryProvider(
+    platform,
+    result.provider.id,
+    providers.map((provider) => provider.id)
+  );
+
+  return {
+    snapshot: getDesktopSnapshot(),
+    result: {
+      backupDir: result.backupDir,
+      targetFiles: result.targetFiles
+    }
+  };
+}
+
+export function activateProviderFromDesktop(platform, nameOrId, options = {}) {
+  validatePlatform(platform);
+  const result = applyStoredProvider(platform, nameOrId, {
+    backup: options.backup !== false,
+    overwrite: options.overwrite === true,
+    activate: true
+  });
+  const providers = listProviders(platform);
+  setPrimaryProvider(
+    platform,
+    result.provider.id,
+    providers.map((provider) => provider.id)
+  );
+
+  return {
+    snapshot: getDesktopSnapshot(),
+    result: {
+      backupDir: result.backupDir,
+      targetFiles: result.targetFiles
+    }
+  };
+}
+
+export function toggleMcpFromDesktop(serverId, platform) {
+  validatePlatform(platform);
+  toggleMcpServerForPlatform(serverId, platform);
+  return getDesktopSnapshot();
+}
+
+export function upsertMcpFromDesktop(input) {
+  upsertMcpInState(input);
+  return getDesktopSnapshot();
+}
+
+export function deleteMcpFromDesktop(serverId) {
+  deleteMcpInState(serverId);
+  return getDesktopSnapshot();
+}
+
+export function togglePromptFromDesktop(promptId) {
+  togglePromptInState(promptId);
+  return getDesktopSnapshot();
+}
+
+export function upsertPromptFromDesktop(input) {
+  upsertPromptInState(input);
+  return getDesktopSnapshot();
+}
+
+export function deletePromptFromDesktop(promptId) {
+  deletePromptInState(promptId);
+  return getDesktopSnapshot();
+}
+
+export function upsertSkillFromDesktop(input) {
+  upsertSkillInState(input);
+  return getDesktopSnapshot();
+}
+
+export function deleteSkillFromDesktop(skillId) {
+  deleteSkillInState(skillId);
+  return getDesktopSnapshot();
+}
+
+export function toggleSkillRepoFromDesktop(repoId) {
+  toggleSkillRepoInState(repoId);
+  return getDesktopSnapshot();
+}
+
+export async function probePlatformProvidersFromDesktop(platform) {
+  validatePlatform(platform);
+  const currentSnapshot = getDesktopSnapshot();
+  const snapshot = currentSnapshot.platforms.find((item) => item.id === platform) || buildPlatformSnapshot(platform);
+  const providerUrls = snapshot.providers.map((provider) => provider.baseUrl);
+
+  if (providerUrls.length === 0) {
+    return {
+      snapshot,
+      results: [],
+      best: null
+    };
+  }
+
+  const results = await probeBaseUrls(providerUrls, { timeoutMs: 5000 });
+  const providers = listProviders(platform);
+  recordProbeResults(platform, providers, results);
+  const currentProvider = getCurrentProvider(platform);
+  const failover = maybeFailoverPlatform(platform, providers, currentProvider?.id || null);
+  if (failover?.nextProviderId) {
+    applyStoredProvider(platform, failover.nextProviderId, {
+      backup: true,
+      overwrite: false,
+      activate: true
+    });
+  }
+
+  return {
+    snapshot: getDesktopSnapshot(),
+    results,
+    best: getBestProbeResult(results),
+    failover: failover || null
+  };
+}
+
+export async function probeCandidateFromDesktop(platform, baseUrl) {
+  validatePlatform(platform);
+  const normalizedBaseUrl = normalizeBaseUrl(`${baseUrl || ""}`.trim());
+
+  if (!normalizedBaseUrl) {
+    throw new Error("测试地址不能为空");
+  }
+
+  const finalUrl =
+    platform === "openclaw" && !normalizedBaseUrl.endsWith("/v1")
+      ? buildOpenClawBaseUrl(normalizedBaseUrl)
+      : normalizedBaseUrl;
+  const results = await probeBaseUrls([finalUrl], { timeoutMs: 5000 });
+
+  return {
+    result: results[0] || null
+  };
+}
+
+export function savePresetFromDesktop(input) {
+  return {
+    preset: upsertPreset(input),
+    snapshot: getDesktopSnapshot()
+  };
+}
+
+export function deletePresetFromDesktop(name) {
+  return {
+    preset: removePreset(name),
+    snapshot: getDesktopSnapshot()
+  };
+}
+
+export function applyPresetFromDesktop(name, options = {}) {
+  const preset = getPreset(name);
+  if (!preset) {
+    throw new Error(`Preset not found: ${name}`);
+  }
+
+  const applied = [];
+  const skipped = [];
+
+  for (const platform of SUPPORTED_PLATFORMS) {
+    const providers = listProviders(platform);
+    const currentProvider = getCurrentProvider(platform);
+    const matchingProvider =
+      providers.find((provider) => provider.name.trim().toLowerCase() === preset.providerName.trim().toLowerCase()) ||
+      currentProvider ||
+      providers[0] ||
+      null;
+    const apiKey = matchingProvider?.apiKey || "";
+
+    if (!apiKey) {
+      skipped.push({
+        platform,
+        reason: "缺少可复用 API Key"
+      });
+      continue;
+    }
+
+    const input = {
+      name: preset.providerName,
+      apiKey,
+      baseUrl: platform === "openclaw" ? preset.openclawBaseUrl : preset.commonBaseUrl,
+      model: preset.model || DEFAULT_PRIMARY_MODEL
+    };
+
+    saveProviderFromDesktop(platform, input, {
+      backup: options.backup !== false,
+      overwrite: options.overwrite === true,
+      activate: true
+    });
+    applied.push({
+      platform,
+      providerName: preset.providerName
+    });
+  }
+
+  return {
+    preset,
+    applied,
+    skipped,
+    snapshot: getDesktopSnapshot()
+  };
+}
+
+export function exportPresetsToDesktop(filePath) {
+  const targetPath = `${filePath || ""}`.trim();
+  if (!targetPath) {
+    throw new Error("导出路径不能为空");
+  }
+
+  writeJson(targetPath, {
+    appName: "ccon",
+    version: "0.1.10",
+    exportedAt: new Date().toISOString(),
+    presets: listPresets()
+  });
+
+  return {
+    targetPath,
+    count: listPresets().length
+  };
+}
+
+export function importPresetsFromDesktop(filePath) {
+  const targetPath = `${filePath || ""}`.trim();
+  if (!targetPath) {
+    throw new Error("导入路径不能为空");
+  }
+
+  const payload = readJson(targetPath, null);
+  const presets = Array.isArray(payload?.presets) ? payload.presets : Array.isArray(payload) ? payload : [];
+  if (presets.length === 0) {
+    throw new Error("未找到可导入的预设");
+  }
+
+  const imported = [];
+  for (const preset of presets) {
+    imported.push(upsertPreset(preset));
+  }
+
+  return {
+    imported,
+    snapshot: getDesktopSnapshot()
+  };
+}
+
+export function updateRoutingFromDesktop(platform, input = {}) {
+  validatePlatform(platform);
+  upsertPlatformRouting(platform, input);
+  return getDesktopSnapshot();
+}