@emit-vision/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,391 @@
+#!/usr/bin/env node
+
+// src/commands/login.ts
+import { createInterface } from "readline";
+import { exec } from "child_process";
+
+// src/config.ts
+import { homedir } from "os";
+import { join } from "path";
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+var DEFAULT_API_URL = "https://api.emitvision.com";
+var CONFIG_DIR = join(homedir(), ".emit-vision");
+var CONFIG_PATH = join(CONFIG_DIR, "config.json");
+function loadConfig() {
+  if (!existsSync(CONFIG_PATH)) return {};
+  try {
+    return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveConfig(patch) {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  const current = loadConfig();
+  writeFileSync(
+    CONFIG_PATH,
+    JSON.stringify({ ...current, ...patch }, null, 2),
+    "utf-8"
+  );
+}
+function clearConfig() {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_PATH, "{}", "utf-8");
+}
+
+// src/api.ts
+var ApiError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "ApiError";
+  }
+  status;
+};
+async function apiFetch(path, options = {}) {
+  const config = loadConfig();
+  const apiUrl = options.apiUrl ?? config.apiUrl ?? DEFAULT_API_URL;
+  const pat = options.pat ?? config.pat;
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (pat) headers["Authorization"] = `Bearer ${pat}`;
+  let res;
+  try {
+    res = await fetch(`${apiUrl}${path}`, {
+      method: options.method ?? "GET",
+      headers,
+      body: options.body !== void 0 ? JSON.stringify(options.body) : void 0
+    });
+  } catch (err) {
+    throw new Error(
+      `Network error: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  if (res.status === 401) {
+    throw new ApiError(401, "Run `emit-vision login` first.");
+  }
+  if (!res.ok) {
+    let msg = `HTTP ${res.status}`;
+    try {
+      const body = await res.json();
+      if (body.error) msg = body.error;
+    } catch {
+    }
+    throw new ApiError(res.status, msg);
+  }
+  if (res.status === 204) return void 0;
+  return res.json();
+}
+
+// src/commands/login.ts
+async function runLogin(args) {
+  let apiUrl;
+  const apiUrlIdx = args.indexOf("--api-url");
+  if (apiUrlIdx !== -1 && args[apiUrlIdx + 1]) {
+    apiUrl = args[apiUrlIdx + 1];
+  }
+  if (args.includes("--browser")) {
+    await runBrowserLogin(apiUrl);
+    return;
+  }
+  await runPasteLogin(apiUrl);
+}
+async function runPasteLogin(apiUrl) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const pat = await new Promise((resolve) => {
+    rl.question("Paste your Personal Access Token: ", (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+  if (!pat) {
+    console.error("No token provided.");
+    process.exit(1);
+  }
+  try {
+    await apiFetch("/v1/management/projects", { pat, apiUrl });
+    const patch = { pat };
+    if (apiUrl) patch.apiUrl = apiUrl;
+    saveConfig(patch);
+    console.log("Logged in successfully.");
+  } catch (err) {
+    console.error(
+      `Login failed: ${err instanceof Error ? err.message : String(err)}`
+    );
+    process.exit(1);
+  }
+}
+async function runBrowserLogin(apiUrl) {
+  const config = loadConfig();
+  if (config.pat) {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    const answer = await new Promise((resolve) => {
+      rl.question("Already logged in. Overwrite? [y/N] ", (a) => {
+        rl.close();
+        resolve(a.trim().toLowerCase());
+      });
+    });
+    if (answer !== "y" && answer !== "yes") {
+      console.log("Aborted.");
+      return;
+    }
+  }
+  let initResult;
+  try {
+    initResult = await apiFetch(
+      "/v1/cli-auth/init",
+      { method: "POST", apiUrl }
+    );
+  } catch (err) {
+    console.error(
+      `Failed to start browser login: ${err instanceof Error ? err.message : String(err)}`
+    );
+    process.exit(1);
+  }
+  const { code, authUrl } = initResult;
+  console.log(
+    `Open this URL in your browser to authorize the CLI:
+  ${authUrl}`
+  );
+  openBrowser(authUrl);
+  const controller = new AbortController();
+  const { signal } = controller;
+  process.on("SIGINT", () => {
+    controller.abort();
+    console.log("\nLogin cancelled.");
+    process.exit(1);
+  });
+  const POLL_INTERVAL_MS = 2e3;
+  const POLL_TIMEOUT_MS = 5 * 60 * 1e3;
+  const deadline = Date.now() + POLL_TIMEOUT_MS;
+  console.log("Waiting for browser authorization\u2026");
+  while (Date.now() < deadline) {
+    if (signal.aborted) break;
+    await sleep(POLL_INTERVAL_MS);
+    if (signal.aborted) break;
+    let pollResult;
+    try {
+      pollResult = await apiFetch(
+        `/v1/cli-auth/poll/${encodeURIComponent(code)}`,
+        { apiUrl }
+      );
+    } catch {
+      continue;
+    }
+    if (pollResult.status === "authorized") {
+      if (!pollResult.rawToken) {
+        console.error("Authorization succeeded but no token was returned.");
+        process.exit(1);
+      }
+      const patch = {
+        pat: pollResult.rawToken
+      };
+      if (apiUrl) patch.apiUrl = apiUrl;
+      saveConfig(patch);
+      console.log("Logged in successfully.");
+      return;
+    }
+    if (pollResult.status === "expired") {
+      console.error("Login timed out. Try again.");
+      process.exit(1);
+    }
+  }
+  console.error("Login timed out. Try again.");
+  process.exit(1);
+}
+function openBrowser(url) {
+  const platform = process.platform;
+  const cmd2 = platform === "darwin" ? `open "${url}"` : platform === "win32" ? `start "" "${url}"` : `xdg-open "${url}"`;
+  exec(cmd2, (err) => {
+    if (err) {
+    }
+  });
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/commands/logout.ts
+function runLogout() {
+  clearConfig();
+  console.log("Logged out.");
+}
+
+// src/commands/project.ts
+async function runProjectList() {
+  const projects = await apiFetch("/v1/management/projects");
+  if (projects.length === 0) {
+    console.log(
+      "No projects found. Create one with: emit-vision project create <name>"
+    );
+    return;
+  }
+  const rows = projects.map((p) => [
+    p.name,
+    p.id,
+    p.environment ?? "\u2014",
+    p.createdAt ? new Date(p.createdAt).toLocaleDateString() : "\u2014"
+  ]);
+  printTable(["Name", "ID", "Environment", "Created"], rows);
+}
+async function runProjectCreate(args) {
+  const name = args[0];
+  if (!name) {
+    console.error("Usage: emit-vision project create <name>");
+    process.exit(1);
+  }
+  const result = await apiFetch("/v1/management/projects", { method: "POST", body: { name } });
+  console.log(`Project created: ${result.name} (${result.id})`);
+  if (result.rawIngestKey) {
+    console.log(
+      "\nWarning: Copy this ingest key now \u2014 it will not be shown again."
+    );
+    console.log(`  ${result.rawIngestKey}`);
+  }
+}
+async function runProjectEnvCreate(args) {
+  const [projectId, envName, ...rest2] = args;
+  const typeIdx = rest2.indexOf("--type");
+  const envType = typeIdx !== -1 ? rest2[typeIdx + 1] : void 0;
+  if (!projectId || !envName) {
+    console.error(
+      "Usage: emit-vision project env create <projectId> <envName> [--type development|staging|custom]"
+    );
+    process.exit(1);
+  }
+  const result = await apiFetch(`/v1/management/projects/${encodeURIComponent(projectId)}/environments`, {
+    method: "POST",
+    body: { name: envName, ...envType ? { type: envType } : {} }
+  });
+  console.log(`Environment created: ${result.name} (${result.id})`);
+  if (result.rawIngestKey) {
+    console.log(
+      "\nWarning: Copy this ingest key now \u2014 it will not be shown again."
+    );
+    console.log(`  ${result.rawIngestKey}`);
+  }
+}
+function printTable(headers, rows) {
+  const widths = headers.map(
+    (h, i) => Math.max(h.length, ...rows.map((r) => (r[i] ?? "").length))
+  );
+  const line = (cells) => cells.map((c, i) => c.padEnd(widths[i])).join("  ");
+  console.log(line(headers));
+  console.log(widths.map((w) => "-".repeat(w)).join("  "));
+  rows.forEach((r) => console.log(line(r)));
+}
+
+// src/commands/key.ts
+import { createInterface as createInterface2 } from "readline";
+async function runKeyGet(args) {
+  const projectId = args[0];
+  if (!projectId) {
+    console.error("Usage: emit-vision key get <projectId>");
+    process.exit(1);
+  }
+  const key = await apiFetch(
+    `/v1/management/projects/${encodeURIComponent(projectId)}/keys`
+  );
+  console.log(`Prefix:    ${key.keyPrefix}`);
+  console.log(`Scope:     ${key.scope}`);
+  console.log(
+    `Last used: ${key.lastUsedAt ? new Date(key.lastUsedAt).toLocaleDateString() : "Never"}`
+  );
+}
+async function runKeyRotate(args) {
+  const projectId = args[0];
+  if (!projectId) {
+    console.error("Usage: emit-vision key rotate <projectId>");
+    process.exit(1);
+  }
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
+  const answer = await new Promise((resolve) => {
+    rl.question(
+      "Rotate the ingest key? This will invalidate the current key. [y/N] ",
+      (a) => {
+        rl.close();
+        resolve(a.trim().toLowerCase());
+      }
+    );
+  });
+  if (answer !== "y" && answer !== "yes") {
+    console.log("Aborted.");
+    return;
+  }
+  const result = await apiFetch(
+    `/v1/management/projects/${encodeURIComponent(projectId)}/keys/rotate`,
+    { method: "POST" }
+  );
+  console.log(
+    "\nWarning: Copy this new ingest key now \u2014 it will not be shown again."
+  );
+  console.log(`  ${result.rawIngestKey}`);
+}
+
+// src/index.ts
+var [cmd, subcmd, ...rest] = process.argv.slice(2);
+async function main() {
+  try {
+    if (cmd === "login") {
+      await runLogin(subcmd ? [subcmd, ...rest] : rest);
+    } else if (cmd === "logout") {
+      runLogout();
+    } else if (cmd === "project") {
+      if (subcmd === "list") {
+        await runProjectList();
+      } else if (subcmd === "create") {
+        await runProjectCreate(rest);
+      } else if (subcmd === "env" && rest[0] === "create") {
+        await runProjectEnvCreate(rest.slice(1));
+      } else {
+        printHelp();
+        process.exit(1);
+      }
+    } else if (cmd === "key") {
+      if (subcmd === "get") {
+        await runKeyGet(rest);
+      } else if (subcmd === "rotate") {
+        await runKeyRotate(rest);
+      } else {
+        printHelp();
+        process.exit(1);
+      }
+    } else {
+      printHelp();
+      if (cmd !== void 0) process.exit(1);
+    }
+  } catch (err) {
+    if (err instanceof ApiError) {
+      if (err.status === 401) {
+        console.error("Not authenticated. Run `emit-vision login` first.");
+      } else if (err.status === 402) {
+        console.error(err.message);
+      } else {
+        console.error(`Error: ${err.message}`);
+      }
+    } else {
+      console.error(
+        `Error: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    process.exit(1);
+  }
+}
+function printHelp() {
+  console.log(`emit-vision CLI
+
+Commands:
+  login [--api-url <url>]                              Authenticate with a Personal Access Token
+  logout                                                Clear stored credentials
+  project list                                          List your projects
+  project create <name>                                 Create a new project
+  project env create <projectId> <name> [--type ...]   Create a new environment
+  key get <projectId>                                   Get ingest key info for a project
+  key rotate <projectId>                                Rotate the ingest key for a project
+`);
+}
+main();

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@emit-vision/cli",
+  "version": "0.1.0",
+  "description": "CLI for emit-vision project management",
+  "private": false,
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "emit-vision": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup --config tsup.config.ts",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  }
+}