@sleepwalkerai/cli 0.1.0

package/src/config.js

@@ -0,0 +1,83 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+export const DEFAULT_API_BASE_URL = "https://api.sleepwalker.ai";
+
+export function configDir(env = process.env) {
+  if (env.SLEEPWALKER_CONFIG_DIR) {
+    return env.SLEEPWALKER_CONFIG_DIR;
+  }
+  return path.join(os.homedir(), ".sleepwalker");
+}
+
+export function configPath(env = process.env) {
+  return path.join(configDir(env), "config.json");
+}
+
+export function readConfig(env = process.env) {
+  const file = configPath(env);
+  try {
+    const raw = fs.readFileSync(file, "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch (error) {
+    if (error && error.code === "ENOENT") {
+      return {};
+    }
+    throw new Error(`Could not read Sleepwalker config at ${file}: ${error.message}`);
+  }
+}
+
+export function writeConfig(config, env = process.env) {
+  const dir = configDir(env);
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  fs.chmodSync(dir, 0o700);
+  const file = configPath(env);
+  fs.writeFileSync(file, `${JSON.stringify(config, null, 2)}\n`, {
+    encoding: "utf8",
+    mode: 0o600,
+  });
+  fs.chmodSync(file, 0o600);
+}
+
+export function getApiBaseUrl(env = process.env, config = readConfig(env)) {
+  return String(env.SLEEPWALKER_API_BASE_URL || config.apiBaseUrl || DEFAULT_API_BASE_URL).replace(/\/+$/, "");
+}
+
+export function getApiKey(env = process.env, config = readConfig(env)) {
+  return String(env.SLEEPWALKER_API_KEY || config.apiKey || "").trim();
+}
+
+export function getApiKeySource(env = process.env, config = readConfig(env)) {
+  const envKey = String(env.SLEEPWALKER_API_KEY || "").trim();
+  if (envKey) {
+    return { source: "env", key: envKey };
+  }
+  const configKey = String(config.apiKey || "").trim();
+  if (configKey) {
+    return { source: "config", key: configKey };
+  }
+  return { source: "missing", key: "" };
+}
+
+export function getApiBaseUrlSource(env = process.env, config = readConfig(env)) {
+  if (env.SLEEPWALKER_API_BASE_URL) {
+    return { source: "env", value: getApiBaseUrl(env, config) };
+  }
+  if (config.apiBaseUrl) {
+    return { source: "config", value: getApiBaseUrl(env, config) };
+  }
+  return { source: "default", value: DEFAULT_API_BASE_URL };
+}
+
+export function maskApiKey(key) {
+  const value = String(key || "");
+  if (!value) {
+    return "";
+  }
+  if (value.length <= 14) {
+    return `${value.slice(0, 5)}...`;
+  }
+  return `${value.slice(0, 12)}...${value.slice(-4)}`;
+}

package/src/format.js

@@ -0,0 +1,121 @@
+import { createTheme, sanitizeTerminalText, styleStatus } from "./theme.js";
+
+export function printJson(stdout, value) {
+  stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+
+export function asList(value) {
+  if (!value) {
+    return [];
+  }
+  return Array.isArray(value) ? value : [value];
+}
+
+export function printKeyValue(stdout, rows, theme = createTheme({ stdout })) {
+  const visibleRows = rows.filter((row) => row && row[1] !== undefined && row[1] !== null && row[1] !== "");
+  const width = Math.max(...visibleRows.map(([key]) => String(key).length), 0);
+  for (const [key, value] of visibleRows) {
+    stdout.write(`${theme.muted(String(key).padEnd(width))}  ${value ?? ""}\n`);
+  }
+}
+
+function valueCount(value) {
+  if (Array.isArray(value)) {
+    return value.length;
+  }
+  if (typeof value === "number") {
+    return value;
+  }
+  if (typeof value === "string" && value.trim()) {
+    return value.split(",").map((item) => item.trim()).filter(Boolean).length;
+  }
+  return 0;
+}
+
+function valueLabel(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => sanitizeTerminalText(item)).join(", ");
+  }
+  return sanitizeTerminalText(value);
+}
+
+function hasNonZeroCreditValue(value) {
+  if (value === undefined || value === null || value === "") {
+    return false;
+  }
+  const numeric = Number(value);
+  return Number.isNaN(numeric) || numeric !== 0;
+}
+
+function billingRows(run, theme) {
+  const billing = run.billing && typeof run.billing === "object" ? run.billing : {};
+  const rows = [];
+  const estimated = run.estimated_credits || billing.estimated_credits;
+  const reserved = run.reserved_credits || billing.reserved_credits;
+  const settled = run.settled_credits || billing.settled_credits;
+  const released = run.released_credits || billing.released_credits;
+  const status = run.billing_status || billing.status;
+  if (estimated) {
+    rows.push(["Estimated credits", theme.info(estimated)]);
+  }
+  if (reserved) {
+    rows.push(["Reserved credits", theme.warning(reserved)]);
+  }
+  if (settled) {
+    rows.push(["Settled credits", theme.accent(settled)]);
+  }
+  if (hasNonZeroCreditValue(released)) {
+    rows.push(["Released credits", theme.info(released)]);
+  }
+  if (status) {
+    rows.push(["Billing", styleStatus(theme, status)]);
+  }
+  return rows;
+}
+
+export function printNextCommands(stdout, commands, theme = createTheme({ stdout })) {
+  const visible = asList(commands).filter(Boolean);
+  if (!visible.length) {
+    return;
+  }
+  stdout.write(`\n${theme.accent("Next")}\n`);
+  for (const command of visible) {
+    stdout.write(`  ${theme.command(command)}\n`);
+  }
+}
+
+export function printRunSummary(stdout, payload, type, theme = createTheme({ stdout }), options = {}) {
+  const run = payload || {};
+  const id = run.run_id || run.id;
+  const platforms = run.platforms || run.platform || run.ai_platforms;
+  const promptCount = run.prompt_count || run.prompts_count || valueCount(run.prompts);
+  const platformCount = run.platform_count || valueCount(platforms);
+  const probeCount = run.probe_count || run.total_probes || run.summary?.total_probes || valueCount(run.probes);
+  const rows = [
+    ["Type", type],
+    ["Run ID", id ? theme.id(id) : "unknown"],
+    ["Status", styleStatus(theme, run.status || "unknown")],
+    ["URL", run.url ? theme.info(run.url) : ""],
+    ["Target", sanitizeTerminalText(run.target_entity || run.brand_name || run.target || "")],
+    ["Platforms", valueLabel(platforms) || ""],
+    ["Prompts", promptCount || ""],
+    ["Platform count", !platforms && platformCount ? platformCount : ""],
+    ["Probes", probeCount || ""],
+  ];
+  rows.push(...billingRows(run, theme));
+  if (run.skipped_probe_count) {
+    rows.push(["Skipped probes", theme.warning(run.skipped_probe_count)]);
+  }
+  printKeyValue(stdout, rows, theme);
+  printNextCommands(stdout, options.nextCommands, theme);
+}
+
+export function printList(stdout, items, render) {
+  if (!items.length) {
+    stdout.write("No records found.\n");
+    return;
+  }
+  for (const item of items) {
+    stdout.write(`${render(item)}\n`);
+  }
+}

package/src/http.js

@@ -0,0 +1,85 @@
+import { getApiBaseUrl, getApiKey, getApiKeySource, readConfig } from "./config.js";
+
+export class SleepwalkerApiError extends Error {
+  constructor(message, { status, payload } = {}) {
+    super(message);
+    this.name = "SleepwalkerApiError";
+    this.status = status;
+    this.payload = payload;
+  }
+}
+
+export function createApiClient({ env = process.env, fetchImpl = globalThis.fetch } = {}) {
+  if (typeof fetchImpl !== "function") {
+    throw new Error("This Node.js runtime does not expose fetch. Use Node 18.17 or newer.");
+  }
+  const config = readConfig(env);
+  const baseUrl = getApiBaseUrl(env, config);
+  const apiKey = getApiKey(env, config);
+  const apiKeySource = getApiKeySource(env, config).source;
+
+  async function request(method, pathname, { query, body, requireAuth = true } = {}) {
+    if (requireAuth && !apiKey) {
+      throw new SleepwalkerApiError(
+        "No API key configured. Set SLEEPWALKER_API_KEY or run `sleepwalker auth key set <key>`.",
+        { status: 401 },
+      );
+    }
+
+    const url = new URL(pathname, `${baseUrl}/`);
+    for (const [key, value] of Object.entries(query || {})) {
+      if (value !== undefined && value !== null && value !== "") {
+        url.searchParams.set(key, String(value));
+      }
+    }
+
+    const headers = {
+      Accept: "application/json",
+    };
+    if (body !== undefined) {
+      headers["Content-Type"] = "application/json";
+    }
+    if (apiKey) {
+      headers.Authorization = `Bearer ${apiKey}`;
+    }
+
+    const response = await fetchImpl(url, {
+      method,
+      headers,
+      body: body === undefined ? undefined : JSON.stringify(body),
+    });
+
+    const text = await response.text();
+    let payload = null;
+    if (text) {
+      try {
+        payload = JSON.parse(text);
+      } catch {
+        payload = { raw: text };
+      }
+    }
+
+    if (!response.ok) {
+      const detail = payload && payload.detail ? payload.detail : payload;
+      let message = typeof detail === "string"
+        ? detail
+        : detail && typeof detail === "object" && detail.error
+          ? detail.error
+          : `Sleepwalker API returned HTTP ${response.status}`;
+      if (message === "API key is missing required scope") {
+        message = "This API key cannot run the requested action. Create a new key in Sleepwalker Console > API; new keys include the full API action surface.";
+      }
+      throw new SleepwalkerApiError(message, { status: response.status, payload });
+    }
+
+    return payload;
+  }
+
+  return {
+    baseUrl,
+    apiKeySource,
+    request,
+    get: (pathname, options) => request("GET", pathname, options),
+    post: (pathname, body, options = {}) => request("POST", pathname, { ...options, body }),
+  };
+}

package/src/theme.js

@@ -0,0 +1,178 @@
+const RESET = "\u001b[0m";
+
+const CODES = {
+  bold: "\u001b[1m",
+  dim: "\u001b[2m",
+  green: "\u001b[38;2;34;197;94m",
+  greenSoft: "\u001b[38;2;186;247;203m",
+  purple: "\u001b[38;2;167;139;250m",
+  blue: "\u001b[38;2;96;165;250m",
+  cyan: "\u001b[38;2;34;211;238m",
+  yellow: "\u001b[38;2;245;158;11m",
+  orange: "\u001b[38;2;249;115;22m",
+  red: "\u001b[38;2;239;68;68m",
+  muted: "\u001b[38;2;148;163;184m",
+};
+
+const WORDMARK = [
+  String.raw`     _                              _ _`,
+  String.raw` ___| | ___  ___ _ ____      ____ _| | | _____ _ __`,
+  "/ __| |/ _ \\/ _ \\ '_ \\ \\ /\\ / / _` | | |/ / _ \\ '__|",
+  String.raw`\__ \ |  __/  __/ |_) \ V  V / (_| | |   <  __/ |`,
+  String.raw`|___/_|\___|\___| .__/ \_/\_/ \__,_|_|_|\_\___|_|`,
+  String.raw`                |_|`,
+].join("\n");
+
+function shouldUseColor(env, stdout) {
+  if (env.NO_COLOR !== undefined) {
+    return false;
+  }
+  if (env.FORCE_COLOR && env.FORCE_COLOR !== "0") {
+    return true;
+  }
+  return Boolean(stdout && stdout.isTTY);
+}
+
+function wrap(enabled, code, value) {
+  const text = sanitizeTerminalText(value);
+  return enabled ? `${code}${text}${RESET}` : text;
+}
+
+export function sanitizeTerminalText(value) {
+  return String(value ?? "").replace(/[\x00-\x08\x0B-\x1F\x7F-\x9F\u061C\u200E\u200F\u202A-\u202E\u2066-\u2069]/g, "");
+}
+
+export function createTheme({ env = process.env, stdout = process.stdout } = {}) {
+  const enabled = shouldUseColor(env, stdout);
+  return {
+    enabled,
+    bold: (value) => wrap(enabled, CODES.bold, value),
+    dim: (value) => wrap(enabled, CODES.dim, value),
+    accent: (value) => wrap(enabled, CODES.green, value),
+    accentSoft: (value) => wrap(enabled, CODES.greenSoft, value),
+    ci: (value) => wrap(enabled, CODES.purple, value),
+    info: (value) => wrap(enabled, CODES.blue, value),
+    id: (value) => wrap(enabled, CODES.cyan, value),
+    warning: (value) => wrap(enabled, CODES.yellow, value),
+    orange: (value) => wrap(enabled, CODES.orange, value),
+    error: (value) => wrap(enabled, CODES.red, value),
+    muted: (value) => wrap(enabled, CODES.muted, value),
+    command: (value) => wrap(enabled, CODES.purple, value),
+  };
+}
+
+export function styleStatus(theme, status) {
+  const value = String(status || "unknown");
+  const normalized = value.toLowerCase();
+  if (["completed", "settled", "succeeded", "success", "operational"].includes(normalized)) {
+    return theme.accent(value);
+  }
+  if (["queued", "running", "partially_queued", "pending"].includes(normalized)) {
+    return theme.warning(value);
+  }
+  if (["released", "skipped", "cancelled"].includes(normalized)) {
+    return theme.info(value);
+  }
+  if (["failed", "fail", "errored", "error", "denied", "site_error", "blocked"].includes(normalized)) {
+    return theme.error(value);
+  }
+  return theme.muted(value);
+}
+
+export function renderWelcome(theme, options = {}) {
+  const hasApiKey = Boolean(options.hasApiKey);
+  const apiKeySource = options.apiKeySource || "missing";
+  const apiBaseUrl = options.apiBaseUrl || "https://api.sleepwalker.ai";
+  const configError = options.configError || "";
+  const command = (value) => theme.command(value);
+  const section = (value) => theme.accent(value);
+  const muted = (value) => theme.muted(value);
+  return `${theme.accent(WORDMARK)}
+${theme.accent("Sleepwalker")} ${theme.ci("CLI")} ${theme.muted("command line")}
+${theme.muted("AI Visibility | Content Intelligence | MCP | API | CLI")}
+
+${section("Start here")}
+${configError ? `  ${theme.warning("Config needs attention:")} ${configError}\n` : ""}${hasApiKey
+    ? `  ${theme.accent("API key detected")} ${muted(`(${apiKeySource})`)}
+  ${command("sleepwalker menu")}          Open the interactive command menu.
+  ${command("sleepwalker doctor")}        Check account, API reachability, and credits.
+  ${command("sleepwalker credits")}       Show prepaid credits.
+`
+    : `  ${command("sleepwalker init")}          Follow the setup checklist.
+  ${command("sleepwalker auth key set <api_key>")}
+  ${command("sleepwalker doctor")}        Check the connection.
+`}
+
+${hasApiKey
+    ? `${section("Common workflows")}
+  ${command("sleepwalker page serialize <url>")}
+  ${command("sleepwalker visibility run <url>")} ${muted("--brand <brand> --prompt <prompt> --platform <platform>")}
+  ${command("sleepwalker ci run <url>")} ${muted("[--depth score|full] [--watch]")}
+  ${command("sleepwalker reports by-url <url>")}
+`
+    : `${section("After setup")}
+  ${command("sleepwalker commands")}      Choose an action once the CLI is authenticated.
+`}
+
+${section("More")}
+${hasApiKey ? `  ${command("sleepwalker commands")}      Show every command and option.\n` : ""}  ${command("sleepwalker config show")}   Show local configuration.
+
+${section("API base")}
+  ${theme.info(apiBaseUrl)}
+`;
+}
+
+export function renderCommandsHelp(theme) {
+  const command = (value) => theme.command(value);
+  const section = (value) => theme.accent(value);
+  const muted = (value) => theme.muted(value);
+  return `${theme.accent(WORDMARK)}
+${theme.accent("Sleepwalker")} ${theme.ci("CLI")} ${theme.muted("command reference")}
+
+${section("Usage")}
+  ${command("sleepwalker <command> [options]")}
+
+${section("Setup")}
+  ${command("sleepwalker menu")}
+  ${command("sleepwalker init")}
+  ${command("sleepwalker auth key set <api_key>")}
+  ${command("sleepwalker auth key show")}
+  ${command("sleepwalker auth key clear")}
+  ${command("sleepwalker auth whoami")}
+  ${command("sleepwalker doctor")}
+  ${command("sleepwalker config show")}
+  ${command("sleepwalker config set api-base-url <url>")}
+  ${command("sleepwalker config clear api-base-url")}
+
+${section("Read")}
+  ${command("sleepwalker credits")}
+  ${command("sleepwalker usage")} ${muted("[--recent-limit 20]")}
+  ${command("sleepwalker activity list")} ${muted("[--limit 10] [--kind all]")}
+  ${command("sleepwalker tests list")} ${muted("[--limit 20] [--type ai_citations|content_intelligence]")}
+  ${command("sleepwalker reports by-url <url>")} ${muted("[--type ai_citations|content_intelligence]")}
+
+${section("Actions")}
+  ${command("sleepwalker page serialize <url>")} ${muted("[--max-chars 4000] [--offset 0]")}
+  ${command("sleepwalker visibility suggest-prompts <url>")} ${muted("--brand <brand>")}
+  ${command("sleepwalker visibility run <url>")} ${muted("--brand <brand> --prompt <prompt> --platform <platform> [--watch] [--idempotency-key <key>]")}
+  ${command("sleepwalker visibility status <run_id>")} ${muted("[--results]")}
+  ${command("sleepwalker visibility list")} ${muted("[--limit 20] [--status queued|running|completed|failed]")}
+  ${command("sleepwalker ci score <url>")}
+  ${command("sleepwalker ci run <url>")} ${muted("[--depth score|full] [--watch] [--idempotency-key <key>]")}
+  ${command("sleepwalker ci status <run_id>")} ${muted("[--result]")}
+  ${command("sleepwalker ci list")} ${muted("[--limit 20] [--status queued|running|completed|failed]")}
+
+${section("Global options")}
+  ${theme.info("--json")}          Print raw JSON responses.
+  ${theme.info("--help")}          Show help.
+  ${theme.info("--version")}       Show version.
+
+${section("Environment")}
+  ${theme.info("SLEEPWALKER_API_KEY")}       API key from the Sleepwalker Console.
+  ${theme.info("SLEEPWALKER_API_BASE_URL")}  API base URL. Defaults to https://api.sleepwalker.ai.
+`;
+}
+
+export function renderHelp(theme, options = {}) {
+  return renderWelcome(theme, options);
+}