ccnew 0.1.10

package/core/paths.js

@@ -0,0 +1,99 @@
+import os from "node:os";
+import path from "node:path";
+
+export function getHomeDir() {
+  return process.env.MARCH_HOME ? path.resolve(process.env.MARCH_HOME) : os.homedir();
+}
+
+export function getMarchDir() {
+  return path.join(getHomeDir(), ".march");
+}
+
+export function getMarchStorePath(platform) {
+  return path.join(getMarchDir(), `${platform}.json`);
+}
+
+export function getMarchDesktopStatePath() {
+  return path.join(getMarchDir(), "desktop-state.json");
+}
+
+export function getMarchRoutingPath() {
+  return path.join(getMarchDir(), "routing.json");
+}
+
+export function getMarchPresetPath() {
+  return path.join(getMarchDir(), "presets.json");
+}
+
+export function getMarchManagedDir() {
+  return path.join(getMarchDir(), "managed");
+}
+
+export function getMarchManagedPromptDir(platform) {
+  return path.join(getMarchManagedDir(), "prompts", platform);
+}
+
+export function getBackupDirRoot() {
+  return path.join(getMarchDir(), "backups");
+}
+
+export function getCodexDir() {
+  return path.join(getHomeDir(), ".codex");
+}
+
+export function getCodexConfigPath() {
+  return path.join(getCodexDir(), "config.toml");
+}
+
+export function getCodexAuthPath() {
+  return path.join(getCodexDir(), "auth.json");
+}
+
+export function getOpenCodeDir() {
+  return path.join(getHomeDir(), ".config", "opencode");
+}
+
+export function getOpenCodeConfigPath() {
+  return path.join(getOpenCodeDir(), "opencode.json");
+}
+
+export function getOpenCodeAgentsPath() {
+  return path.join(getOpenCodeDir(), "AGENTS.md");
+}
+
+export function getOpenCodeSkillsDir() {
+  return path.join(getOpenCodeDir(), "skills");
+}
+
+export function getOpenClawDir() {
+  return path.join(getHomeDir(), ".openclaw");
+}
+
+export function getOpenClawConfigPath() {
+  return path.join(getOpenClawDir(), "openclaw.json");
+}
+
+export function getOpenClawModelsPath() {
+  return path.join(getOpenClawDir(), "agents", "main", "agent", "models.json");
+}
+
+export function getOpenClawSkillsDir() {
+  return path.join(getOpenClawDir(), "skills");
+}
+
+export function getAgentsSkillsDir() {
+  return path.join(getHomeDir(), ".agents", "skills");
+}
+
+export function getPlatformTargetFiles(platform) {
+  switch (platform) {
+    case "codex":
+      return [getMarchStorePath(platform), getCodexConfigPath(), getCodexAuthPath()];
+    case "opencode":
+      return [getMarchStorePath(platform), getOpenCodeConfigPath(), getOpenCodeAgentsPath()];
+    case "openclaw":
+      return [getMarchStorePath(platform), getOpenClawConfigPath(), getOpenClawModelsPath()];
+    default:
+      throw new Error(`Unsupported platform: ${platform}`);
+  }
+}

package/core/presets.js

@@ -0,0 +1,171 @@
+import { BUILTIN_PRESETS, DEFAULT_PRIMARY_MODEL } from "./constants.js";
+import { getMarchDir, getMarchPresetPath } from "./paths.js";
+import { buildOpenClawBaseUrl, ensureDir, normalizeBaseUrl, readJson, writeJson } from "./utils.js";
+
+function createEmptyPresetStore() {
+  return {
+    presets: []
+  };
+}
+
+function toNormalizedPreset(input, fallback = {}) {
+  const name = `${input?.name || fallback?.name || ""}`.trim();
+  if (!name) {
+    throw new Error("Preset name cannot be empty");
+  }
+
+  const providerName = `${input?.providerName || fallback?.providerName || name}`.trim() || name;
+  const commonBaseUrl = normalizeBaseUrl(
+    `${input?.commonBaseUrl || input?.baseUrl || fallback?.commonBaseUrl || fallback?.baseUrl || ""}`.trim()
+  );
+  if (!commonBaseUrl) {
+    throw new Error("Preset base URL cannot be empty");
+  }
+
+  const openclawBaseUrl = normalizeBaseUrl(
+    `${input?.openclawBaseUrl || fallback?.openclawBaseUrl || buildOpenClawBaseUrl(commonBaseUrl)}`.trim()
+  );
+
+  return {
+    name,
+    providerName,
+    commonBaseUrl,
+    openclawBaseUrl,
+    model: `${input?.model || fallback?.model || DEFAULT_PRIMARY_MODEL}`.trim() || DEFAULT_PRIMARY_MODEL
+  };
+}
+
+function normalizeStoreEntry(entry) {
+  const preset = toNormalizedPreset(entry, entry);
+  return {
+    ...preset,
+    createdAt: entry?.createdAt || null,
+    updatedAt: entry?.updatedAt || null
+  };
+}
+
+function loadCustomPresetStore() {
+  const raw = readJson(getMarchPresetPath(), createEmptyPresetStore());
+  return {
+    presets: Array.isArray(raw?.presets) ? raw.presets.map((item) => normalizeStoreEntry(item)) : []
+  };
+}
+
+function saveCustomPresetStore(store) {
+  ensureDir(getMarchDir());
+  writeJson(getMarchPresetPath(), {
+    presets: Array.isArray(store.presets) ? store.presets : []
+  });
+}
+
+function listBuiltinPresets() {
+  return BUILTIN_PRESETS.map((preset) => ({
+    ...toNormalizedPreset(preset, preset),
+    source: "builtin",
+    readonly: true,
+    createdAt: null,
+    updatedAt: null
+  }));
+}
+
+function listCustomPresets() {
+  return loadCustomPresetStore().presets.map((preset) => ({
+    ...preset,
+    source: "custom",
+    readonly: false
+  }));
+}
+
+function nameKey(name) {
+  return `${name || ""}`.trim().toLowerCase();
+}
+
+export function listPresets() {
+  const merged = [...listBuiltinPresets(), ...listCustomPresets()];
+  const seen = new Set();
+  const result = [];
+
+  // custom preset with same name overrides builtin view
+  for (const preset of [...merged].reverse()) {
+    const key = nameKey(preset.name);
+    if (!key || seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    result.push(preset);
+  }
+
+  return result.reverse();
+}
+
+export function getPreset(name) {
+  const key = nameKey(name);
+  if (!key) {
+    return null;
+  }
+
+  return listPresets().find((preset) => nameKey(preset.name) === key) || null;
+}
+
+export function upsertPreset(input) {
+  const normalized = toNormalizedPreset(input, input);
+  const store = loadCustomPresetStore();
+  const targetKey = nameKey(normalized.name);
+  const existing = store.presets.find((preset) => nameKey(preset.name) === targetKey);
+  const now = new Date().toISOString();
+
+  if (existing) {
+    const next = {
+      ...existing,
+      ...normalized,
+      updatedAt: now
+    };
+    store.presets = store.presets.map((preset) =>
+      nameKey(preset.name) === targetKey ? next : preset
+    );
+    saveCustomPresetStore(store);
+    return {
+      ...next,
+      source: "custom",
+      readonly: false
+    };
+  }
+
+  const created = {
+    ...normalized,
+    createdAt: now,
+    updatedAt: now
+  };
+  store.presets.push(created);
+  saveCustomPresetStore(store);
+  return {
+    ...created,
+    source: "custom",
+    readonly: false
+  };
+}
+
+export function removePreset(name) {
+  const key = nameKey(name);
+  if (!key) {
+    throw new Error("Preset name cannot be empty");
+  }
+
+  const store = loadCustomPresetStore();
+  const existing = store.presets.find((preset) => nameKey(preset.name) === key);
+  if (!existing) {
+    const builtin = listBuiltinPresets().find((preset) => nameKey(preset.name) === key);
+    if (builtin) {
+      throw new Error("Built-in preset is read-only");
+    }
+    throw new Error(`Preset not found: ${name}`);
+  }
+
+  store.presets = store.presets.filter((preset) => nameKey(preset.name) !== key);
+  saveCustomPresetStore(store);
+  return {
+    ...existing,
+    source: "custom",
+    readonly: false
+  };
+}

package/core/probe.js

@@ -0,0 +1,70 @@
+import { dedupeStrings, normalizeBaseUrl } from "./utils.js";
+
+async function fetchWithTimeout(url, timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  const startedAt = Date.now();
+
+  try {
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        Accept: "application/json"
+      },
+      signal: controller.signal
+    });
+
+    return {
+      ok: true,
+      url,
+      latency: Date.now() - startedAt,
+      status: response.status
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      url,
+      latency: Date.now() - startedAt,
+      error: error.name === "AbortError" ? "timeout" : error.message
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export async function probeBaseUrls(baseUrls, options = {}) {
+  const timeoutMs = options.timeoutMs ?? 5000;
+  const normalized = dedupeStrings(baseUrls).map((value) => normalizeBaseUrl(value));
+  const results = [];
+
+  for (const baseUrl of normalized) {
+    const modelUrl = `${baseUrl}/models`;
+    const modelResult = await fetchWithTimeout(modelUrl, timeoutMs);
+
+    if (modelResult.ok) {
+      results.push({
+        ...modelResult,
+        baseUrl
+      });
+      continue;
+    }
+
+    const fallbackResult = await fetchWithTimeout(baseUrl, timeoutMs);
+    results.push({
+      ...fallbackResult,
+      baseUrl
+    });
+  }
+
+  return results.sort((left, right) => {
+    if (left.ok !== right.ok) {
+      return left.ok ? -1 : 1;
+    }
+
+    return left.latency - right.latency;
+  });
+}
+
+export function getBestProbeResult(results) {
+  return results.find((result) => result.ok) || results[0] || null;
+}

package/core/routing.js

@@ -0,0 +1,334 @@
+import { SUPPORTED_PLATFORMS } from "./constants.js";
+import { getMarchRoutingPath } from "./paths.js";
+import { readJson, writeJson } from "./utils.js";
+
+const DEFAULT_FAILOVER_THRESHOLD_MS = 1800;
+const DEFAULT_MAX_FAILURES = 2;
+
+function now() {
+  return new Date().toISOString();
+}
+
+function createDefaultPlatformState(platform) {
+  return {
+    platform,
+    proxyMode: "provider-base-url",
+    autoFailover: false,
+    failoverThresholdMs: DEFAULT_FAILOVER_THRESHOLD_MS,
+    maxConsecutiveFailures: DEFAULT_MAX_FAILURES,
+    primaryProviderId: null,
+    fallbackProviderIds: [],
+    lastFailoverAt: null
+  };
+}
+
+function createDefaultRoutingState() {
+  return {
+    budgetMode: "tiered",
+    monthlyBudgetUsd: null,
+    platforms: SUPPORTED_PLATFORMS.map((platform) => createDefaultPlatformState(platform)),
+    providers: {}
+  };
+}
+
+function sanitizePlatformState(raw, platform) {
+  const fallback = createDefaultPlatformState(platform);
+  const fallbackIds = Array.isArray(raw?.fallbackProviderIds)
+    ? [...new Set(raw.fallbackProviderIds.filter((item) => typeof item === "string" && item.trim()).map((item) => item.trim()))]
+    : [];
+
+  return {
+    platform,
+    proxyMode: raw?.proxyMode === "direct" ? "direct" : fallback.proxyMode,
+    autoFailover: typeof raw?.autoFailover === "boolean" ? raw.autoFailover : fallback.autoFailover,
+    failoverThresholdMs:
+      Number.isFinite(raw?.failoverThresholdMs) && raw.failoverThresholdMs > 0
+        ? Math.round(raw.failoverThresholdMs)
+        : fallback.failoverThresholdMs,
+    maxConsecutiveFailures:
+      Number.isFinite(raw?.maxConsecutiveFailures) && raw.maxConsecutiveFailures > 0
+        ? Math.round(raw.maxConsecutiveFailures)
+        : fallback.maxConsecutiveFailures,
+    primaryProviderId: typeof raw?.primaryProviderId === "string" && raw.primaryProviderId.trim() ? raw.primaryProviderId.trim() : null,
+    fallbackProviderIds: fallbackIds,
+    lastFailoverAt: typeof raw?.lastFailoverAt === "string" && raw.lastFailoverAt.trim() ? raw.lastFailoverAt : null
+  };
+}
+
+function sanitizeProviderMetrics(raw) {
+  const result = {};
+
+  for (const [key, value] of Object.entries(raw || {})) {
+    if (!value || typeof value !== "object") {
+      continue;
+    }
+
+    result[key] = {
+      providerId: typeof value.providerId === "string" ? value.providerId : null,
+      platform: typeof value.platform === "string" ? value.platform : null,
+      lastLatency: Number.isFinite(value.lastLatency) ? Math.round(value.lastLatency) : null,
+      lastCheckedAt: typeof value.lastCheckedAt === "string" ? value.lastCheckedAt : null,
+      lastError: typeof value.lastError === "string" ? value.lastError : null,
+      consecutiveFailures: Number.isFinite(value.consecutiveFailures) ? Math.max(0, Math.round(value.consecutiveFailures)) : 0,
+      lastStatus:
+        value.lastStatus === "healthy" || value.lastStatus === "degraded" || value.lastStatus === "offline"
+          ? value.lastStatus
+          : "unknown"
+    };
+  }
+
+  return result;
+}
+
+export function loadRoutingState() {
+  const raw = readJson(getMarchRoutingPath(), null);
+  const fallback = createDefaultRoutingState();
+
+  return {
+    budgetMode: raw?.budgetMode === "manual" ? "manual" : fallback.budgetMode,
+    monthlyBudgetUsd: Number.isFinite(raw?.monthlyBudgetUsd) && raw.monthlyBudgetUsd >= 0 ? raw.monthlyBudgetUsd : null,
+    platforms: SUPPORTED_PLATFORMS.map((platform) =>
+      sanitizePlatformState(raw?.platforms?.find?.((item) => item?.platform === platform), platform)
+    ),
+    providers: sanitizeProviderMetrics(raw?.providers)
+  };
+}
+
+export function saveRoutingState(state) {
+  writeJson(getMarchRoutingPath(), state);
+}
+
+export function getPlatformRoutingState(platform) {
+  return loadRoutingState().platforms.find((item) => item.platform === platform) || createDefaultPlatformState(platform);
+}
+
+export function upsertPlatformRouting(platform, input = {}) {
+  const state = loadRoutingState();
+  state.platforms = state.platforms.map((item) =>
+    item.platform !== platform
+      ? item
+      : sanitizePlatformState(
+          {
+            ...item,
+            ...input
+          },
+          platform
+        )
+  );
+
+  if (input.monthlyBudgetUsd !== undefined) {
+    state.monthlyBudgetUsd =
+      Number.isFinite(input.monthlyBudgetUsd) && input.monthlyBudgetUsd >= 0 ? input.monthlyBudgetUsd : null;
+  }
+
+  if (input.budgetMode !== undefined) {
+    state.budgetMode = input.budgetMode === "manual" ? "manual" : "tiered";
+  }
+
+  saveRoutingState(state);
+  return state;
+}
+
+export function ensureRoutingProviders(platform, providers, currentProviderId = null) {
+  const state = loadRoutingState();
+  const policy = state.platforms.find((item) => item.platform === platform) || createDefaultPlatformState(platform);
+  const providerIds = providers.map((item) => item.id);
+
+  let primaryProviderId = policy.primaryProviderId;
+  if (!primaryProviderId || !providerIds.includes(primaryProviderId)) {
+    primaryProviderId = currentProviderId && providerIds.includes(currentProviderId) ? currentProviderId : providerIds[0] || null;
+  }
+
+  const fallbackProviderIds = providerIds.filter((providerId) => providerId !== primaryProviderId);
+  const nextPolicy = {
+    ...policy,
+    primaryProviderId,
+    fallbackProviderIds
+  };
+
+  state.platforms = state.platforms.map((item) => (item.platform === platform ? nextPolicy : item));
+  saveRoutingState(state);
+  return nextPolicy;
+}
+
+function metricsKey(platform, providerId) {
+  return `${platform}:${providerId}`;
+}
+
+export function recordProbeResults(platform, providers, results) {
+  const state = loadRoutingState();
+  const timestamp = now();
+
+  for (const provider of providers) {
+    const result = results.find((item) => item.baseUrl === provider.baseUrl);
+    const key = metricsKey(platform, provider.id);
+    const previous = state.providers[key] || {
+      providerId: provider.id,
+      platform,
+      lastLatency: null,
+      lastCheckedAt: null,
+      lastError: null,
+      consecutiveFailures: 0,
+      lastStatus: "unknown"
+    };
+
+    if (!result) {
+      state.providers[key] = {
+        ...previous,
+        lastCheckedAt: timestamp
+      };
+      continue;
+    }
+
+    const lastStatus = !result.ok
+      ? "offline"
+      : result.latency > DEFAULT_FAILOVER_THRESHOLD_MS
+        ? "degraded"
+        : "healthy";
+
+    state.providers[key] = {
+      providerId: provider.id,
+      platform,
+      lastLatency: Number.isFinite(result.latency) ? Math.round(result.latency) : null,
+      lastCheckedAt: timestamp,
+      lastError: result.ok ? null : result.error || null,
+      consecutiveFailures: result.ok ? 0 : previous.consecutiveFailures + 1,
+      lastStatus
+    };
+  }
+
+  saveRoutingState(state);
+  return state;
+}
+
+function getProviderMetrics(state, platform, providerId) {
+  return (
+    state.providers[metricsKey(platform, providerId)] || {
+      providerId,
+      platform,
+      lastLatency: null,
+      lastCheckedAt: null,
+      lastError: null,
+      consecutiveFailures: 0,
+      lastStatus: "unknown"
+    }
+  );
+}
+
+export function estimateCostTier(model) {
+  const normalized = `${model || ""}`.toLowerCase();
+
+  if (!normalized) {
+    return "unknown";
+  }
+
+  if (normalized.includes("mini")) {
+    return "low";
+  }
+
+  if (normalized.includes("max") || normalized.includes("5.4")) {
+    return "high";
+  }
+
+  if (normalized.includes("5.3") || normalized.includes("5.2") || normalized.includes("codex")) {
+    return "medium";
+  }
+
+  return "medium";
+}
+
+export function buildRoutingSnapshot(platforms) {
+  const state = loadRoutingState();
+
+  return {
+    budgetMode: state.budgetMode,
+    monthlyBudgetUsd: state.monthlyBudgetUsd,
+    platforms: platforms.map(({ platform, providers, currentProviderId }) => {
+      const policy = ensureRoutingProviders(platform, providers, currentProviderId);
+      return {
+        platform,
+        proxyMode: policy.proxyMode,
+        autoFailover: policy.autoFailover,
+        failoverThresholdMs: policy.failoverThresholdMs,
+        maxConsecutiveFailures: policy.maxConsecutiveFailures,
+        primaryProviderId: policy.primaryProviderId,
+        fallbackProviderIds: policy.fallbackProviderIds,
+        lastFailoverAt: policy.lastFailoverAt,
+        providerStates: providers.map((provider, index) => {
+          const metrics = getProviderMetrics(state, platform, provider.id);
+          return {
+            providerId: provider.id,
+            failoverRank:
+              provider.id === policy.primaryProviderId
+                ? 0
+                : Math.max(1, policy.fallbackProviderIds.indexOf(provider.id) + 1 || index + 1),
+            role: provider.id === policy.primaryProviderId ? "primary" : policy.fallbackProviderIds.includes(provider.id) ? "fallback" : "standby",
+            health: metrics.lastStatus,
+            lastLatency: metrics.lastLatency,
+            lastCheckedAt: metrics.lastCheckedAt,
+            lastError: metrics.lastError,
+            consecutiveFailures: metrics.consecutiveFailures,
+            costTier: estimateCostTier(provider.model)
+          };
+        })
+      };
+    })
+  };
+}
+
+export function maybeFailoverPlatform(platform, providers, currentProviderId) {
+  const state = loadRoutingState();
+  const policy = state.platforms.find((item) => item.platform === platform) || createDefaultPlatformState(platform);
+
+  if (!policy.autoFailover || !currentProviderId) {
+    return null;
+  }
+
+  const currentMetrics = getProviderMetrics(state, platform, currentProviderId);
+  const shouldFailover =
+    currentMetrics.lastStatus === "offline" ||
+    currentMetrics.consecutiveFailures >= policy.maxConsecutiveFailures ||
+    (Number.isFinite(currentMetrics.lastLatency) && currentMetrics.lastLatency > policy.failoverThresholdMs);
+
+  if (!shouldFailover) {
+    return null;
+  }
+
+  const nextProvider = policy.fallbackProviderIds
+    .map((providerId) => providers.find((item) => item.id === providerId))
+    .filter(Boolean)
+    .find((provider) => {
+      const metrics = getProviderMetrics(state, platform, provider.id);
+      return metrics.lastStatus === "healthy" || metrics.lastStatus === "degraded";
+    });
+
+  if (!nextProvider || nextProvider.id === currentProviderId) {
+    return null;
+  }
+
+  state.platforms = state.platforms.map((item) =>
+    item.platform !== platform
+      ? item
+      : {
+          ...item,
+          primaryProviderId: nextProvider.id,
+          fallbackProviderIds: providers
+            .map((provider) => provider.id)
+            .filter((providerId) => providerId !== nextProvider.id),
+          lastFailoverAt: now()
+        }
+  );
+  saveRoutingState(state);
+
+  return {
+    previousProviderId: currentProviderId,
+    nextProviderId: nextProvider.id
+  };
+}
+
+export function setPrimaryProvider(platform, providerId, providerIds) {
+  return upsertPlatformRouting(platform, {
+    primaryProviderId: providerId,
+    fallbackProviderIds: providerIds.filter((item) => item !== providerId)
+  });
+}