@ch4p/cli 0.1.2 → 0.1.4

package/dist/chunk-AORLXQHZ.js

@@ -0,0 +1,304 @@
+// src/config.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { resolve, join } from "path";
+import { homedir } from "os";
+var CH4P_DIR_NAME = ".ch4p";
+var CONFIG_FILE_NAME = "config.json";
+var LOGS_DIR_NAME = "logs";
+function getCh4pDir() {
+  return resolve(homedir(), CH4P_DIR_NAME);
+}
+function getConfigPath() {
+  return join(getCh4pDir(), CONFIG_FILE_NAME);
+}
+function getLogsDir() {
+  return join(getCh4pDir(), LOGS_DIR_NAME);
+}
+function getDefaultConfig() {
+  return {
+    agent: {
+      model: "claude-sonnet-4-6",
+      provider: "anthropic",
+      thinkingLevel: "medium"
+    },
+    providers: {
+      anthropic: {
+        apiKey: "${ANTHROPIC_API_KEY}"
+      },
+      openai: {
+        apiKey: "${OPENAI_API_KEY}"
+      }
+    },
+    channels: {},
+    memory: {
+      backend: "sqlite",
+      autoSave: true,
+      vectorWeight: 0.7,
+      keywordWeight: 0.3
+    },
+    gateway: {
+      port: 18789,
+      requirePairing: true,
+      allowPublicBind: false
+    },
+    security: {
+      workspaceOnly: true,
+      blockedPaths: []
+    },
+    autonomy: {
+      level: "supervised",
+      allowedCommands: [
+        "git",
+        "npm",
+        "pnpm",
+        "node",
+        "npx",
+        "cargo",
+        "ls",
+        "cat",
+        "grep",
+        "find",
+        "wc",
+        "sort",
+        "head",
+        "tail",
+        "mkdir",
+        "cp",
+        "mv",
+        "echo",
+        "touch"
+      ]
+    },
+    engines: {
+      default: "native",
+      available: {
+        native: {
+          provider: "anthropic",
+          model: "claude-sonnet-4-6"
+        },
+        "claude-cli": {
+          command: "claude",
+          timeout: 6e5
+        },
+        "codex-cli": {
+          command: "codex",
+          timeout: 6e5
+        }
+      }
+    },
+    tunnel: {
+      provider: "none"
+    },
+    secrets: {
+      encrypt: true
+    },
+    observability: {
+      observers: ["console"],
+      logLevel: "info"
+    },
+    skills: {
+      enabled: true,
+      paths: ["~/.ch4p/skills", ".ch4p/skills", ".agents/skills"],
+      autoLoad: true,
+      contextBudget: 16e3
+    },
+    verification: {
+      enabled: true,
+      semantic: true
+    },
+    mesh: {
+      enabled: false,
+      maxConcurrency: 3,
+      defaultTimeout: 12e4
+    }
+  };
+}
+function loadEnvFile() {
+  const envPath = join(getCh4pDir(), ".env");
+  let raw;
+  try {
+    raw = readFileSync(envPath, "utf8");
+  } catch {
+    return 0;
+  }
+  let loaded = 0;
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const stripped = trimmed.startsWith("export ") ? trimmed.slice(7).trim() : trimmed;
+    const eqIdx = stripped.indexOf("=");
+    if (eqIdx === -1) continue;
+    const key = stripped.slice(0, eqIdx).trim();
+    let value = stripped.slice(eqIdx + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    if (key && process.env[key] === void 0) {
+      process.env[key] = value;
+      loaded++;
+    }
+  }
+  return loaded;
+}
+function resolveEnvVars(obj, missing) {
+  if (typeof obj === "string") {
+    return obj.replace(/\$\{([^}]+)\}/g, (_match, varName) => {
+      const value = process.env[varName];
+      if (value === void 0) {
+        missing?.add(varName);
+      }
+      return value ?? "";
+    });
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => resolveEnvVars(item, missing));
+  }
+  if (obj !== null && typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = resolveEnvVars(value, missing);
+    }
+    return result;
+  }
+  return obj;
+}
+function deepMerge(target, source, seen = /* @__PURE__ */ new WeakSet()) {
+  if (seen.has(source)) return target;
+  seen.add(source);
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const sourceVal = source[key];
+    const targetVal = result[key];
+    if (sourceVal !== null && typeof sourceVal === "object" && !Array.isArray(sourceVal) && targetVal !== null && typeof targetVal === "object" && !Array.isArray(targetVal)) {
+      result[key] = deepMerge(
+        targetVal,
+        sourceVal,
+        seen
+      );
+    } else {
+      result[key] = sourceVal;
+    }
+  }
+  return result;
+}
+function validateConfig(config) {
+  const errors = [];
+  if (!config.agent?.model) {
+    errors.push({ field: "agent.model", message: "Model is required" });
+  }
+  if (!config.agent?.provider) {
+    errors.push({ field: "agent.provider", message: "Provider is required" });
+  }
+  if (config.agent?.maxToolResults != null && (typeof config.agent.maxToolResults !== "number" || config.agent.maxToolResults < 1)) {
+    errors.push({ field: "agent.maxToolResults", message: "Must be a positive number" });
+  }
+  if (config.agent?.maxToolOutputLen != null && (typeof config.agent.maxToolOutputLen !== "number" || config.agent.maxToolOutputLen < 1024)) {
+    errors.push({ field: "agent.maxToolOutputLen", message: "Must be at least 1024 bytes" });
+  }
+  if (config.agent?.maxStateRecords != null && (typeof config.agent.maxStateRecords !== "number" || config.agent.maxStateRecords < 1)) {
+    errors.push({ field: "agent.maxStateRecords", message: "Must be a positive number" });
+  }
+  if (config.agent?.maxSessionErrors != null && (typeof config.agent.maxSessionErrors !== "number" || config.agent.maxSessionErrors < 1)) {
+    errors.push({ field: "agent.maxSessionErrors", message: "Must be a positive number" });
+  }
+  if (config.agent?.runTimeout != null && (typeof config.agent.runTimeout !== "number" || config.agent.runTimeout < 3e4)) {
+    errors.push({ field: "agent.runTimeout", message: "Must be at least 30000 (30 seconds)" });
+  }
+  if (typeof config.gateway?.port !== "number" || config.gateway.port < 1 || config.gateway.port > 65535) {
+    errors.push({ field: "gateway.port", message: "Port must be a number between 1 and 65535" });
+  }
+  if (config.autonomy?.level && !["readonly", "supervised", "full"].includes(config.autonomy.level)) {
+    errors.push({ field: "autonomy.level", message: "Must be one of: readonly, supervised, full" });
+  }
+  if (config.observability?.logLevel && !["debug", "info", "warn", "error"].includes(config.observability.logLevel)) {
+    errors.push({ field: "observability.logLevel", message: "Must be one of: debug, info, warn, error" });
+  }
+  if (config.memory?.backend && !["sqlite", "markdown", "noop"].includes(config.memory.backend)) {
+    errors.push({ field: "memory.backend", message: "Must be one of: sqlite, markdown, noop" });
+  }
+  if (config.tunnel?.provider && !["none", "cloudflare", "tailscale", "ngrok"].includes(config.tunnel.provider)) {
+    errors.push({ field: "tunnel.provider", message: "Must be one of: none, cloudflare, tailscale, ngrok" });
+  }
+  if (config.engines?.default && config.engines.available && !Object.keys(config.engines.available).includes(config.engines.default)) {
+    errors.push({
+      field: "engines.default",
+      message: `Engine "${config.engines.default}" is not defined in engines.available`
+    });
+  }
+  if (config.skills?.contextBudget != null && (typeof config.skills.contextBudget !== "number" || config.skills.contextBudget < 0)) {
+    errors.push({ field: "skills.contextBudget", message: "Must be a non-negative number" });
+  }
+  if (config.mesh?.maxConcurrency != null && (typeof config.mesh.maxConcurrency !== "number" || config.mesh.maxConcurrency < 1)) {
+    errors.push({ field: "mesh.maxConcurrency", message: "Must be a positive number" });
+  }
+  if (config.mesh?.defaultTimeout != null && (typeof config.mesh.defaultTimeout !== "number" || config.mesh.defaultTimeout < 1e3)) {
+    errors.push({ field: "mesh.defaultTimeout", message: "Must be at least 1000ms" });
+  }
+  return errors;
+}
+function ensureConfigDir() {
+  const ch4pDir = getCh4pDir();
+  const logsDir = getLogsDir();
+  if (!existsSync(ch4pDir)) {
+    mkdirSync(ch4pDir, { recursive: true, mode: 448 });
+  }
+  if (!existsSync(logsDir)) {
+    mkdirSync(logsDir, { recursive: true, mode: 448 });
+  }
+}
+function loadConfig() {
+  loadEnvFile();
+  const defaults = getDefaultConfig();
+  let merged = defaults;
+  const configPath = getConfigPath();
+  if (existsSync(configPath)) {
+    try {
+      const raw = readFileSync(configPath, "utf8");
+      const userConfig = JSON.parse(raw);
+      merged = deepMerge(defaults, userConfig);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      throw new ConfigLoadError(`Failed to parse ${configPath}: ${message}`);
+    }
+  }
+  const missingVars = /* @__PURE__ */ new Set();
+  const resolved = resolveEnvVars(merged, missingVars);
+  for (const varName of missingVars) {
+    console.warn(`  \u26A0  Config references \${${varName}} but it is not set in environment.`);
+  }
+  const errors = validateConfig(resolved);
+  if (errors.length > 0) {
+    const details = errors.map((e) => `  - ${e.field}: ${e.message}`).join("\n");
+    throw new ConfigLoadError(`Configuration validation failed:
+${details}`);
+  }
+  return resolved;
+}
+function saveConfig(config) {
+  ensureConfigDir();
+  const configPath = getConfigPath();
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", {
+    encoding: "utf8",
+    mode: 384
+  });
+}
+function configExists() {
+  return existsSync(getConfigPath());
+}
+var ConfigLoadError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigLoadError";
+  }
+};
+
+export {
+  getCh4pDir,
+  getConfigPath,
+  getLogsDir,
+  getDefaultConfig,
+  ensureConfigDir,
+  loadConfig,
+  saveConfig,
+  configExists
+};