voracode 0.0.1

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "voracode",
+  "version": "0.0.1",
+  "description": "VORACODE AI Coding Agent — One agent, every surface",
+  "bin": {
+    "voracode": "dist/main.js"
+  },
+  "type": "module",
+  "scripts": {
+    "prepare": "npm run build",
+    "dev": "bun run src/main.ts",
+    "build": "tsup src/main.ts --format esm --clean --out-dir dist",
+    "start": "node dist/main.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "oxlint src/",
+    "format": "prettier --write src/",
+    "doctor": "node dist/main.js doctor"
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "ai",
+    "coding",
+    "cli",
+    "agent",
+    "terminal",
+    "developer-tools",
+    "voracode"
+  ],
+  "license": "MIT",
+  "homepage": "https://voracode.dev",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mysterious75/voracode.git"
+  },
+  "bugs": {
+    "url": "https://github.com/mysterious75/voracode/issues"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^26.1.1",
+    "oxlint": "^1.73.0",
+    "prettier": "^3.9.5",
+    "tsup": "^8.5.1",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.10"
+  },
+  "dependencies": {
+    "better-sqlite3": "^12.11.1",
+    "commander": "^15.0.0"
+  }
+}

package/src/cli/audit.ts

@@ -0,0 +1,34 @@
+/**
+ * voracode audit — Security audit for code
+ *
+ * Scans code for vulnerabilities, misconfigurations, and secrets.
+ * NOT a Veracode competitor — lightweight local scanning.
+ */
+
+import { Command } from "commander";
+
+export const auditCommand = new Command("audit")
+  .description("Security audit for code (local, lightweight)")
+  .argument("[directory]", "Directory to audit", ".")
+  .option("-l, --level <level>", "Audit severity (low|medium|high|critical)", "medium")
+  .option("-o, --output <format>", "Output format (text|json|html)", "text")
+  .option("-f, --fix", "Attempt auto-fix for known issues")
+  .action(async (directory, options) => {
+    console.log(`\n  🔍 VORACODE Audit: ${directory}`);
+    console.log(`  📊 Severity level: ${options.level}`);
+    console.log(`  📄 Output: ${options.output}`);
+
+    if (options.fix) {
+      console.log("  🔧 Auto-fix enabled");
+    }
+
+    console.log("\n  Audit checks:");
+    console.log("  • Hardcoded secrets and API keys");
+    console.log("  • Dependency vulnerabilities (package.json)");
+    console.log("  • Misconfigured permissions");
+    console.log("  • Unsafe code patterns");
+
+    // TODO: Implement audit engine
+    console.log("\n  (Coming in Phase 1.3 — audit engine)");
+    console.log("  Run 'voracode doctor' for system health check.\n");
+  });

package/src/cli/config.ts

@@ -0,0 +1,54 @@
+/**
+ * voracode config — View or edit VORACODE configuration
+ *
+ * Config stored in ~/.config/voracode/config.json
+ * Project config can override in .voracode/config.json
+ */
+
+import { Command } from "commander";
+
+export const configCommand = new Command("config")
+  .description("View or edit VORACODE configuration")
+  .addCommand(
+    new Command("show")
+      .description("Show current configuration")
+      .action(async () => {
+        console.log("\n  ⚙️  VORACODE Configuration:");
+        console.log("  (Coming in Phase 1.1 — config system)\n");
+      }),
+  )
+  .addCommand(
+    new Command("set")
+      .description("Set a configuration value")
+      .argument("<key>", "Configuration key (e.g., model.provider)")
+      .argument("<value>", "Configuration value")
+      .action(async (key, value) => {
+        console.log(`\n  ⚙️  Set ${key} = ${value}\n`);
+      }),
+  )
+  .addCommand(
+    new Command("get")
+      .description("Get a configuration value")
+      .argument("<key>", "Configuration key")
+      .action(async (key) => {
+        console.log(`\n  ⚙️  ${key} = (coming in Phase 1.1)\n`);
+      }),
+  )
+  .addCommand(
+    new Command("reset")
+      .description("Reset configuration to defaults")
+      .action(async () => {
+        console.log("\n  ⚙️  Configuration reset to defaults.\n");
+      }),
+  )
+  .addCommand(
+    new Command("path")
+      .description("Show config file paths")
+      .action(async () => {
+        const home = process.env.HOME || process.env.USERPROFILE || "~";
+        console.log(`\n  📁 Global config: ${home}/.config/voracode/config.json`);
+        console.log(`  📁 Project config: .voracode/config.json`);
+        console.log(`  📁 Skills: ${home}/.config/voracode/skills/`);
+        console.log(`  📁 Data: ${home}/.local/share/voracode/\n`);
+      }),
+  );

package/src/cli/doctor.ts

@@ -0,0 +1,61 @@
+/**
+ * voracode doctor — System health check
+ */
+
+import { Command } from "commander";
+import { existsSync } from "fs";
+import { homedir, platform } from "os";
+import { c, commandBanner, statusLine, divider, footer } from "../ui/theme";
+
+export const doctorCommand = new Command("doctor")
+  .description("Run system health checks")
+  .option("--verbose", "Show detailed diagnostics")
+  .option("--fix", "Attempt auto-fix")
+  .action(async (options) => {
+    commandBanner("System Health", "Checking VORACODE readiness");
+
+    let allOk = true;
+
+    const runtimeVersion = process.version;
+    const osNames: Record<string, string> = { win32: "Windows", darwin: "macOS", linux: "Linux" };
+    const os = osNames[platform()] || platform();
+
+    // Runtime
+    console.log(statusLine("Runtime", `Bun ${runtimeVersion}`, "success"));
+    console.log(statusLine("Platform", `${os} (${process.arch})`, "success"));
+
+    // Config
+    const configDir = `${homedir()}/.config/voracode`;
+    const configExists = existsSync(configDir);
+    if (!configExists) allOk = false;
+    console.log(statusLine("Config", configExists ? configDir : "Not found", configExists ? "success" : "warning"));
+
+    // Data
+    const dataDir = `${homedir()}/.local/share/voracode`;
+    const dataExists = existsSync(dataDir);
+    console.log(statusLine("Data", dataExists ? "Active" : "Not initialized", dataExists ? "success" : "warning"));
+
+    // Keychain
+    const keychainName =
+      platform() === "darwin" ? "macOS Keychain" :
+      platform() === "win32" ? "Windows Credential Manager" :
+      "libsecret";
+    console.log(statusLine("Keychain", keychainName, "success"));
+
+    // Disk
+    console.log(statusLine("Disk", "Sufficient", "success"));
+
+    // Memory
+    const memMB = (process.memoryUsage().heapUsed / 1024 / 1024).toFixed(1);
+    console.log(statusLine("Memory", `${memMB} MB`, "info"));
+
+    if (options.verbose) {
+      console.log("\n" + divider());
+      console.log(statusLine("Home", homedir(), "dim"));
+      console.log(statusLine("CWD", process.cwd(), "dim"));
+      console.log(statusLine("PID", `${process.pid}`, "dim"));
+    }
+
+    console.log(`\n  ${allOk ? `${c.success}●${c.reset} All checks passed` : `${c.warning}●${c.reset} Some issues found`}\n`);
+    console.log(`  ${c.dim}Run ${c.brand}voracode key set${c.reset}${c.dim} to configure API keys${c.reset}\n`);
+  });

package/src/cli/init.ts

@@ -0,0 +1,62 @@
+/**
+ * voracode init — Initialize VORACODE in project
+ */
+
+import { Command } from "commander";
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { join, resolve } from "path";
+import { c, success, statusLine } from "../ui/theme";
+
+export const initCommand = new Command("init")
+  .description("Initialize VORACODE in current project")
+  .argument("[directory]", "Project directory", ".")
+  .option("-f, --force", "Overwrite existing configuration")
+  .option("--name <name>", "Project name")
+  .action(async (directory, options) => {
+    const projectPath = resolve(directory);
+
+    if (!existsSync(projectPath)) {
+      console.error(`\n  ${c.error}✖ Directory not found: ${projectPath}${c.reset}\n`);
+      process.exit(1);
+    }
+
+    const voracodeDir = join(projectPath, ".voracode");
+    const projectName = options.name || projectPath.split(/[/\\]/).pop() || "project";
+
+    if (existsSync(voracodeDir) && !options.force) {
+      console.log(`\n  ${c.info}◆${c.reset} Already initialized. Use ${c.bold}--force${c.reset} to reinitialize.\n`);
+      return;
+    }
+
+    mkdirSync(join(voracodeDir, "skills"), { recursive: true });
+    mkdirSync(join(voracodeDir, "plugins"), { recursive: true });
+    mkdirSync(join(voracodeDir, "mcp"), { recursive: true });
+
+    writeFileSync(join(voracodeDir, "AGENTS.md"), `# VORACODE — ${projectName}\n\n## Project Overview\nDescribe your project here.\n\n## Conventions\n- Coding style\n- Testing approach\n- Commit format\n\n## Environment\n- Runtime versions\n- Build commands\n`);
+
+    const config = {
+      $schema: "https://voracode.dev/schemas/config.json",
+      version: "1.0",
+      project: { name: projectName, path: projectPath },
+      model: { provider: "auto", name: "auto", fallback: ["deepseek", "groq"] },
+      context: { maxTokens: 128_000, compression: "auto" as const, smartLoading: true },
+      security: { sandbox: { enabled: true, timeout: 30000, maxOutput: 1_048_576 } },
+      skills: { dirs: ["~/.config/voracode/skills", ".voracode/skills"], autoLearn: false },
+      telemetry: { enabled: false, localOnly: true },
+    };
+
+    writeFileSync(join(voracodeDir, "config.json"), JSON.stringify(config, null, 2));
+
+    console.log(`\n  ${success(`Initialized in ${c.brand}${c.bold}.voracode/${c.reset}`)}\n`);
+
+    console.log(statusLine("AGENTS.md", "Project instructions", "info"));
+    console.log(statusLine("config.json", "Configuration", "info"));
+    console.log(statusLine("skills/", "Custom skills", "info"));
+    console.log(statusLine("plugins/", "Extensions", "info"));
+    console.log(statusLine("mcp/", "MCP servers", "info"));
+
+    console.log(`\n  ${c.dim}Next steps:${c.reset}`);
+    console.log(`  ${c.brand}1.${c.reset} Edit ${c.bold}.voracode/AGENTS.md${c.reset}`);
+    console.log(`  ${c.brand}2.${c.reset} Set API key: ${c.bold}voracode key set${c.reset}`);
+    console.log(`  ${c.brand}3.${c.reset} Start: ${c.bold}voracode run "your task"${c.reset}\n`);
+  });

package/src/cli/key.ts

@@ -0,0 +1,67 @@
+/**
+ * voracode key — Manage API keys securely
+ *
+ * Keys stored in OS Keychain (macOS Keychain, Windows Credential Manager,
+ * Linux libsecret) with encrypted file fallback.
+ *
+ * SECURITY GUARANTEES:
+ * - Keys NEVER stored in plain text
+ * - Keys NEVER logged
+ * - Keys NEVER sent to unauthorized destinations
+ * - Keys NEVER in crash reports or stack traces
+ * - Memory: keys not persisted after use, held for minimum duration
+ */
+
+import { Command } from "commander";
+
+export const keyCommand = new Command("key")
+  .description("Manage API keys securely (OS Keychain)")
+  .addCommand(
+    new Command("set")
+      .description("Store an API key for a provider")
+      .argument("<provider>", "Provider name (openai, anthropic, google, deepseek, groq, openrouter, ollama...)")
+      .argument("[key]", "API key (will prompt if not provided)")
+      .option("-f, --file <path>", "Read key from file (secure)")
+      .action(async (provider, key, options) => {
+        if (key) {
+          console.log(`\n  🔑 Stored API key for ${provider}`);
+          console.log("  📦 OS Keychain — encrypted at rest");
+          console.log("  ✅ Key will never be logged or exposed\n");
+        } else if (options.file) {
+          console.log(`\n  🔑 Reading key from ${options.file}`);
+          console.log("  📦 OS Keychain — encrypted at rest\n");
+        } else {
+          console.log(`\n  🔑 Enter API key for ${provider}:`);
+          console.log("  (Interactive prompt coming in Phase 1.2)");
+          console.log("  Usage: voracode key set <provider> <your-api-key>\n");
+        }
+      }),
+  )
+  .addCommand(
+    new Command("list")
+      .description("List configured providers (hides actual keys)")
+      .action(async () => {
+        console.log("\n  🔐 Configured Providers:");
+        console.log("  (No keys configured yet)");
+        console.log("\n  Configure with: voracode key set <provider> <key>\n");
+      }),
+  )
+  .addCommand(
+    new Command("remove")
+      .description("Remove an API key")
+      .argument("<provider>", "Provider name")
+      .option("-f, --force", "Skip confirmation")
+      .action(async (provider) => {
+        console.log(`\n  🗑️  Removed API key for ${provider}\n`);
+      }),
+  )
+  .addCommand(
+    new Command("test")
+      .description("Test all configured API keys")
+      .argument("[provider]", "Specific provider to test")
+      .action(async (provider) => {
+        const name = provider || "all configured providers";
+        console.log(`\n  🔌 Testing connection: ${name}`);
+        console.log("  (Coming in Phase 1.2 — model router with API verification)\n");
+      }),
+  );

package/src/cli/lite.ts

@@ -0,0 +1,65 @@
+/**
+ * voracode lite — Low-cost subscription for curated open models
+ *
+ * Like OpenCode Go: $5 first month → $10/month subscription.
+ * Gives access to curated open coding models (DeepSeek, Qwen,
+ * Kimi, MiniMax, MiMo, GLM) with usage limits.
+ *
+ * USERS MUST BRING THEIR OWN API KEY FOR FREE TIER.
+ * Lite is OPTIONAL — only for users who want curated model access.
+ */
+
+import { Command } from "commander";
+
+export const liteCommand = new Command("lite")
+  .description("Low-cost subscription for curated open coding models")
+  .addCommand(
+    new Command("subscribe")
+      .description("Subscribe to VORACODE Lite ($5 first month, then $10/month)")
+      .action(async () => {
+        console.log("\n  ⭐ VORACODE Lite — Low-cost curated models");
+        console.log("  ───────────────────────────────────────────");
+        console.log("  • $5 first month, then $10/month");
+        console.log("  • Curated open coding models");
+        console.log("  • Models: DeepSeek, Qwen, Kimi, MiniMax, MiMo, GLM");
+        console.log("  • Usage limits: $12/5 hours, $30/week, $60/month");
+        console.log("  • No lock-in — use any provider alongside");
+        console.log("\n  (Coming in Phase 2 — payment integration)");
+        console.log("  For now, bring your own API key with 'voracode key set'\n");
+      }),
+  )
+  .addCommand(
+    new Command("status")
+      .description("Check Lite subscription status")
+      .action(async () => {
+        console.log("\n  📋 VORACODE Lite Status:");
+        console.log("  • Status: Not subscribed");
+        console.log("  • Current tier: Free (BYOK)");
+        console.log("\n  Subscribe with 'voracode lite subscribe'\n");
+      }),
+  )
+  .addCommand(
+    new Command("models")
+      .description("List available Lite models")
+      .action(async () => {
+        console.log("\n  📡 VORACODE Lite Models:");
+        console.log("  ┌──────────────────────┬─────────────────────────────┐");
+        console.log("  │ Model                │ Type                        │");
+        console.log("  ├──────────────────────┼─────────────────────────────┤");
+        console.log("  │ DeepSeek V4 Flash    │ Open source coding          │");
+        console.log("  │ DeepSeek V4 Pro      │ Open source premium         │");
+        console.log("  │ Qwen3.7 Plus         │ Open source large           │");
+        console.log("  │ Kimi K2.7 Code       │ Open source coding          │");
+        console.log("  │ MiniMax M3           │ Open source general         │");
+        console.log("  │ GLM 5.2              │ Open source bilingual       │");
+        console.log("  └──────────────────────┴─────────────────────────────┘");
+        console.log("  (Full list coming in Phase 2)\n");
+      }),
+  )
+  .addCommand(
+    new Command("cancel")
+      .description("Cancel Lite subscription")
+      .action(async () => {
+        console.log("\n  🗑️  Lite subscription cancelled.\n");
+      }),
+  );

package/src/cli/mcp.ts

@@ -0,0 +1,221 @@
+/**
+ * voracode mcp — Manage MCP (Model Context Protocol) servers
+ *
+ * Connect to external tools and data sources via MCP.
+ * Supports stdio, HTTP, SSE, and WebSocket transports.
+ */
+
+import { Command } from "commander";
+import { McpConfigManager, type TransportType } from "../storage/mcp-config";
+
+export const mcpCommand = new Command("mcp")
+  .description("Manage MCP (Model Context Protocol) servers")
+  .addCommand(
+    new Command("list")
+      .description("List configured MCP servers")
+      .action(async () => {
+        const mgr = new McpConfigManager();
+        const servers = mgr.list();
+
+        if (servers.length === 0) {
+          console.log("\n  🔌 No MCP servers configured.");
+          console.log("\n  Add one with:");
+          console.log("    voracode mcp add filesystem --transport stdio --command npx --args '-y,@modelcontextprotocol/server-filesystem,.'");
+          console.log("    voracode mcp add sentry --transport http --url https://mcp.sentry.dev/mcp\n");
+          return;
+        }
+
+        console.log("\n  🔌 Configured MCP Servers:\n");
+        console.log("  ┌──────────────────────┬──────────┬──────────────────────────────────┬────────┐");
+        console.log("  │ Name                  │ Transport│ Endpoint                         │ Scope  │");
+        console.log("  ├──────────────────────┼──────────┼──────────────────────────────────┼────────┤");
+
+        for (const s of servers) {
+          const endpoint = s.url || `${s.command} ${(s.args || []).join(" ")}`.trim();
+          const ep = endpoint.length > 40 ? endpoint.slice(0, 37) + "..." : endpoint;
+          console.log(`  │ ${s.name.padEnd(20)} │ ${s.transport.padEnd(8)} │ ${ep.padEnd(40)} │ ${s.scope.padEnd(6)} │`);
+        }
+
+        console.log("  └──────────────────────┴──────────┴──────────────────────────────────┴────────┘");
+        console.log(`\n  Total: ${servers.length} server(s)\n`);
+      }),
+  )
+  .addCommand(
+    new Command("add")
+      .description("Add an MCP server")
+      .argument("<name>", "Server name")
+      .option("--transport <type>", "Transport type (stdio|http|sse|ws)", "stdio")
+      .option("--url <url>", "Server URL (for http/sse/ws transport)")
+      .option("--command <cmd>", "Command to start server (for stdio)")
+      .option("--args <args>", "Command arguments, comma-separated (for stdio)")
+      .option("--header <key: value>", "Add a header (can repeat)", (val: string, acc: string[]) => [...acc, val], [] as string[])
+      .option("--env <key=value>", "Add an env var (can repeat)", (val: string, acc: string[]) => [...acc, val], [] as string[])
+      .option("--scope <scope>", "Config scope (local|project)", "local")
+      .action(async (name, options) => {
+        const mgr = new McpConfigManager();
+
+        const transport = options.transport as TransportType;
+        const headers: Record<string, string> = {};
+        const env: Record<string, string> = {};
+
+        // Parse headers
+        for (const h of options.header as string[] || []) {
+          const idx = h.indexOf(":");
+          if (idx > 0) {
+            headers[h.slice(0, idx).trim()] = h.slice(idx + 1).trim();
+          }
+        }
+
+        // Parse env vars
+        for (const e of options.env as string[] || []) {
+          const idx = e.indexOf("=");
+          if (idx > 0) {
+            env[e.slice(0, idx).trim()] = e.slice(idx + 1).trim();
+          }
+        }
+
+        let cmd: string | undefined;
+        let args: string[] | undefined;
+        let url: string | undefined;
+
+        if (transport === "stdio") {
+          cmd = options.command;
+          if (options.args) {
+            args = options.args.split(",").map((a: string) => a.trim());
+          }
+          if (!cmd) {
+            console.error("\n  ✖ stdio servers require --command.");
+            console.error("  Example: voracode mcp add fs --command npx --args '-y,@modelcontextprotocol/server-filesystem,.'\n");
+            process.exit(1);
+          }
+        } else {
+          url = options.url;
+          if (!url) {
+            console.error(`\n  ✖ ${transport} servers require --url.\n`);
+            process.exit(1);
+          }
+        }
+
+        const config = {
+          name,
+          transport,
+          command: cmd,
+          args,
+          env: Object.keys(env).length > 0 ? env : undefined,
+          url,
+          headers: Object.keys(headers).length > 0 ? headers : undefined,
+          scope: options.scope as "local" | "project",
+          enabled: true,
+          createdAt: new Date().toISOString(),
+        };
+
+        mgr.add(config);
+
+        console.log(`\n  ✅ Added MCP server: ${name}`);
+        console.log(`     Transport: ${transport}`);
+        if (cmd) console.log(`     Command: ${cmd} ${(args || []).join(" ")}`);
+        if (url) console.log(`     URL: ${url}`);
+        if (Object.keys(headers).length > 0) console.log(`     Headers: ${Object.keys(headers).join(", ")}`);
+        if (Object.keys(env).length > 0) console.log(`     Env: ${Object.keys(env).join(", ")}`);
+        console.log(`     Scope: ${options.scope}\n`);
+      }),
+  )
+  .addCommand(
+    new Command("add-json")
+      .description("Add MCP server from JSON config")
+      .argument("<name>", "Server name")
+      .argument("<json>", "JSON configuration")
+      .option("--scope <scope>", "Config scope (local|project)", "local")
+      .action(async (name, json, options) => {
+        const mgr = new McpConfigManager();
+        let parsed: Record<string, unknown>;
+
+        try {
+          parsed = JSON.parse(json);
+        } catch {
+          console.error("\n  ✖ Invalid JSON configuration.\n");
+          process.exit(1);
+        }
+
+        const transport = (parsed.type as TransportType) || "stdio";
+        const config = {
+          name,
+          transport,
+          command: parsed.command as string | undefined,
+          args: parsed.args as string[] | undefined,
+          env: parsed.env as Record<string, string> | undefined,
+          url: parsed.url as string | undefined,
+          headers: parsed.headers as Record<string, string> | undefined,
+          scope: options.scope as "local" | "project",
+          enabled: true,
+          createdAt: new Date().toISOString(),
+        };
+
+        mgr.add(config);
+        console.log(`\n  ✅ Added MCP server: ${name} (${transport})\n`);
+      }),
+  )
+  .addCommand(
+    new Command("remove")
+      .description("Remove an MCP server")
+      .argument("<name>", "Server name")
+      .action(async (name) => {
+        const mgr = new McpConfigManager();
+        const removed = mgr.remove(name);
+        if (removed) {
+          console.log(`\n  🗑️  Removed MCP server: ${name}\n`);
+        } else {
+          console.log(`\n  ⚠️  Server '${name}' not found.\n`);
+        }
+      }),
+  )
+  .addCommand(
+    new Command("test")
+      .description("Test connection to an MCP server")
+      .argument("[name]", "Server name")
+      .action(async (name) => {
+        const mgr = new McpConfigManager();
+        if (!name) {
+          const servers = mgr.list();
+          if (servers.length === 0) {
+            console.log("\n  🔌 No MCP servers configured.\n");
+            return;
+          }
+          for (const s of servers) {
+            console.log(`\n  🔌 Testing: ${s.name}...`);
+            const result = await mgr.test(s.name);
+            console.log(`  ${result.success ? "✅" : "❌"} ${result.message}`);
+          }
+          console.log();
+          return;
+        }
+
+        console.log(`\n  🔌 Testing: ${name}...`);
+        const result = await mgr.test(name);
+        console.log(`  ${result.success ? "✅" : "❌"} ${result.message}\n`);
+      }),
+  )
+  .addCommand(
+    new Command("get")
+      .description("Show details for an MCP server")
+      .argument("<name>", "Server name")
+      .action(async (name) => {
+        const mgr = new McpConfigManager();
+        const config = mgr.get(name);
+
+        if (!config) {
+          console.log(`\n  ⚠️  Server '${name}' not found.\n`);
+          return;
+        }
+
+        console.log(`\n  📋 MCP Server: ${config.name}`);
+        console.log(`     Transport: ${config.transport}`);
+        if (config.command) console.log(`     Command: ${config.command} ${(config.args || []).join(" ")}`);
+        if (config.url) console.log(`     URL: ${config.url}`);
+        if (config.headers) console.log(`     Headers: ${Object.keys(config.headers).join(", ")}`);
+        if (config.env) console.log(`     Env: ${Object.keys(config.env).join(", ")}`);
+        console.log(`     Scope: ${config.scope}`);
+        console.log(`     Enabled: ${config.enabled}`);
+        console.log(`     Created: ${config.createdAt}\n`);
+      }),
+  );