@archal/cli 0.2.0 → 0.3.1

package/dist/chunk-XSO7ETSM.js

@@ -0,0 +1,561 @@
+// src/commands/login.ts
+import { Command } from "commander";
+import { exec } from "child_process";
+import { randomBytes } from "crypto";
+import { createServer } from "http";
+
+// src/auth.ts
+import { chmodSync, existsSync as existsSync2, readFileSync as readFileSync2, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+
+// src/config/config.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { z } from "zod";
+
+// src/utils/logger.ts
+var LOG_LEVEL_PRIORITY = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var LOG_LEVEL_COLORS = {
+  debug: "\x1B[90m",
+  // gray
+  info: "\x1B[36m",
+  // cyan
+  warn: "\x1B[33m",
+  // yellow
+  error: "\x1B[31m"
+  // red
+};
+var RESET = "\x1B[0m";
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[2m";
+var globalOptions = {
+  level: "warn",
+  quiet: false,
+  json: false,
+  verbose: false
+};
+function configureLogger(options) {
+  globalOptions = { ...globalOptions, ...options };
+}
+function shouldLog(level) {
+  if (globalOptions.quiet && level !== "error") {
+    return false;
+  }
+  return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[globalOptions.level];
+}
+function formatTimestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function formatLogEntry(entry) {
+  if (globalOptions.json) {
+    return JSON.stringify(entry);
+  }
+  const color = LOG_LEVEL_COLORS[entry.level];
+  const levelTag = `${color}${BOLD}${entry.level.toUpperCase().padEnd(5)}${RESET}`;
+  const timestamp = `${DIM}${entry.timestamp}${RESET}`;
+  let line = `${timestamp} ${levelTag} ${entry.message}`;
+  if (entry.data && Object.keys(entry.data).length > 0) {
+    const dataStr = Object.entries(entry.data).map(([k, v]) => `${DIM}${k}=${RESET}${typeof v === "string" ? v : JSON.stringify(v)}`).join(" ");
+    line += ` ${dataStr}`;
+  }
+  return line;
+}
+function log(level, message, data) {
+  if (!shouldLog(level)) {
+    return;
+  }
+  const entry = {
+    level,
+    message,
+    timestamp: formatTimestamp(),
+    data
+  };
+  const formatted = formatLogEntry(entry);
+  process.stderr.write(formatted + "\n");
+}
+function debug(message, data) {
+  log("debug", message, data);
+}
+function info(message, data) {
+  log("info", message, data);
+}
+function warn(message, data) {
+  log("warn", message, data);
+}
+function error(message, data) {
+  log("error", message, data);
+}
+function success(message) {
+  if (globalOptions.quiet) return;
+  process.stderr.write(`\x1B[32m${BOLD}  OK${RESET} ${message}
+`);
+}
+function fail(message) {
+  if (globalOptions.quiet) return;
+  process.stderr.write(`\x1B[31m${BOLD}FAIL${RESET} ${message}
+`);
+}
+function progress(message) {
+  if (!globalOptions.verbose) return;
+  process.stderr.write(`${DIM}  ...${RESET} ${message}
+`);
+}
+function banner(text) {
+  if (!globalOptions.verbose) return;
+  const line = "=".repeat(Math.max(text.length + 4, 40));
+  process.stderr.write(`
+\x1B[36m${BOLD}${line}${RESET}
+`);
+  process.stderr.write(`\x1B[36m${BOLD}  ${text}${RESET}
+`);
+  process.stderr.write(`\x1B[36m${BOLD}${line}${RESET}
+
+`);
+}
+function table(headers, rows) {
+  if (globalOptions.quiet) return;
+  const colWidths = headers.map((h, i) => {
+    const maxDataWidth = rows.reduce((max, row) => {
+      const cell = row[i] ?? "";
+      return Math.max(max, cell.length);
+    }, 0);
+    return Math.max(h.length, maxDataWidth);
+  });
+  const headerLine = headers.map((h, i) => h.padEnd(colWidths[i] ?? 0)).join("  ");
+  const separator = colWidths.map((w) => "-".repeat(w)).join("  ");
+  process.stderr.write(`${BOLD}${headerLine}${RESET}
+`);
+  process.stderr.write(`${DIM}${separator}${RESET}
+`);
+  for (const row of rows) {
+    const line = row.map((cell, i) => cell.padEnd(colWidths[i] ?? 0)).join("  ");
+    process.stderr.write(`${line}
+`);
+  }
+}
+
+// src/config/config.ts
+var ARCHAL_DIR_NAME = ".archal";
+var CONFIG_FILE_NAME = "config.json";
+var evaluatorConfigSchema = z.object({
+  model: z.string().default("claude-sonnet-4-20250514"),
+  apiKey: z.string().default("env:ANTHROPIC_API_KEY")
+});
+var defaultsConfigSchema = z.object({
+  runs: z.number().int().positive().default(5),
+  timeout: z.number().int().positive().default(120)
+});
+var configFileSchema = z.object({
+  telemetry: z.boolean().default(false),
+  evaluator: evaluatorConfigSchema.default({}),
+  defaults: defaultsConfigSchema.default({})
+});
+function getArchalDir() {
+  return join(homedir(), ARCHAL_DIR_NAME);
+}
+function getConfigPath() {
+  return join(getArchalDir(), CONFIG_FILE_NAME);
+}
+function ensureArchalDir() {
+  const dir = getArchalDir();
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+    debug("Created archal directory", { path: dir });
+  }
+  return dir;
+}
+function loadConfigFile() {
+  const configPath = getConfigPath();
+  if (!existsSync(configPath)) {
+    debug("No config file found, using defaults", { path: configPath });
+    return configFileSchema.parse({});
+  }
+  try {
+    const raw = readFileSync(configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    const config = configFileSchema.parse(parsed);
+    debug("Loaded config file", { path: configPath });
+    return config;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    warn(`Failed to parse config file at ${configPath}: ${message}`);
+    return configFileSchema.parse({});
+  }
+}
+function resolveApiKey(apiKeyConfig) {
+  if (apiKeyConfig.startsWith("env:")) {
+    const envVar = apiKeyConfig.slice(4);
+    return process.env[envVar] ?? "";
+  }
+  return apiKeyConfig;
+}
+function loadConfig() {
+  const file = loadConfigFile();
+  const envTelemetry = process.env["ARCHAL_TELEMETRY"];
+  const envModel = process.env["ARCHAL_MODEL"];
+  const envRuns = process.env["ARCHAL_RUNS"];
+  const envTimeout = process.env["ARCHAL_TIMEOUT"];
+  const envApiKey = process.env["ANTHROPIC_API_KEY"];
+  const telemetry = envTelemetry !== void 0 ? envTelemetry === "true" : file.telemetry;
+  const model = envModel ?? file.evaluator.model;
+  const runs = envRuns !== void 0 ? parseInt(envRuns, 10) : file.defaults.runs;
+  const timeout = envTimeout !== void 0 ? parseInt(envTimeout, 10) : file.defaults.timeout;
+  const apiKey = envApiKey ?? resolveApiKey(file.evaluator.apiKey);
+  return {
+    telemetry,
+    apiKey,
+    model,
+    runs: Number.isNaN(runs) ? 5 : runs,
+    timeout: Number.isNaN(timeout) ? 120 : timeout,
+    archalDir: getArchalDir(),
+    configPath: getConfigPath()
+  };
+}
+function saveConfig(config) {
+  const dir = ensureArchalDir();
+  const configPath = join(dir, CONFIG_FILE_NAME);
+  let existing;
+  if (existsSync(configPath)) {
+    try {
+      const raw = readFileSync(configPath, "utf-8");
+      existing = configFileSchema.parse(JSON.parse(raw));
+    } catch {
+      existing = configFileSchema.parse({});
+    }
+  } else {
+    existing = configFileSchema.parse({});
+  }
+  const merged = {
+    telemetry: config.telemetry ?? existing.telemetry,
+    evaluator: {
+      ...existing.evaluator,
+      ...config.evaluator
+    },
+    defaults: {
+      ...existing.defaults,
+      ...config.defaults
+    }
+  };
+  writeFileSync(configPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+  debug("Saved config file", { path: configPath });
+}
+function initConfig() {
+  const configPath = getConfigPath();
+  if (existsSync(configPath)) {
+    warn(`Config file already exists at ${configPath}`);
+    return configPath;
+  }
+  const defaultConfig = configFileSchema.parse({});
+  ensureArchalDir();
+  writeFileSync(configPath, JSON.stringify(defaultConfig, null, 2) + "\n", "utf-8");
+  return configPath;
+}
+function setConfigValue(key, value) {
+  const file = loadConfigFile();
+  const parts = key.split(".");
+  if (parts.length === 1) {
+    const topKey = parts[0];
+    if (topKey === "telemetry") {
+      saveConfig({ ...file, telemetry: value === "true" });
+      return;
+    }
+  }
+  if (parts.length === 2) {
+    const [section, prop] = parts;
+    if (section === "evaluator" && (prop === "model" || prop === "apiKey")) {
+      saveConfig({
+        ...file,
+        evaluator: { ...file.evaluator, [prop]: value }
+      });
+      return;
+    }
+    if (section === "defaults" && (prop === "runs" || prop === "timeout")) {
+      const numValue = parseInt(value, 10);
+      if (Number.isNaN(numValue) || numValue <= 0) {
+        throw new Error(`Invalid numeric value for ${key}: ${value}`);
+      }
+      saveConfig({
+        ...file,
+        defaults: { ...file.defaults, [prop]: numValue }
+      });
+      return;
+    }
+  }
+  throw new Error(
+    `Unknown config key: "${key}". Valid keys: telemetry, evaluator.model, evaluator.apiKey, defaults.runs, defaults.timeout`
+  );
+}
+function getConfigDisplay() {
+  const resolved = loadConfig();
+  return {
+    telemetry: resolved.telemetry,
+    evaluator: {
+      model: resolved.model,
+      apiKey: resolved.apiKey ? "***" + resolved.apiKey.slice(-4) : "(not set)"
+    },
+    defaults: {
+      runs: resolved.runs,
+      timeout: resolved.timeout
+    },
+    paths: {
+      archalDir: resolved.archalDir,
+      configFile: resolved.configPath
+    }
+  };
+}
+
+// src/constants.ts
+var BUNDLED_TWINS = ["github", "slack", "stripe"];
+var SELECTABLE_TWINS = [
+  "linear",
+  "jira",
+  "supabase",
+  "browser",
+  "google-workspace"
+];
+var ALL_TWINS = [...BUNDLED_TWINS, ...SELECTABLE_TWINS];
+var FREE_TIER_MAX_SELECTIONS = 3;
+var TWIN_TOOL_COUNTS = {
+  github: 18,
+  slack: 10,
+  stripe: 16,
+  linear: 12,
+  jira: 14,
+  supabase: 12,
+  browser: 8,
+  "google-workspace": 15
+};
+
+// src/auth.ts
+var CREDENTIALS_FILE = "credentials.json";
+function getCredentialsPath() {
+  return join2(ensureArchalDir(), CREDENTIALS_FILE);
+}
+function readCredentialsFile() {
+  const path = getCredentialsPath();
+  if (!existsSync2(path)) {
+    return null;
+  }
+  try {
+    const raw = readFileSync2(path, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.token !== "string" || typeof parsed.email !== "string" || typeof parsed.plan !== "string" || !Array.isArray(parsed.selectedTwins) || typeof parsed.expiresAt !== "number") {
+      return null;
+    }
+    return {
+      token: parsed.token,
+      email: parsed.email,
+      plan: parsed.plan,
+      selectedTwins: parsed.selectedTwins,
+      expiresAt: parsed.expiresAt
+    };
+  } catch {
+    return null;
+  }
+}
+function getCredentials() {
+  const creds = readCredentialsFile();
+  if (!creds) {
+    return null;
+  }
+  const nowSeconds = Math.floor(Date.now() / 1e3);
+  if (creds.expiresAt <= nowSeconds) {
+    return null;
+  }
+  return creds;
+}
+function saveCredentials(creds) {
+  const path = getCredentialsPath();
+  writeFileSync2(path, JSON.stringify(creds, null, 2) + "\n", "utf-8");
+  try {
+    chmodSync(path, 384);
+  } catch {
+  }
+}
+function deleteCredentials() {
+  const path = getCredentialsPath();
+  if (!existsSync2(path)) {
+    return false;
+  }
+  unlinkSync(path);
+  return true;
+}
+function requireAuth() {
+  const creds = getCredentials();
+  if (!creds) {
+    process.stderr.write("Not logged in. Run: archal login\n");
+    process.exit(1);
+  }
+  return creds;
+}
+async function refreshAuthFromServer(creds) {
+  try {
+    const { fetchAuthMe } = await import("./api-client-ZUMDL3TP.js");
+    const result = await fetchAuthMe(creds.token);
+    if (!result.ok) {
+      return creds;
+    }
+    const updated = {
+      ...creds,
+      email: result.data.email,
+      plan: result.data.plan,
+      selectedTwins: result.data.selectedTwins
+    };
+    if (updated.email !== creds.email || updated.plan !== creds.plan || JSON.stringify(updated.selectedTwins) !== JSON.stringify(creds.selectedTwins)) {
+      saveCredentials(updated);
+    }
+    return updated;
+  } catch {
+    return creds;
+  }
+}
+function isEntitled(creds, twinName) {
+  if (creds.plan === "pro" || creds.plan === "enterprise") {
+    return true;
+  }
+  if (BUNDLED_TWINS.includes(twinName)) {
+    return true;
+  }
+  return creds.selectedTwins.includes(twinName);
+}
+function getJwtExpiry(token) {
+  try {
+    const payloadPart = token.split(".")[1];
+    if (!payloadPart) return null;
+    const normalized = payloadPart.replace(/-/g, "+").replace(/_/g, "/");
+    const padded = normalized + "=".repeat((4 - normalized.length % 4) % 4);
+    const decoded = JSON.parse(Buffer.from(padded, "base64").toString("utf-8"));
+    return typeof decoded.exp === "number" ? decoded.exp : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/login.ts
+var AUTH_BASE_URL = process.env["ARCHAL_AUTH_URL"] ?? "https://archal.ai";
+var START_PORT = 51423;
+var LOGIN_TIMEOUT_MS = 5 * 60 * 1e3;
+function openBrowser(url) {
+  const platform = process.platform;
+  const command = platform === "darwin" ? `open "${url}"` : platform === "win32" ? `start "" "${url}"` : `xdg-open "${url}"`;
+  exec(command, () => {
+  });
+}
+function findFreePort(startPort) {
+  return new Promise((resolve, reject) => {
+    const server = createServer();
+    server.listen(startPort, "127.0.0.1", () => {
+      const address = server.address();
+      const port = typeof address === "object" && address ? address.port : startPort;
+      server.close(() => resolve(port));
+    });
+    server.on("error", () => {
+      if (startPort < START_PORT + 100) {
+        findFreePort(startPort + 1).then(resolve).catch(reject);
+      } else {
+        reject(new Error("Could not find a free localhost callback port"));
+      }
+    });
+  });
+}
+function createLoginCommand() {
+  return new Command("login").description("Log in via archal.ai browser auth").action(async () => {
+    const port = await findFreePort(START_PORT);
+    const state = randomBytes(16).toString("hex");
+    const redirectUrl = `http://localhost:${port}/callback`;
+    const authUrl = `${AUTH_BASE_URL}/cli-auth?redirect=${encodeURIComponent(redirectUrl)}&state=${encodeURIComponent(state)}`;
+    info("Opening browser for authentication...");
+    info(`If your browser does not open, visit:
+  ${authUrl}`);
+    openBrowser(authUrl);
+    await new Promise((resolve, reject) => {
+      const server = createServer((req, res) => {
+        const requestUrl = new URL(req.url ?? "/", `http://localhost:${port}`);
+        if (requestUrl.pathname !== "/callback") {
+          res.writeHead(404);
+          res.end("Not found");
+          return;
+        }
+        const returnedState = requestUrl.searchParams.get("state");
+        if (returnedState !== state) {
+          res.writeHead(400, { "content-type": "text/html; charset=utf-8" });
+          res.end("<h1>Login failed</h1><p>State mismatch.</p>");
+          server.close();
+          reject(new Error("State mismatch in callback"));
+          return;
+        }
+        const token = requestUrl.searchParams.get("token");
+        const email = requestUrl.searchParams.get("email");
+        const plan = requestUrl.searchParams.get("plan");
+        const twins = requestUrl.searchParams.get("twins");
+        if (!token || !email || !plan) {
+          res.writeHead(400, { "content-type": "text/html; charset=utf-8" });
+          res.end("<h1>Login failed</h1><p>Missing callback parameters.</p>");
+          server.close();
+          reject(new Error("Missing token/email/plan in callback"));
+          return;
+        }
+        const expiresAt = getJwtExpiry(token) ?? Math.floor(Date.now() / 1e3) + 30 * 24 * 60 * 60;
+        const credentials = {
+          token,
+          email,
+          plan,
+          selectedTwins: twins ? twins.split(",").filter(Boolean) : [],
+          expiresAt
+        };
+        saveCredentials(credentials);
+        res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+        res.end("<h1>Login successful</h1><p>You can close this tab.</p>");
+        success(`Logged in as ${email} (${plan})`);
+        server.close(() => resolve());
+      });
+      server.listen(port, "127.0.0.1");
+      const timeout = setTimeout(() => {
+        server.close();
+        reject(new Error("Login timed out. Run archal login again."));
+      }, LOGIN_TIMEOUT_MS);
+      server.on("close", () => clearTimeout(timeout));
+    }).catch((error2) => {
+      const message = error2 instanceof Error ? error2.message : String(error2);
+      error(message);
+      process.exit(1);
+    });
+  });
+}
+
+export {
+  configureLogger,
+  debug,
+  info,
+  warn,
+  error,
+  success,
+  fail,
+  progress,
+  banner,
+  table,
+  getArchalDir,
+  getConfigPath,
+  ensureArchalDir,
+  loadConfig,
+  initConfig,
+  setConfigValue,
+  getConfigDisplay,
+  BUNDLED_TWINS,
+  ALL_TWINS,
+  FREE_TIER_MAX_SELECTIONS,
+  TWIN_TOOL_COUNTS,
+  getCredentials,
+  saveCredentials,
+  deleteCredentials,
+  requireAuth,
+  refreshAuthFromServer,
+  isEntitled,
+  createLoginCommand
+};