march-control-cli 0.1.3

package/core/paths.js

@@ -0,0 +1,71 @@
+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 getMarchPresetPath() {
+  return path.join(getMarchDir(), "presets.json");
+}
+
+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 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 getPlatformTargetFiles(platform) {
+  switch (platform) {
+    case "codex":
+      return [getMarchStorePath(platform), getCodexConfigPath(), getCodexAuthPath()];
+    case "opencode":
+      return [getMarchStorePath(platform), getOpenCodeConfigPath()];
+    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/store.js

@@ -0,0 +1,218 @@
+import { DEFAULT_PRIMARY_MODEL } from "./constants.js";
+import { getMarchDir, getMarchStorePath } from "./paths.js";
+import {
+  ensureDir,
+  findByName,
+  findByNameOrId,
+  generateId,
+  readJson,
+  writeJson
+} from "./utils.js";
+
+function createEmptyStore() {
+  return {
+    providers: [],
+    currentProviderId: null
+  };
+}
+
+export function loadPlatformStore(platform) {
+  const storePath = getMarchStorePath(platform);
+  const loaded = readJson(storePath, createEmptyStore());
+
+  return {
+    providers: Array.isArray(loaded?.providers) ? loaded.providers : [],
+    currentProviderId: typeof loaded?.currentProviderId === "string" ? loaded.currentProviderId : null
+  };
+}
+
+export function savePlatformStore(platform, store) {
+  ensureDir(getMarchDir());
+  writeJson(getMarchStorePath(platform), {
+    providers: Array.isArray(store.providers) ? store.providers : [],
+    currentProviderId: store.currentProviderId || null
+  });
+}
+
+export function listProviders(platform) {
+  return loadPlatformStore(platform).providers;
+}
+
+export function getCurrentProvider(platform) {
+  const store = loadPlatformStore(platform);
+  return store.providers.find((provider) => provider.id === store.currentProviderId) || null;
+}
+
+function ensureUniqueProviderName(providers, name, exceptId = null) {
+  const target = name.trim().toLowerCase();
+  const conflict = providers.find(
+    (provider) =>
+      provider.id !== exceptId && provider.name.trim().toLowerCase() === target
+  );
+
+  if (conflict) {
+    throw new Error(`Provider name already exists: ${name}`);
+  }
+}
+
+export function upsertProvider(platform, input, options = {}) {
+  const store = loadPlatformStore(platform);
+  const name = input.name.trim();
+  const now = new Date().toISOString();
+  const existing = findByName(store.providers, name);
+
+  let provider;
+
+  if (existing) {
+    provider = {
+      ...existing,
+      baseUrl: input.baseUrl,
+      apiKey: input.apiKey,
+      model: input.model || existing.model || DEFAULT_PRIMARY_MODEL,
+      updatedAt: now
+    };
+    store.providers = store.providers.map((item) => (item.id === provider.id ? provider : item));
+  } else {
+    provider = {
+      id: generateId(platform),
+      name,
+      baseUrl: input.baseUrl,
+      apiKey: input.apiKey,
+      model: input.model || DEFAULT_PRIMARY_MODEL,
+      createdAt: now,
+      updatedAt: now
+    };
+    store.providers.push(provider);
+  }
+
+  if (options.activate !== false) {
+    store.currentProviderId = provider.id;
+  }
+
+  savePlatformStore(platform, store);
+  return provider;
+}
+
+export function updateProvider(platform, nameOrId, updates, options = {}) {
+  const store = loadPlatformStore(platform);
+  const current = findByNameOrId(store.providers, nameOrId);
+
+  if (!current) {
+    throw new Error(`Provider not found: ${nameOrId}`);
+  }
+
+  const nextName = `${updates?.name ?? current.name}`.trim();
+  if (!nextName) {
+    throw new Error("Provider name cannot be empty");
+  }
+
+  ensureUniqueProviderName(store.providers, nextName, current.id);
+
+  const nextProvider = {
+    ...current,
+    name: nextName,
+    baseUrl: `${updates?.baseUrl ?? current.baseUrl}`.trim() || current.baseUrl,
+    apiKey: `${updates?.apiKey ?? current.apiKey}`.trim() || current.apiKey,
+    model: `${updates?.model ?? current.model ?? DEFAULT_PRIMARY_MODEL}`.trim() || DEFAULT_PRIMARY_MODEL,
+    updatedAt: new Date().toISOString()
+  };
+
+  store.providers = store.providers.map((provider) => (provider.id === current.id ? nextProvider : provider));
+
+  if (options.activate === true) {
+    store.currentProviderId = nextProvider.id;
+  }
+
+  savePlatformStore(platform, store);
+  return nextProvider;
+}
+
+export function cloneProvider(platform, nameOrId, input, options = {}) {
+  const store = loadPlatformStore(platform);
+  const source = findByNameOrId(store.providers, nameOrId);
+
+  if (!source) {
+    throw new Error(`Provider not found: ${nameOrId}`);
+  }
+
+  const nextName = `${input?.name || ""}`.trim();
+  if (!nextName) {
+    throw new Error("Clone name cannot be empty");
+  }
+
+  ensureUniqueProviderName(store.providers, nextName);
+  const now = new Date().toISOString();
+  const cloned = {
+    ...source,
+    id: generateId(platform),
+    name: nextName,
+    baseUrl: `${input?.baseUrl ?? source.baseUrl}`.trim() || source.baseUrl,
+    apiKey: `${input?.apiKey ?? source.apiKey}`.trim() || source.apiKey,
+    model: `${input?.model ?? source.model ?? DEFAULT_PRIMARY_MODEL}`.trim() || DEFAULT_PRIMARY_MODEL,
+    clonedFrom: source.id,
+    createdAt: now,
+    updatedAt: now
+  };
+
+  store.providers.push(cloned);
+  if (options.activate === true) {
+    store.currentProviderId = cloned.id;
+  }
+
+  savePlatformStore(platform, store);
+  return cloned;
+}
+
+export function removeProvider(platform, nameOrId, options = {}) {
+  const store = loadPlatformStore(platform);
+  const target = findByNameOrId(store.providers, nameOrId);
+
+  if (!target) {
+    throw new Error(`Provider not found: ${nameOrId}`);
+  }
+
+  store.providers = store.providers.filter((provider) => provider.id !== target.id);
+  let nextCurrent = null;
+
+  if (store.currentProviderId === target.id) {
+    if (options.activateFallback === false || store.providers.length === 0) {
+      store.currentProviderId = null;
+    } else {
+      nextCurrent = store.providers[store.providers.length - 1];
+      store.currentProviderId = nextCurrent.id;
+    }
+  } else {
+    nextCurrent = store.providers.find((provider) => provider.id === store.currentProviderId) || null;
+  }
+
+  savePlatformStore(platform, store);
+
+  return {
+    removedProvider: target,
+    currentProvider: nextCurrent
+  };
+}
+
+export function switchProvider(platform, nameOrId) {
+  const store = loadPlatformStore(platform);
+  const provider = findByNameOrId(store.providers, nameOrId);
+
+  if (!provider) {
+    throw new Error(`Provider not found: ${nameOrId}`);
+  }
+
+  store.currentProviderId = provider.id;
+  savePlatformStore(platform, store);
+  return provider;
+}
+
+export function resolveStoredProvider(platform, nameOrId) {
+  const store = loadPlatformStore(platform);
+  const provider = findByNameOrId(store.providers, nameOrId);
+
+  if (!provider) {
+    throw new Error(`Provider not found: ${nameOrId}`);
+  }
+
+  return provider;
+}

package/core/utils.js

@@ -0,0 +1,178 @@
+import fs from "node:fs";
+import path from "node:path";
+
+export function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+export function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true, mode: 0o700 });
+}
+
+export function readJson(filePath, fallback = null) {
+  if (!fs.existsSync(filePath)) {
+    return fallback;
+  }
+
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch {
+    return fallback;
+  }
+}
+
+export function writeJson(filePath, value) {
+  ensureDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+}
+
+export function readText(filePath, fallback = "") {
+  if (!fs.existsSync(filePath)) {
+    return fallback;
+  }
+
+  try {
+    return fs.readFileSync(filePath, "utf8");
+  } catch {
+    return fallback;
+  }
+}
+
+export function writeText(filePath, value) {
+  ensureDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, value, { mode: 0o600 });
+}
+
+export function deepMerge(base, patch) {
+  if (!isRecord(base)) {
+    return cloneValue(patch);
+  }
+
+  if (!isRecord(patch)) {
+    return cloneValue(base);
+  }
+
+  const result = { ...base };
+
+  for (const [key, value] of Object.entries(patch)) {
+    if (isRecord(value) && isRecord(result[key])) {
+      result[key] = deepMerge(result[key], value);
+      continue;
+    }
+
+    result[key] = cloneValue(value);
+  }
+
+  return result;
+}
+
+function cloneValue(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => cloneValue(item));
+  }
+
+  if (isRecord(value)) {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, nested]) => [key, cloneValue(nested)])
+    );
+  }
+
+  return value;
+}
+
+export function normalizeBaseUrl(url) {
+  return url.trim().replace(/\/+$/, "");
+}
+
+export function buildOpenClawBaseUrl(baseUrl) {
+  return `${normalizeBaseUrl(baseUrl)}/v1`;
+}
+
+export function dedupeStrings(values) {
+  const seen = new Set();
+  const result = [];
+
+  for (const rawValue of values) {
+    const value = typeof rawValue === "string" ? rawValue.trim() : "";
+    if (!value) {
+      continue;
+    }
+
+    const key = value.toLowerCase();
+    if (seen.has(key)) {
+      continue;
+    }
+
+    seen.add(key);
+    result.push(value);
+  }
+
+  return result;
+}
+
+export function parseCommaList(value) {
+  if (!value) {
+    return [];
+  }
+
+  return dedupeStrings(value.split(",").map((item) => item.trim()).filter(Boolean));
+}
+
+export function generateId(prefix) {
+  return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+
+export function findByName(items, name) {
+  const target = name.trim().toLowerCase();
+  return items.find((item) => item.name.trim().toLowerCase() === target);
+}
+
+export function findByNameOrId(items, value) {
+  const trimmed = value.trim();
+  const lowered = trimmed.toLowerCase();
+  return items.find((item) => item.id === trimmed || item.name.trim().toLowerCase() === lowered);
+}
+
+export function replaceCaseInsensitiveKey(record, nextKey, nextValue) {
+  const result = isRecord(record) ? { ...record } : {};
+  const target = nextKey.toLowerCase();
+
+  for (const key of Object.keys(result)) {
+    if (key.toLowerCase() === target) {
+      delete result[key];
+    }
+  }
+
+  result[nextKey] = nextValue;
+  return result;
+}
+
+export function providerKeyFromName(name) {
+  const normalized = name
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+
+  return normalized || "march";
+}
+
+export function maskApiKey(apiKey) {
+  if (!apiKey) {
+    return "(empty)";
+  }
+
+  if (apiKey.length <= 10) {
+    return `${apiKey.slice(0, 2)}***${apiKey.slice(-2)}`;
+  }
+
+  return `${apiKey.slice(0, 4)}***${apiKey.slice(-4)}`;
+}
+
+export function formatLatency(result) {
+  if (!result.ok) {
+    return result.error || "failed";
+  }
+
+  return `${result.latency} ms`;
+}