@tryghost/velo-cli 0.1.0

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,398 @@
+#!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/login.ts
+import { createServer } from "http";
+import { URL } from "url";
+import chalk from "chalk";
+import open from "open";
+import ora from "ora";
+
+// src/config.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var API_BASE_URL = "https://velo.tryghost.workers.dev";
+var DEFAULT_CALLBACK_PORT = 9876;
+function getConfigDir() {
+  return join(homedir(), ".config", "velo");
+}
+function getCredentialsPath() {
+  return join(getConfigDir(), "credentials.json");
+}
+function loadCredentials() {
+  const path = getCredentialsPath();
+  if (!existsSync(path)) {
+    return null;
+  }
+  try {
+    const data = readFileSync(path, "utf-8");
+    const creds = JSON.parse(data);
+    if (new Date(creds.expires_at) < /* @__PURE__ */ new Date()) {
+      return null;
+    }
+    return creds;
+  } catch {
+    return null;
+  }
+}
+function saveCredentials(credentials) {
+  const dir = getConfigDir();
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(getCredentialsPath(), JSON.stringify(credentials, null, 2));
+}
+function clearCredentials() {
+  const path = getCredentialsPath();
+  if (existsSync(path)) {
+    const { unlinkSync } = __require("fs");
+    unlinkSync(path);
+    return true;
+  }
+  return false;
+}
+
+// src/api.ts
+var APIError = class extends Error {
+  constructor(message, statusCode, body) {
+    super(message);
+    this.statusCode = statusCode;
+    this.body = body;
+    this.name = "APIError";
+  }
+};
+async function apiRequest(endpoint, options = {}) {
+  const credentials = loadCredentials();
+  if (!credentials) {
+    throw new APIError("Not logged in. Run `velo login` first.", 401);
+  }
+  const url = `${API_BASE_URL}${endpoint}`;
+  const headers = new Headers(options.headers);
+  headers.set("Authorization", `Bearer ${credentials.token}`);
+  headers.set("Content-Type", "application/json");
+  const response = await fetch(url, {
+    ...options,
+    headers
+  });
+  if (!response.ok) {
+    let body;
+    try {
+      body = await response.json();
+    } catch {
+      body = await response.text();
+    }
+    throw new APIError(
+      `API request failed: ${response.statusText}`,
+      response.status,
+      body
+    );
+  }
+  return response.json();
+}
+async function verifyToken(token) {
+  const url = `${API_BASE_URL}/cli/verify`;
+  const response = await fetch(url, {
+    headers: {
+      "Authorization": `Bearer ${token}`
+    }
+  });
+  return response.json();
+}
+
+// src/commands/login.ts
+async function login() {
+  const existing = loadCredentials();
+  if (existing) {
+    console.log(chalk.yellow(`Already logged in as ${existing.email}`));
+    console.log(chalk.gray(`Token expires: ${new Date(existing.expires_at).toLocaleDateString()}`));
+    console.log(chalk.gray(`Run ${chalk.cyan("velo logout")} to log out first.`));
+    return;
+  }
+  const port = DEFAULT_CALLBACK_PORT;
+  const loginUrl = `${API_BASE_URL}/cli/login?port=${port}`;
+  console.log(chalk.blue("Velo CLI Login"));
+  console.log(chalk.gray("Opening browser for authentication...\n"));
+  const credentialsPromise = new Promise((resolve, reject) => {
+    const server = createServer((req, res) => {
+      if (!req.url?.startsWith("/callback")) {
+        res.writeHead(404);
+        res.end("Not found");
+        return;
+      }
+      try {
+        const url = new URL(req.url, `http://localhost:${port}`);
+        const token = url.searchParams.get("token");
+        const email = url.searchParams.get("email");
+        const expiresAt = url.searchParams.get("expires_at");
+        if (!token || !email || !expiresAt) {
+          throw new Error("Missing required parameters");
+        }
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(`
+          <!DOCTYPE html>
+          <html>
+          <head>
+            <title>Velo CLI - Login Success</title>
+            <style>
+              body {
+                font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+                display: flex;
+                justify-content: center;
+                align-items: center;
+                height: 100vh;
+                margin: 0;
+                background: #0d1117;
+                color: #c9d1d9;
+              }
+              .container {
+                text-align: center;
+                padding: 40px;
+              }
+              .success {
+                color: #3fb950;
+                font-size: 48px;
+                margin-bottom: 16px;
+              }
+              h1 { margin-bottom: 8px; }
+              p { color: #8b949e; }
+            </style>
+          </head>
+          <body>
+            <div class="container">
+              <div class="success">&#10003;</div>
+              <h1>Login Successful!</h1>
+              <p>You can close this window and return to your terminal.</p>
+            </div>
+          </body>
+          </html>
+        `);
+        server.close();
+        resolve({ token, email, expires_at: expiresAt });
+      } catch (error) {
+        res.writeHead(400, { "Content-Type": "text/html" });
+        res.end(`
+          <!DOCTYPE html>
+          <html>
+          <head><title>Login Failed</title></head>
+          <body style="font-family: sans-serif; padding: 40px; text-align: center;">
+            <h1 style="color: #f85149;">Login Failed</h1>
+            <p>Something went wrong. Please try again.</p>
+          </body>
+          </html>
+        `);
+        server.close();
+        reject(new Error("Login failed: Invalid callback"));
+      }
+    });
+    server.on("error", (error) => {
+      if (error.code === "EADDRINUSE") {
+        reject(new Error(`Port ${port} is already in use. Make sure no other velo login is running.`));
+      } else {
+        reject(error);
+      }
+    });
+    server.listen(port, "127.0.0.1", () => {
+      open(loginUrl);
+    });
+    setTimeout(() => {
+      server.close();
+      reject(new Error("Login timed out. Please try again."));
+    }, 12e4);
+  });
+  const spinner = ora("Waiting for browser authentication...").start();
+  try {
+    const credentials = await credentialsPromise;
+    spinner.stop();
+    const verification = await verifyToken(credentials.token);
+    if (!verification.valid) {
+      console.log(chalk.red("Token verification failed. Please try again."));
+      return;
+    }
+    saveCredentials(credentials);
+    console.log(chalk.green(`
+\u2713 Logged in as ${chalk.bold(credentials.email)}`));
+    console.log(chalk.gray(`  Token expires: ${new Date(credentials.expires_at).toLocaleDateString()}`));
+    console.log(chalk.gray(`  Credentials saved to ~/.config/velo/credentials.json`));
+    console.log(chalk.gray(`
+Run ${chalk.cyan("velo status")} to see CI metrics.`));
+  } catch (error) {
+    spinner.stop();
+    console.log(chalk.red(`
+${error.message}`));
+    process.exit(1);
+  }
+}
+
+// src/commands/logout.ts
+import chalk2 from "chalk";
+async function logout() {
+  const existing = loadCredentials();
+  if (!existing) {
+    console.log(chalk2.yellow("Not logged in."));
+    return;
+  }
+  clearCredentials();
+  console.log(chalk2.green(`Logged out from ${existing.email}`));
+}
+
+// src/commands/status.ts
+import chalk3 from "chalk";
+async function status(options) {
+  const credentials = loadCredentials();
+  if (!credentials) {
+    console.log(chalk3.red("Not logged in."));
+    console.log(chalk3.gray(`Run ${chalk3.cyan("velo login")} to authenticate.`));
+    process.exit(1);
+  }
+  console.log(chalk3.blue("Velo CI Status"));
+  console.log(chalk3.gray(`Logged in as ${credentials.email}
+`));
+  const days = options.days || 7;
+  try {
+    let endpoint = `/api/metrics?period=${days}d`;
+    if (options.repo) {
+      endpoint += `&repo=${encodeURIComponent(options.repo)}`;
+    }
+    const metrics = await apiRequest(endpoint);
+    console.log(chalk3.white.bold("Last " + days + " days:"));
+    console.log(`  Total runs: ${chalk3.cyan(metrics.data.total_runs.toLocaleString())}`);
+    console.log(`  Success rate: ${formatRate(metrics.data.success_rate)}`);
+    console.log(`  Avg duration: ${chalk3.gray(metrics.data.avg_duration_minutes.toFixed(1) + " min")}`);
+    console.log();
+    const repos = Object.entries(metrics.data.by_repo).sort((a, b) => b[1].total - a[1].total).slice(0, 5);
+    if (repos.length > 0) {
+      console.log(chalk3.white.bold("Top repos:"));
+      for (const [repo, data] of repos) {
+        const shortName = repo.split("/")[1] || repo;
+        const rateStr = formatRate(data.success_rate);
+        console.log(`  ${chalk3.cyan(shortName.padEnd(20))} ${data.total.toString().padStart(5)} runs  ${rateStr}`);
+      }
+      console.log();
+    }
+    const failuresEndpoint = `/api/classifications?limit=5&classification=SOFT${options.repo ? `&repo=${encodeURIComponent(options.repo)}` : ""}`;
+    try {
+      const failures = await apiRequest(failuresEndpoint);
+      if (failures.classifications?.length > 0) {
+        console.log(chalk3.white.bold("Recent SOFT failures (code issues):"));
+        for (const f of failures.classifications) {
+          const shortRepo = f.repo.split("/")[1] || f.repo;
+          const time = new Date(f.created_at).toLocaleDateString();
+          console.log(`  ${chalk3.yellow(shortRepo.padEnd(20))} ${f.branch?.substring(0, 25).padEnd(25)} ${chalk3.gray(time)}`);
+          if (f.explanation) {
+            console.log(chalk3.gray(`    ${f.explanation.substring(0, 80)}...`));
+          }
+        }
+        console.log();
+      }
+    } catch {
+    }
+  } catch (error) {
+    if (error instanceof APIError) {
+      console.log(chalk3.red(`API Error: ${error.message}`));
+      if (error.statusCode === 401) {
+        console.log(chalk3.gray(`Your session may have expired. Run ${chalk3.cyan("velo login")} again.`));
+      }
+    } else {
+      console.log(chalk3.red(`Error: ${error.message}`));
+    }
+    process.exit(1);
+  }
+}
+function formatRate(rate) {
+  if (rate >= 90) return chalk3.green(`${rate.toFixed(1)}%`);
+  if (rate >= 75) return chalk3.yellow(`${rate.toFixed(1)}%`);
+  return chalk3.red(`${rate.toFixed(1)}%`);
+}
+
+// src/commands/api.ts
+import chalk4 from "chalk";
+async function api(endpoint, options) {
+  const credentials = loadCredentials();
+  if (!credentials) {
+    console.log(chalk4.red("Not logged in."));
+    console.log(chalk4.gray(`Run ${chalk4.cyan("velo login")} to authenticate.`));
+    process.exit(1);
+  }
+  if (!endpoint.startsWith("/")) {
+    endpoint = "/" + endpoint;
+  }
+  const url = `${API_BASE_URL}${endpoint}`;
+  const method = options.method?.toUpperCase() || "GET";
+  const headers = {
+    "Authorization": `Bearer ${credentials.token}`,
+    "Content-Type": "application/json"
+  };
+  const fetchOptions = {
+    method,
+    headers
+  };
+  if (options.data && (method === "POST" || method === "PATCH" || method === "PUT")) {
+    fetchOptions.body = options.data;
+  }
+  try {
+    const response = await fetch(url, fetchOptions);
+    const contentType = response.headers.get("content-type") || "";
+    if (options.raw) {
+      if (contentType.includes("application/json")) {
+        const data = await response.json();
+        console.log(JSON.stringify(data, null, 2));
+      } else {
+        console.log(await response.text());
+      }
+    } else {
+      const statusColor = response.ok ? chalk4.green : chalk4.red;
+      console.log(`${statusColor(response.status)} ${chalk4.gray(response.statusText)} ${chalk4.cyan(url)}`);
+      console.log();
+      if (contentType.includes("application/json")) {
+        const data = await response.json();
+        console.log(JSON.stringify(data, null, 2));
+      } else {
+        console.log(await response.text());
+      }
+    }
+    if (!response.ok) {
+      process.exit(1);
+    }
+  } catch (error) {
+    console.log(chalk4.red(`Error: ${error.message}`));
+    process.exit(1);
+  }
+}
+
+// src/index.ts
+var program = new Command();
+program.name("velo").description("CLI for Velo CI/CD metrics").version("0.1.0");
+program.command("login").description("Authenticate via Ghost SSO").action(login);
+program.command("logout").description("Clear saved credentials").action(logout);
+program.command("status").description("Show CI health overview").option("-r, --repo <repo>", "Filter by repository (e.g., TryGhost/Ghost)").option("-d, --days <days>", "Number of days to analyze (default: 7)", "7").action((options) => {
+  status({
+    repo: options.repo,
+    days: parseInt(options.days, 10)
+  });
+});
+program.command("api <endpoint>").description("Make raw API calls").option("-m, --method <method>", "HTTP method (GET, POST, etc.)", "GET").option("-d, --data <json>", "Request body (JSON string)").option("--raw", "Output response only (no status line)").action((endpoint, options) => {
+  api(endpoint, {
+    method: options.method,
+    data: options.data,
+    raw: options.raw
+  });
+});
+program.addHelpText("after", `
+Examples:
+  $ velo login                          # Authenticate via browser SSO
+  $ velo status                         # Quick CI health check
+  $ velo status --repo TryGhost/Ghost   # Status for specific repo
+  $ velo api /api/health                # Check API health
+  $ velo api /api/dora?period=30d       # Get DORA metrics
+  $ velo api /api/classifications?limit=10  # Recent CI failures
+`);
+program.parse();

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@tryghost/velo-cli",
+  "version": "0.1.0",
+  "description": "CLI for Velo CI/CD metrics",
+  "type": "module",
+  "bin": {
+    "velo": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts",
+    "dev": "tsup src/index.ts --format esm --watch",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "chalk": "^5.3.0",
+    "open": "^10.1.0",
+    "ora": "^8.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.3"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "ci",
+    "cd",
+    "metrics",
+    "ghost",
+    "velo"
+  ],
+  "author": "Ghost Foundation",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TryGhost/Velo.git",
+    "directory": "packages/cli"
+  }
+}