ccnew 0.1.10

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,225 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+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 pathExists(targetPath) {
+  return fs.existsSync(targetPath);
+}
+
+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 resolveHomePath(input) {
+  const raw = `${input ?? ""}`.trim();
+  if (!raw) {
+    return "";
+  }
+
+  if (raw === "~") {
+    return os.homedir();
+  }
+
+  if (raw.startsWith("~/")) {
+    return path.join(os.homedir(), raw.slice(2));
+  }
+
+  return path.resolve(raw);
+}
+
+export function toTildePath(targetPath) {
+  const resolved = path.resolve(targetPath);
+  const homeDir = path.resolve(os.homedir());
+
+  if (resolved === homeDir) {
+    return "~";
+  }
+
+  if (resolved.startsWith(`${homeDir}${path.sep}`)) {
+    return `~${path.sep}${resolved.slice(homeDir.length + 1)}`;
+  }
+
+  return resolved;
+}
+
+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 slugify(value, fallback = "item") {
+  const normalized = `${value ?? ""}`
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+
+  return normalized || fallback;
+}
+
+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 || "fhl";
+}
+
+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`;
+}

package/core/writers/codex.js

@@ -0,0 +1,102 @@
+import TOML from "@iarna/toml";
+import { DEFAULT_PRIMARY_MODEL, DEFAULT_PROVIDER_NAME } from "../constants.js";
+import { getCodexAuthPath, getCodexConfigPath, getCodexDir } from "../paths.js";
+import {
+  deepMerge,
+  ensureDir,
+  isRecord,
+  providerKeyFromName,
+  readJson,
+  readText,
+  replaceCaseInsensitiveKey,
+  writeJson,
+  writeText
+} from "../utils.js";
+
+const DEFAULT_CODEX_CONFIG = {
+  model: DEFAULT_PRIMARY_MODEL,
+  model_reasoning_effort: "xhigh",
+  disable_response_storage: true,
+  sandbox_mode: "danger-full-access",
+  windows_wsl_setup_acknowledged: true,
+  approval_policy: "never",
+  profile: "auto-max",
+  file_opener: "vscode",
+  web_search: "cached",
+  suppress_unstable_features_warning: true,
+  history: {
+    persistence: "save-all"
+  },
+  tui: {
+    notifications: true
+  },
+  shell_environment_policy: {
+    inherit: "all",
+    ignore_default_excludes: false
+  },
+  sandbox_workspace_write: {
+    network_access: true
+  },
+  features: {
+    plan_tool: true,
+    apply_patch_freeform: true,
+    view_image_tool: true
+  },
+  profiles: {
+    "auto-max": {
+      approval_policy: "never",
+      sandbox_mode: "workspace-write"
+    }
+  }
+};
+
+function loadCodexConfig(configPath) {
+  const raw = readText(configPath, "");
+  if (!raw.trim()) {
+    return {};
+  }
+
+  try {
+    return TOML.parse(raw);
+  } catch {
+    return {};
+  }
+}
+
+function buildManagedProvider(provider) {
+  return {
+    name: provider.name || DEFAULT_PROVIDER_NAME,
+    base_url: provider.baseUrl,
+    wire_api: "responses",
+    requires_openai_auth: true
+  };
+}
+
+export function writeCodexConfig(provider, options = {}) {
+  ensureDir(getCodexDir());
+
+  const configPath = getCodexConfigPath();
+  const authPath = getCodexAuthPath();
+  const providerKey = providerKeyFromName(provider.name);
+  const mode = options.mode === "overwrite" ? "overwrite" : "merge";
+  const baseConfig = mode === "overwrite" ? {} : loadCodexConfig(configPath);
+  const merged = deepMerge(DEFAULT_CODEX_CONFIG, isRecord(baseConfig) ? baseConfig : {});
+  const existingProviders =
+    mode === "overwrite" || !isRecord(merged.model_providers) ? {} : merged.model_providers;
+
+  merged.model = provider.model || DEFAULT_PRIMARY_MODEL;
+  merged.model_provider = providerKey;
+  merged.model_providers = replaceCaseInsensitiveKey(
+    existingProviders,
+    providerKey,
+    buildManagedProvider(provider)
+  );
+
+  writeText(configPath, TOML.stringify(merged));
+
+  const existingAuth = mode === "overwrite" ? {} : readJson(authPath, {});
+  writeJson(authPath, {
+    ...existingAuth,
+    OPENAI_API_KEY: provider.apiKey
+  });
+}

package/core/writers/index.js

@@ -0,0 +1,16 @@
+import { writeCodexConfig } from "./codex.js";
+import { writeOpenClawConfig } from "./openclaw.js";
+import { writeOpenCodeConfig } from "./opencode.js";
+
+export function writePlatformConfig(platform, provider, options = {}) {
+  switch (platform) {
+    case "codex":
+      return writeCodexConfig(provider, options);
+    case "opencode":
+      return writeOpenCodeConfig(provider, options);
+    case "openclaw":
+      return writeOpenClawConfig(provider, options);
+    default:
+      throw new Error(`Unsupported platform: ${platform}`);
+  }
+}

package/core/writers/openclaw.js

@@ -0,0 +1,93 @@
+import path from "node:path";
+import { DEFAULT_PRIMARY_MODEL, DEFAULT_PROVIDER_NAME, MODEL_DEFINITIONS } from "../constants.js";
+import { getHomeDir, getOpenClawConfigPath, getOpenClawDir, getOpenClawModelsPath } from "../paths.js";
+import {
+  ensureDir,
+  isRecord,
+  providerKeyFromName,
+  readJson,
+  replaceCaseInsensitiveKey,
+  writeJson
+} from "../utils.js";
+
+function buildOpenClawModels() {
+  return MODEL_DEFINITIONS.map((model) => ({
+    id: model.id,
+    name: model.id,
+    api: "openai-responses",
+    reasoning: model.reasoning,
+    input: ["text", "image"],
+    cost: {
+      input: 0,
+      output: 0,
+      cacheRead: 0,
+      cacheWrite: 0
+    },
+    contextWindow: model.contextWindow,
+    maxTokens: model.maxTokens
+  }));
+}
+
+function buildProviderConfig(provider) {
+  return {
+    baseUrl: provider.baseUrl,
+    apiKey: provider.apiKey,
+    api: "openai-responses",
+    authHeader: true,
+    headers: {
+      "User-Agent": "codex-rs/1.0.7"
+    },
+    models: buildOpenClawModels()
+  };
+}
+
+export function writeOpenClawConfig(provider, options = {}) {
+  ensureDir(getOpenClawDir());
+  ensureDir(path.dirname(getOpenClawModelsPath()));
+
+  const configPath = getOpenClawConfigPath();
+  const modelsPath = getOpenClawModelsPath();
+  const mode = options.mode === "overwrite" ? "overwrite" : "merge";
+  const providerName = providerKeyFromName(provider.name || DEFAULT_PROVIDER_NAME);
+  const providerConfig = buildProviderConfig(provider);
+  const existingConfig = mode === "overwrite" ? {} : readJson(configPath, {});
+  const existingModels = mode === "overwrite" ? {} : readJson(modelsPath, {});
+  const existingConfigProviders =
+    mode === "overwrite" || !isRecord(existingConfig?.models?.providers)
+      ? {}
+      : existingConfig.models.providers;
+  const existingModelProviders =
+    mode === "overwrite" || !isRecord(existingModels?.providers) ? {} : existingModels.providers;
+
+  const configPayload = {
+    ...(isRecord(existingConfig) ? existingConfig : {}),
+    models: {
+      mode: "merge",
+      ...(isRecord(existingConfig?.models) ? existingConfig.models : {}),
+      providers: replaceCaseInsensitiveKey(existingConfigProviders, providerName, providerConfig)
+    },
+    agents: {
+      ...(isRecord(existingConfig?.agents) ? existingConfig.agents : {}),
+      defaults: {
+        ...(isRecord(existingConfig?.agents?.defaults) ? existingConfig.agents.defaults : {}),
+        workspace: getHomeDir(),
+        imageModel: `${providerName}/${provider.model || DEFAULT_PRIMARY_MODEL}`,
+        model: {
+          ...(isRecord(existingConfig?.agents?.defaults?.model)
+            ? existingConfig.agents.defaults.model
+            : {}),
+          primary: `${providerName}/${provider.model || DEFAULT_PRIMARY_MODEL}`
+        },
+        thinkingDefault: "xhigh"
+      }
+    }
+  };
+
+  const modelsPayload = {
+    ...(isRecord(existingModels) ? existingModels : {}),
+    providers: replaceCaseInsensitiveKey(existingModelProviders, providerName, providerConfig)
+  };
+
+  writeJson(configPath, configPayload);
+  writeJson(modelsPath, modelsPayload);
+}