npm - @superflag-sh/cli - Versions diffs - 0.1.0 - Mend

@superflag-sh/cli 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/dist/index.js +1369 -0
package/package.json +33 -0

package/dist/index.js ADDED Viewed

@@ -0,0 +1,1369 @@
+#!/usr/bin/env bun
+// @bun
+// src/commands/login.ts
+import { randomBytes } from "crypto";
+// src/lib/server.ts
+function startCallbackServer(expectedState) {
+  return new Promise((resolve) => {
+    let callbackResolve;
+    const callbackPromise = new Promise((res) => {
+      callbackResolve = res;
+    });
+    let server;
+    server = Bun.serve({
+      port: 0,
+      fetch(req) {
+        const url = new URL(req.url);
+        if (url.pathname === "/callback") {
+          const token = url.searchParams.get("token");
+          const error = url.searchParams.get("error");
+          const state = url.searchParams.get("state");
+          if (state !== expectedState) {
+            return new Response(html("Error", "Invalid state parameter. Please try again."), { headers: { "Content-Type": "text/html" } });
+          }
+          if (error) {
+            callbackResolve({ error, state: state || "" });
+            setTimeout(() => server.stop(), 100);
+            return new Response(html("Authorization Cancelled", "You can close this window and return to your terminal."), { headers: { "Content-Type": "text/html" } });
+          }
+          if (token) {
+            callbackResolve({ token, state });
+            setTimeout(() => server.stop(), 100);
+            return new Response(html("Success!", "You're now logged in. You can close this window and return to your terminal."), { headers: { "Content-Type": "text/html" } });
+          }
+          return new Response(html("Error", "Missing token. Please try again."), { headers: { "Content-Type": "text/html" } });
+        }
+        return new Response("Not Found", { status: 404 });
+      }
+    });
+    resolve({
+      port: server.port,
+      waitForCallback: () => callbackPromise
+    });
+  });
+}
+function html(title, message) {
+  return `<!DOCTYPE html>
+<html>
+<head>
+  <title>${title} - Superflag CLI</title>
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      min-height: 100vh;
+      margin: 0;
+      background: #0a0a0a;
+      color: #fafafa;
+    }
+    .container {
+      text-align: center;
+      padding: 2rem;
+    }
+    h1 { margin-bottom: 1rem; }
+    p { color: #a1a1aa; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>${title}</h1>
+    <p>${message}</p>
+  </div>
+</body>
+</html>`;
+}
+// src/lib/config.ts
+import { homedir } from "os";
+import { join } from "path";
+import { mkdir, readFile, writeFile, unlink } from "fs/promises";
+import { existsSync } from "fs";
+var CONFIG_DIR = join(homedir(), ".superflag");
+var CREDENTIALS_FILE = join(CONFIG_DIR, "credentials.json");
+async function ensureConfigDir() {
+  if (!existsSync(CONFIG_DIR)) {
+    await mkdir(CONFIG_DIR, { recursive: true });
+  }
+}
+async function saveCredentials(credentials) {
+  await ensureConfigDir();
+  await writeFile(CREDENTIALS_FILE, JSON.stringify(credentials, null, 2));
+}
+async function loadCredentials() {
+  try {
+    const content = await readFile(CREDENTIALS_FILE, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function clearCredentials() {
+  try {
+    await unlink(CREDENTIALS_FILE);
+  } catch {}
+}
+function getConfigDir() {
+  return CONFIG_DIR;
+}
+// src/lib/auth.ts
+async function getToken() {
+  const credentials = await loadCredentials();
+  return credentials?.token ?? null;
+}
+async function setToken(token, email) {
+  await saveCredentials({ token, email });
+}
+async function removeToken() {
+  await clearCredentials();
+}
+async function isAuthenticated() {
+  const token = await getToken();
+  return token !== null;
+}
+// src/lib/api.ts
+var API_BASE = process.env.SUPERFLAG_API_URL || "http://localhost:3000/api/v1";
+class ApiError extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "ApiError";
+  }
+}
+async function api(endpoint, options = {}) {
+  const token = await getToken();
+  if (!token) {
+    throw new ApiError("Not authenticated. Run 'superflag login' first.", 401);
+  }
+  const { method = "GET", body, params } = options;
+  let url = `${API_BASE}${endpoint}`;
+  if (params) {
+    const searchParams = new URLSearchParams(params);
+    url += `?${searchParams.toString()}`;
+  }
+  const response = await fetch(url, {
+    method,
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    },
+    body: body ? JSON.stringify(body) : undefined
+  });
+  const data = await response.json();
+  if (!response.ok) {
+    throw new ApiError(data.error || "API request failed", response.status);
+  }
+  return data;
+}
+var apiClient = {
+  async whoami() {
+    return api("/cli-token");
+  },
+  async listApps() {
+    return api("/apps");
+  },
+  async createApp(name) {
+    return api("/apps", { method: "POST", body: { name } });
+  },
+  async listFlags(appId, env) {
+    const result = await api("/flags", { params: { appId, env } });
+    const flags = {};
+    for (const flag of result.flags) {
+      const { key, ...rest } = flag;
+      flags[key] = rest;
+    }
+    return { flags };
+  },
+  async updateFlag(appId, env, key, updates) {
+    return api("/flags", {
+      method: "PATCH",
+      body: { appId, env, key, ...updates }
+    });
+  },
+  async deleteFlag(appId, env, key) {
+    return api("/flags", {
+      method: "DELETE",
+      params: { appId, env, key }
+    });
+  },
+  async listKeys(appId, envId) {
+    return api("/keys", { params: { appId, envId } });
+  },
+  async createKey(appId, envId, type) {
+    return api("/keys", {
+      method: "POST",
+      body: { appId, envId, type }
+    });
+  },
+  async revokeKey(keyId) {
+    return api("/keys", {
+      method: "PATCH",
+      body: { id: keyId, revoke: true }
+    });
+  }
+};
+// src/utils/output.ts
+var colors = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  cyan: "\x1B[36m"
+};
+function bold(text) {
+  return `${colors.bold}${text}${colors.reset}`;
+}
+function dim(text) {
+  return `${colors.dim}${text}${colors.reset}`;
+}
+function red(text) {
+  return `${colors.red}${text}${colors.reset}`;
+}
+function green(text) {
+  return `${colors.green}${text}${colors.reset}`;
+}
+function yellow(text) {
+  return `${colors.yellow}${text}${colors.reset}`;
+}
+function blue(text) {
+  return `${colors.blue}${text}${colors.reset}`;
+}
+function error(message) {
+  console.error(`${red("error:")} ${message}`);
+}
+function success(message) {
+  console.log(`${green("success:")} ${message}`);
+}
+function info(message) {
+  console.log(`${blue("info:")} ${message}`);
+}
+function table(headers, rows) {
+  const widths = headers.map((h, i) => {
+    const maxRow = Math.max(...rows.map((r) => (r[i] || "").length));
+    return Math.max(h.length, maxRow);
+  });
+  const headerLine = headers.map((h, i) => h.padEnd(widths[i])).join("  ");
+  console.log(bold(headerLine));
+  console.log(dim("-".repeat(headerLine.length)));
+  for (const row of rows) {
+    console.log(row.map((cell, i) => (cell || "").padEnd(widths[i])).join("  "));
+  }
+}
+// src/commands/login.ts
+var AUTH_URL = process.env.SUPERFLAG_AUTH_URL || "http://localhost:3000/cli-auth";
+async function login() {
+  if (await isAuthenticated()) {
+    try {
+      const { user } = await apiClient.whoami();
+      info(`Already logged in as ${user.email}`);
+      console.log(`Run ${yellow("superflag logout")} to log out first.`);
+      return;
+    } catch {}
+  }
+  const state = randomBytes(16).toString("hex");
+  console.log("Starting authentication...");
+  const { port, waitForCallback } = await startCallbackServer(state);
+  const authUrl = `${AUTH_URL}?port=${port}&state=${state}`;
+  console.log(`Opening browser to authenticate...`);
+  console.log(`If browser doesn't open, visit: ${authUrl}`);
+  const { platform } = process;
+  try {
+    if (platform === "darwin") {
+      Bun.spawn(["open", authUrl]);
+    } else if (platform === "win32") {
+      Bun.spawn(["cmd", "/c", "start", authUrl]);
+    } else {
+      Bun.spawn(["xdg-open", authUrl]);
+    }
+  } catch {}
+  console.log(`
+Waiting for authentication...`);
+  const result = await waitForCallback();
+  if (result.error) {
+    error(`Authentication failed: ${result.error}`);
+    process.exit(1);
+  }
+  if (!result.token) {
+    error("No token received");
+    process.exit(1);
+  }
+  await setToken(result.token);
+  try {
+    const { user } = await apiClient.whoami();
+    await setToken(result.token, user.email);
+    success(`Logged in as ${user.email}`);
+  } catch {
+    success("Logged in successfully");
+  }
+}
+// src/commands/logout.ts
+async function logout() {
+  if (!await isAuthenticated()) {
+    info("Not logged in");
+    return;
+  }
+  await removeToken();
+  success("Logged out");
+}
+// src/commands/whoami.ts
+async function whoami() {
+  if (!await isAuthenticated()) {
+    info("Not logged in");
+    return;
+  }
+  try {
+    const { user } = await apiClient.whoami();
+    console.log(`Logged in as ${bold(user.email)}`);
+    console.log(`User ID: ${user.id}`);
+  } catch (e) {
+    if (e instanceof ApiError) {
+      error(e.message);
+    } else {
+      error("Failed to get user info");
+    }
+    process.exit(1);
+  }
+}
+// src/commands/apps.ts
+async function listApps() {
+  try {
+    const { apps } = await apiClient.listApps();
+    if (apps.length === 0) {
+      info("No apps found");
+      console.log(`Run ${yellow("superflag apps create <name>")} to create one.`);
+      return;
+    }
+    console.log(bold(`
+Apps (${apps.length})
+`));
+    table(["NAME", "ID", "ENVIRONMENTS"], apps.map((app) => [
+      app.name,
+      dim(app.id),
+      app.envs?.map((e) => e.slug).join(", ") || ""
+    ]));
+    console.log("");
+  } catch (e) {
+    if (e instanceof ApiError) {
+      error(e.message);
+    } else {
+      error("Failed to list apps");
+    }
+    process.exit(1);
+  }
+}
+async function createApp(name) {
+  if (!name) {
+    error("App name is required");
+    console.log(`Usage: ${yellow("superflag apps create <name>")}`);
+    process.exit(1);
+  }
+  try {
+    const result = await apiClient.createApp(name);
+    success(`Created app "${result.app.name}"`);
+    console.log("");
+    console.log(bold("Environments:"));
+    for (const env of result.envs) {
+      console.log(`  - ${env.slug}`);
+    }
+    console.log("");
+    console.log(bold("API Keys:"));
+    console.log(dim("Save these keys - they won't be shown again!"));
+    console.log("");
+    for (const key of result.keys) {
+      const envLabel = key.env ? ` (${key.env})` : "";
+      console.log(`  ${key.type.toUpperCase()}${envLabel}:`);
+      console.log(`  ${yellow(key.token)}`);
+      console.log("");
+    }
+  } catch (e) {
+    if (e instanceof ApiError) {
+      error(e.message);
+    } else {
+      error("Failed to create app");
+    }
+    process.exit(1);
+  }
+}
+// src/commands/envs.ts
+async function findApp(nameOrId) {
+  const { apps } = await apiClient.listApps();
+  return apps.find((a) => a.name === nameOrId || a.id === nameOrId) || null;
+}
+async function listEnvs(appName) {
+  if (!appName) {
+    error("App name is required");
+    console.log(`Usage: ${yellow("superflag envs list --app <name>")}`);
+    process.exit(1);
+  }
+  try {
+    const app = await findApp(appName);
+    if (!app) {
+      error(`App "${appName}" not found`);
+      process.exit(1);
+    }
+    if (!app.envs || app.envs.length === 0) {
+      info(`No environments found for "${app.name}"`);
+      return;
+    }
+    console.log(bold(`
+Environments for "${app.name}" (${app.envs.length})
+`));
+    table(["SLUG", "ID", "CREATED"], app.envs.map((env) => [
+      env.slug,
+      dim(env.id),
+      new Date(env.created_at).toLocaleDateString()
+    ]));
+    console.log("");
+  } catch (e) {
+    if (e instanceof ApiError) {
+      error(e.message);
+    } else {
+      error("Failed to list environments");
+    }
+    process.exit(1);
+  }
+}
+// src/lib/context.ts
+import { join as join2 } from "path";
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+var CONTEXT_FILE = join2(getConfigDir(), "context.json");
+var cachedContext = null;
+async function loadContext() {
+  if (cachedContext)
+    return cachedContext;
+  try {
+    const content = await readFile2(CONTEXT_FILE, "utf-8");
+    cachedContext = JSON.parse(content);
+    return cachedContext;
+  } catch {
+    return {};
+  }
+}
+async function saveContext(context) {
+  await ensureConfigDir();
+  await writeFile2(CONTEXT_FILE, JSON.stringify(context, null, 2));
+  cachedContext = context;
+}
+async function getAppAndEnv(flagApp, flagEnv) {
+  const context = await loadContext();
+  return {
+    app: flagApp || context.app,
+    env: flagEnv || context.env
+  };
+}
+// src/commands/flags.ts
+async function findApp2(nameOrId) {
+  const { apps } = await apiClient.listApps();
+  return apps.find((a) => a.name === nameOrId || a.id === nameOrId) || null;
+}
+function formatValue(flag) {
+  if (flag.type === "bool") {
+    return flag.value ? green("true") : red("false");
+  }
+  if (flag.type === "json") {
+    return dim(JSON.stringify(flag.value));
+  }
+  return String(flag.value);
+}
+async function listFlags(appName, envSlug) {
+  if (!appName || !envSlug) {
+    error("App and environment are required");
+    console.log(`Usage: ${yellow("superflag flags list --app <name> --env <slug>")}`);
+    process.exit(1);
+  }
+  try {
+    const app = await findApp2(appName);
+    if (!app) {
+      error(`App "${appName}" not found`);
+      process.exit(1);
+    }
+    const { flags } = await apiClient.listFlags(app.id, envSlug);
+    const flagEntries = Object.entries(flags);
+    if (flagEntries.length === 0) {
+      info(`No flags found in "${app.name}" (${envSlug})`);
+      console.log(`Run ${yellow("superflag flags create --app <name> --env <slug> --key <key> --type <type> --value <value>")} to create one.`);
+      return;
+    }
+    console.log(bold(`
+Flags in "${app.name}" (${envSlug}) - ${flagEntries.length} total
+`));
+    table(["KEY", "TYPE", "VALUE", "CLIENT"], flagEntries.map(([key, flag]) => [
+      key,
+      flag.type,
+      formatValue(flag),
+      flag.clientEnabled ? green("yes") : dim("no")
+    ]));
+    console.log("");
+  } catch (e) {
+    if (e instanceof ApiError) {
+      error(e.message);
+    } else {
+      error("Failed to list flags");
+    }
+    process.exit(1);
+  }
+}
+async function createFlag(appName, envSlug, key, type, valueStr, clientEnabled) {
+  if (!appName || !envSlug || !key || !type || valueStr === undefined) {
+    error("Missing required arguments");
+    console.log(`Usage: ${yellow("superflag flags create --app <name> --env <slug> --key <key> --type <bool|string|number|json> --value <value> [--client]")}`);
+    process.exit(1);
+  }
+  let value;
+  switch (type) {
+    case "bool":
+      value = valueStr === "true" || valueStr === "1";
+      break;
+    case "number":
+      value = Number(valueStr);
+      if (isNaN(value)) {
+        error("Invalid number value");
+        process.exit(1);
+      }
+      break;
+    case "json":
+      try {
+        value = JSON.parse(valueStr);
+      } catch {
+        error("Invalid JSON value");
+        process.exit(1);
+      }
+      break;
+    default:
+      value = valueStr;
+  }
+  try {
+    const app = await findApp2(appName);
+    if (!app) {
+      error(`App "${appName}" not found`);
+      process.exit(1);
+    }
+    await apiClient.updateFlag(app.id, envSlug, key, {
+      type,
+      value,
+      clientEnabled
+    });
+    success(`Created flag "${key}" in "${app.name}" (${envSlug})`);
+  } catch (e) {
+    if (e instanceof ApiError) {
+      error(e.message);
+    } else {
+      error("Failed to create flag");
+    }
+    process.exit(1);
+  }
+}
+async function setFlag(appName, envSlug, key, valueStr) {
+  if (!appName || !envSlug || !key || valueStr === undefined) {
+    error("Missing required arguments");
+    console.log(`Usage: ${yellow("superflag flags set --app <name> --env <slug> --key <key> --value <value>")}`);
+    process.exit(1);
+  }
+  try {
+    const app = await findApp2(appName);
+    if (!app) {
+      error(`App "${appName}" not found`);
+      process.exit(1);
+    }
+    const { flags } = await apiClient.listFlags(app.id, envSlug);
+    const currentFlag = flags[key];
+    if (!currentFlag) {
+      error(`Flag "${key}" not found`);
+      process.exit(1);
+    }
+    let value;
+    switch (currentFlag.type) {
+      case "bool":
+        value = valueStr === "true" || valueStr === "1";
+        break;
+      case "number":
+        value = Number(valueStr);
+        if (isNaN(value)) {
+          error("Invalid number value");
+          process.exit(1);
+        }
+        break;
+      case "json":
+        try {
+          value = JSON.parse(valueStr);
+        } catch {
+          error("Invalid JSON value");
+          process.exit(1);
+        }
+        break;
+      default:
+        value = valueStr;
+    }
+    await apiClient.updateFlag(app.id, envSlug, key, { value });
+    success(`Updated flag "${key}" to ${formatValue({ ...currentFlag, value })}`);
+  } catch (e) {
+    if (e instanceof ApiError) {
+      error(e.message);
+    } else {
+      error("Failed to update flag");
+    }
+    process.exit(1);
+  }
+}
+async function toggleFlag(appName, envSlug, key) {
+  if (!appName || !envSlug || !key) {
+    error("Missing required arguments");
+    console.log(`Usage: ${yellow("superflag flags toggle --app <name> --env <slug> --key <key>")}`);
+    process.exit(1);
+  }
+  try {
+    const app = await findApp2(appName);
+    if (!app) {
+      error(`App "${appName}" not found`);
+      process.exit(1);
+    }
+    const { flags } = await apiClient.listFlags(app.id, envSlug);
+    const currentFlag = flags[key];
+    if (!currentFlag) {
+      error(`Flag "${key}" not found`);
+      process.exit(1);
+    }
+    if (currentFlag.type !== "bool") {
+      error(`Flag "${key}" is not a boolean flag`);
+      process.exit(1);
+    }
+    const newValue = !currentFlag.value;
+    await apiClient.updateFlag(app.id, envSlug, key, { value: newValue });
+    success(`Toggled "${key}" to ${newValue ? green("true") : red("false")}`);
+  } catch (e) {
+    if (e instanceof ApiError) {
+      error(e.message);
+    } else {
+      error("Failed to toggle flag");
+    }
+    process.exit(1);
+  }
+}
+async function deleteFlag(appName, envSlug, key) {
+  if (!appName || !envSlug || !key) {
+    error("Missing required arguments");
+    console.log(`Usage: ${yellow("superflag flags delete --app <name> --env <slug> --key <key>")}`);
+    process.exit(1);
+  }
+  try {
+    const app = await findApp2(appName);
+    if (!app) {
+      error(`App "${appName}" not found`);
+      process.exit(1);
+    }
+    await apiClient.deleteFlag(app.id, envSlug, key);
+    success(`Deleted flag "${key}" from "${app.name}" (${envSlug})`);
+  } catch (e) {
+    if (e instanceof ApiError) {
+      error(e.message);
+    } else {
+      error("Failed to delete flag");
+    }
+    process.exit(1);
+  }
+}
+async function upsertFlag(options) {
+  const { app: appName, env: envSlug } = await getAppAndEnv(options.app, options.env);
+  if (!appName || !envSlug) {
+    error("No context set. Run 'superflag use <app> <env>' or provide --app and --env");
+    process.exit(2);
+  }
+  if (!options.key || !options.type || options.value === undefined) {
+    error("Missing required arguments: --key, --type, --value");
+    process.exit(1);
+  }
+  let value;
+  switch (options.type) {
+    case "bool":
+      value = options.value === "true" || options.value === "1";
+      break;
+    case "number":
+      value = Number(options.value);
+      if (isNaN(value)) {
+        error("Invalid number value");
+        process.exit(1);
+      }
+      break;
+    case "json":
+      try {
+        value = JSON.parse(options.value);
+      } catch {
+        error("Invalid JSON value");
+        process.exit(1);
+      }
+      break;
+    default:
+      value = options.value;
+  }
+  try {
+    const app = await findApp2(appName);
+    if (!app) {
+      error(`App "${appName}" not found`);
+      process.exit(3);
+    }
+    await apiClient.updateFlag(app.id, envSlug, options.key, {
+      type: options.type,
+      value,
+      clientEnabled: options.client || false
+    });
+    if (!options.quiet) {
+      console.log("✓");
+    }
+  } catch (e) {
+    if (e instanceof ApiError) {
+      error(e.message);
+      process.exit(e.status === 401 ? 2 : 1);
+    }
+    error("Failed to upsert flag");
+    process.exit(1);
+  }
+}
+async function bulkSet(options) {
+  const { app: appName, env: envSlug } = await getAppAndEnv(options.app, options.env);
+  if (!appName || !envSlug) {
+    error("No context set. Run 'superflag use <app> <env>' or provide --app and --env");
+    process.exit(2);
+  }
+  try {
+    let input;
+    if (options.file) {
+      input = await Bun.file(options.file).text();
+    } else {
+      const chunks = [];
+      const reader = Bun.stdin.stream().getReader();
+      const decoder = new TextDecoder;
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        chunks.push(decoder.decode(value));
+      }
+      input = chunks.join("");
+    }
+    if (!input.trim()) {
+      error("No input provided");
+      process.exit(1);
+    }
+    const data = JSON.parse(input);
+    const app = await findApp2(appName);
+    if (!app) {
+      error(`App "${appName}" not found`);
+      process.exit(3);
+    }
+    const { flags: currentFlags } = await apiClient.listFlags(app.id, envSlug);
+    let updated = 0;
+    for (const [key, value] of Object.entries(data)) {
+      const currentFlag = currentFlags[key];
+      if (!currentFlag) {
+        error(`Flag "${key}" not found. Use 'superflag flags upsert' to create it first.`);
+        continue;
+      }
+      await apiClient.updateFlag(app.id, envSlug, key, { value });
+      updated++;
+    }
+    if (!options.quiet) {
+      console.log(`✓ Updated ${updated} flags`);
+    }
+  } catch (e) {
+    if (e instanceof SyntaxError) {
+      error("Invalid JSON input");
+      process.exit(1);
+    }
+    if (e instanceof ApiError) {
+      error(e.message);
+      process.exit(e.status === 401 ? 2 : 1);
+    }
+    error("Failed to bulk set flags");
+    process.exit(1);
+  }
+}
+// src/commands/keys.ts
+async function findApp3(nameOrId) {
+  const { apps } = await apiClient.listApps();
+  return apps.find((a) => a.name === nameOrId || a.id === nameOrId) || null;
+}
+async function listKeys(appName, envSlug) {
+  if (!appName || !envSlug) {
+    error("App and environment are required");
+    console.log(`Usage: ${yellow("superflag keys list --app <name> --env <slug>")}`);
+    process.exit(1);
+  }
+  try {
+    const app = await findApp3(appName);
+    if (!app) {
+      error(`App "${appName}" not found`);
+      process.exit(1);
+    }
+    const env = app.envs?.find((e) => e.slug === envSlug);
+    if (!env) {
+      error(`Environment "${envSlug}" not found`);
+      process.exit(1);
+    }
+    const { keys } = await apiClient.listKeys(app.id, env.id);
+    if (keys.length === 0) {
+      info(`No keys found for "${app.name}" (${envSlug})`);
+      return;
+    }
+    console.log(bold(`
+Keys for "${app.name}" (${envSlug}) - ${keys.length} total
+`));
+    table(["TYPE", "NAME", "ID", "STATUS"], keys.map((key) => [
+      key.type.toUpperCase(),
+      key.name,
+      dim(key.id),
+      key.revoked_at ? red("revoked") : "active"
+    ]));
+    console.log("");
+  } catch (e) {
+    if (e instanceof ApiError) {
+      error(e.message);
+    } else {
+      error("Failed to list keys");
+    }
+    process.exit(1);
+  }
+}
+async function createKey(appName, envSlug, type) {
+  if (!appName || !envSlug || !type) {
+    error("Missing required arguments");
+    console.log(`Usage: ${yellow("superflag keys create --app <name> --env <slug> --type <sdk|pub>")}`);
+    process.exit(1);
+  }
+  if (type !== "sdk" && type !== "pub") {
+    error("Type must be 'sdk' or 'pub'");
+    process.exit(1);
+  }
+  try {
+    const app = await findApp3(appName);
+    if (!app) {
+      error(`App "${appName}" not found`);
+      process.exit(1);
+    }
+    const env = app.envs?.find((e) => e.slug === envSlug);
+    if (!env) {
+      error(`Environment "${envSlug}" not found`);
+      process.exit(1);
+    }
+    const { key, token } = await apiClient.createKey(app.id, env.id, type);
+    success(`Created ${type.toUpperCase()} key for "${app.name}" (${envSlug})`);
+    console.log("");
+    console.log(dim("Save this key - it won't be shown again!"));
+    console.log("");
+    console.log(`  ${yellow(token)}`);
+    console.log("");
+  } catch (e) {
+    if (e instanceof ApiError) {
+      error(e.message);
+    } else {
+      error("Failed to create key");
+    }
+    process.exit(1);
+  }
+}
+async function revokeKey(keyId) {
+  if (!keyId) {
+    error("Key ID is required");
+    console.log(`Usage: ${yellow("superflag keys revoke <key-id>")}`);
+    process.exit(1);
+  }
+  try {
+    await apiClient.revokeKey(keyId);
+    success(`Revoked key ${keyId}`);
+  } catch (e) {
+    if (e instanceof ApiError) {
+      error(e.message);
+    } else {
+      error("Failed to revoke key");
+    }
+    process.exit(1);
+  }
+}
+// src/commands/use.ts
+async function use(appName, envSlug) {
+  if (!appName) {
+    const context = await loadContext();
+    if (context.app && context.env) {
+      info(`Current context: ${context.app} (${context.env})`);
+    } else {
+      info("No context set");
+      console.log(dim("Usage: superflag use <app> <env>"));
+    }
+    return;
+  }
+  if (!envSlug) {
+    error("Environment is required");
+    console.log(dim("Usage: superflag use <app> <env>"));
+    process.exit(1);
+  }
+  try {
+    const { apps } = await apiClient.listApps();
+    const app = apps.find((a) => a.name === appName || a.id === appName);
+    if (!app) {
+      error(`App "${appName}" not found`);
+      process.exit(3);
+    }
+    const env = app.envs?.find((e) => e.slug === envSlug);
+    if (!env) {
+      error(`Environment "${envSlug}" not found in "${app.name}"`);
+      process.exit(3);
+    }
+    await saveContext({ app: app.name, env: env.slug });
+    success(`Context set to ${app.name} (${env.slug})`);
+  } catch (e) {
+    error(e instanceof Error ? e.message : "Failed to set context");
+    process.exit(1);
+  }
+}
+// src/commands/get.ts
+async function findApp4(nameOrId) {
+  const { apps } = await apiClient.listApps();
+  return apps.find((a) => a.name === nameOrId || a.id === nameOrId) || null;
+}
+async function get(key, options) {
+  const { app: appName, env: envSlug } = await getAppAndEnv(options.app, options.env);
+  if (!appName || !envSlug) {
+    error("No context set. Run 'superflag use <app> <env>' first.");
+    process.exit(2);
+  }
+  if (!key) {
+    error("Flag key is required");
+    process.exit(1);
+  }
+  try {
+    const app = await findApp4(appName);
+    if (!app) {
+      error(`App "${appName}" not found`);
+      process.exit(3);
+    }
+    const { flags } = await apiClient.listFlags(app.id, envSlug);
+    const flag = flags[key];
+    if (!flag) {
+      error(`Flag "${key}" not found`);
+      process.exit(3);
+    }
+    if (options.json) {
+      console.log(JSON.stringify({ key, ...flag }));
+    } else {
+      if (flag.type === "json") {
+        console.log(JSON.stringify(flag.value));
+      } else {
+        console.log(flag.value);
+      }
+    }
+  } catch (e) {
+    if (e instanceof ApiError) {
+      error(e.message);
+      process.exit(e.status === 401 ? 2 : 1);
+    }
+    error("Failed to get flag");
+    process.exit(1);
+  }
+}
+// src/commands/set.ts
+async function findApp5(nameOrId) {
+  const { apps } = await apiClient.listApps();
+  return apps.find((a) => a.name === nameOrId || a.id === nameOrId) || null;
+}
+async function set(key, valueStr, options) {
+  const { app: appName, env: envSlug } = await getAppAndEnv(options.app, options.env);
+  if (!appName || !envSlug) {
+    error("No context set. Run 'superflag use <app> <env>' first.");
+    process.exit(2);
+  }
+  if (!key || valueStr === undefined) {
+    error("Flag key and value are required");
+    process.exit(1);
+  }
+  try {
+    const app = await findApp5(appName);
+    if (!app) {
+      error(`App "${appName}" not found`);
+      process.exit(3);
+    }
+    const { flags } = await apiClient.listFlags(app.id, envSlug);
+    const currentFlag = flags[key];
+    if (!currentFlag) {
+      error(`Flag "${key}" not found. Use 'superflag flags upsert' to create it.`);
+      process.exit(3);
+    }
+    let value;
+    switch (currentFlag.type) {
+      case "bool":
+        value = valueStr === "true" || valueStr === "1";
+        break;
+      case "number":
+        value = Number(valueStr);
+        if (isNaN(value)) {
+          error("Invalid number value");
+          process.exit(1);
+        }
+        break;
+      case "json":
+        try {
+          value = JSON.parse(valueStr);
+        } catch {
+          error("Invalid JSON value");
+          process.exit(1);
+        }
+        break;
+      default:
+        value = valueStr;
+    }
+    await apiClient.updateFlag(app.id, envSlug, key, { value });
+    if (!options.quiet) {
+      console.log("✓");
+    }
+  } catch (e) {
+    if (e instanceof ApiError) {
+      error(e.message);
+      process.exit(e.status === 401 ? 2 : 1);
+    }
+    error("Failed to set flag");
+    process.exit(1);
+  }
+}
+// src/commands/config.ts
+async function findApp6(nameOrId) {
+  const { apps } = await apiClient.listApps();
+  return apps.find((a) => a.name === nameOrId || a.id === nameOrId) || null;
+}
+async function config(options) {
+  const { app: appName, env: envSlug } = await getAppAndEnv(options.app, options.env);
+  if (!appName || !envSlug) {
+    error("No context set. Run 'superflag use <app> <env>' first.");
+    process.exit(2);
+  }
+  try {
+    const app = await findApp6(appName);
+    if (!app) {
+      error(`App "${appName}" not found`);
+      process.exit(3);
+    }
+    const { flags } = await apiClient.listFlags(app.id, envSlug);
+    console.log(JSON.stringify({ app: app.name, env: envSlug, flags }, null, 2));
+  } catch (e) {
+    if (e instanceof ApiError) {
+      error(e.message);
+      process.exit(e.status === 401 ? 2 : 1);
+    }
+    error("Failed to get config");
+    process.exit(1);
+  }
+}
+// src/commands/status.ts
+async function status(options) {
+  const authenticated = await isAuthenticated();
+  const context = await loadContext();
+  let email = null;
+  let apiConnected = false;
+  if (authenticated) {
+    try {
+      const { user } = await apiClient.whoami();
+      email = user.email;
+      apiConnected = true;
+    } catch {}
+  }
+  if (options.json) {
+    console.log(JSON.stringify({
+      authenticated,
+      email,
+      apiConnected,
+      context: context.app && context.env ? { app: context.app, env: context.env } : null
+    }));
+    return;
+  }
+  if (authenticated && email) {
+    console.log(`${green("✓")} Authenticated as ${email}`);
+  } else if (authenticated) {
+    console.log(`${red("✗")} Token invalid or expired`);
+  } else {
+    console.log(`${red("✗")} Not authenticated`);
+  }
+  if (context.app && context.env) {
+    console.log(`${green("✓")} Context: ${context.app} (${context.env})`);
+  } else {
+    console.log(`${dim("○")} No context set`);
+  }
+  if (apiConnected) {
+    console.log(`${green("✓")} API: connected`);
+  } else if (authenticated) {
+    console.log(`${red("✗")} API: connection failed`);
+  }
+}
+// src/utils/output.ts
+var colors2 = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  cyan: "\x1B[36m"
+};
+function bold2(text) {
+  return `${colors2.bold}${text}${colors2.reset}`;
+}
+function dim2(text) {
+  return `${colors2.dim}${text}${colors2.reset}`;
+}
+function red2(text) {
+  return `${colors2.red}${text}${colors2.reset}`;
+}
+function yellow2(text) {
+  return `${colors2.yellow}${text}${colors2.reset}`;
+}
+function error2(message) {
+  console.error(`${red2("error:")} ${message}`);
+}
+// src/index.ts
+var VERSION = "0.1.0";
+function parseArgs(args) {
+  const command = [];
+  const flags = {};
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      const nextArg = args[i + 1];
+      if (nextArg && !nextArg.startsWith("-")) {
+        flags[key] = nextArg;
+        i++;
+      } else {
+        flags[key] = true;
+      }
+    } else if (arg.startsWith("-")) {
+      const key = arg.slice(1);
+      flags[key] = true;
+    } else {
+      command.push(arg);
+    }
+  }
+  return { command, flags };
+}
+function showHelp() {
+  console.log(`
+${bold2("Superflag CLI")} ${dim2(`v${VERSION}`)}
+${bold2("USAGE")}
+  superflag <command> [options]
+${bold2("QUICK COMMANDS")} ${dim2("(agent-friendly)")}
+  ${yellow2("use")} <app> <env>                    Set default app/env context
+  ${yellow2("get")} <key>                          Get a flag value
+  ${yellow2("set")} <key> <value>                  Set a flag value
+  ${yellow2("config")}                             Dump full config as JSON
+  ${yellow2("status")}                             Show auth and context status
+${bold2("AUTH COMMANDS")}
+  ${yellow2("login")}                              Authenticate with Superflag
+  ${yellow2("logout")}                             Log out of Superflag
+  ${yellow2("whoami")}                             Show current user
+${bold2("APP COMMANDS")}
+  ${yellow2("apps list")}                          List all apps
+  ${yellow2("apps create")} <name>                 Create a new app
+${bold2("ENV COMMANDS")}
+  ${yellow2("envs list")} --app <name>             List environments for an app
+${bold2("FLAG COMMANDS")}
+  ${yellow2("flags list")} --app <n> --env <e>     List flags in an environment
+  ${yellow2("flags create")} --app <n> --env <e> --key <k> --type <t> --value <v> [--client]
+  ${yellow2("flags set")} --app <n> --env <e> --key <k> --value <v>
+  ${yellow2("flags toggle")} --app <n> --env <e> --key <k>
+  ${yellow2("flags delete")} --app <n> --env <e> --key <k>
+  ${yellow2("flags upsert")} --key <k> --type <t> --value <v> [--client]
+                                       ${dim2("(uses context, idempotent)")}
+  ${yellow2("flags bulk-set")} [--file <path>]     Set multiple flags from JSON
+${bold2("KEY COMMANDS")}
+  ${yellow2("keys list")} --app <n> --env <e>      List keys for an environment
+  ${yellow2("keys create")} --app <n> --env <e> --type <sdk|pub>
+  ${yellow2("keys revoke")} <key-id>               Revoke a key
+${bold2("GLOBAL OPTIONS")}
+  --json                               Output as JSON
+  --quiet, -q                          Suppress non-essential output
+  --app, --env                         Override context for single command
+  --help, -h                           Show this help message
+  --version, -v                        Show version
+${bold2("AGENT WORKFLOW")}
+  ${dim2("superflag use myapp prod")}
+  ${dim2("superflag get dark-mode")}              ${dim2("\u2192 true")}
+  ${dim2("superflag set dark-mode false")}
+  ${dim2("superflag flags upsert --key new-flag --type bool --value true")}
+`);
+}
+async function main() {
+  const args = process.argv.slice(2);
+  const { command, flags } = parseArgs(args);
+  if (flags.help || flags.h || command.length === 0) {
+    showHelp();
+    return;
+  }
+  if (flags.version || flags.v) {
+    console.log(`superflag v${VERSION}`);
+    return;
+  }
+  const [cmd, subCmd, ...rest] = command;
+  try {
+    switch (cmd) {
+      case "use":
+        await use(subCmd, rest[0]);
+        break;
+      case "get":
+        await get(subCmd, {
+          app: flags.app,
+          env: flags.env,
+          json: Boolean(flags.json)
+        });
+        break;
+      case "set":
+        await set(subCmd, rest[0], {
+          app: flags.app,
+          env: flags.env,
+          quiet: Boolean(flags.quiet || flags.q)
+        });
+        break;
+      case "config":
+        await config({
+          app: flags.app,
+          env: flags.env
+        });
+        break;
+      case "status":
+        await status({ json: Boolean(flags.json) });
+        break;
+      case "login":
+        await login();
+        break;
+      case "logout":
+        await logout();
+        break;
+      case "whoami":
+        await whoami();
+        break;
+      case "apps":
+        switch (subCmd) {
+          case "list":
+            await listApps();
+            break;
+          case "create":
+            await createApp(rest[0] || flags.name);
+            break;
+          default:
+            error2(`Unknown apps command: ${subCmd}`);
+            console.log(`Run ${yellow2("superflag apps --help")} for usage.`);
+            process.exit(1);
+        }
+        break;
+      case "envs":
+        switch (subCmd) {
+          case "list":
+            await listEnvs(flags.app);
+            break;
+          default:
+            error2(`Unknown envs command: ${subCmd}`);
+            process.exit(1);
+        }
+        break;
+      case "flags":
+        switch (subCmd) {
+          case "list":
+            await listFlags(flags.app, flags.env);
+            break;
+          case "create":
+            await createFlag(flags.app, flags.env, flags.key, flags.type, flags.value, Boolean(flags.client));
+            break;
+          case "set":
+            await setFlag(flags.app, flags.env, flags.key, flags.value);
+            break;
+          case "toggle":
+            await toggleFlag(flags.app, flags.env, flags.key);
+            break;
+          case "delete":
+            await deleteFlag(flags.app, flags.env, flags.key);
+            break;
+          case "upsert":
+            await upsertFlag({
+              app: flags.app,
+              env: flags.env,
+              key: flags.key,
+              type: flags.type,
+              value: flags.value,
+              client: Boolean(flags.client),
+              quiet: Boolean(flags.quiet || flags.q)
+            });
+            break;
+          case "bulk-set":
+            await bulkSet({
+              app: flags.app,
+              env: flags.env,
+              file: flags.file,
+              quiet: Boolean(flags.quiet || flags.q)
+            });
+            break;
+          default:
+            error2(`Unknown flags command: ${subCmd}`);
+            process.exit(1);
+        }
+        break;
+      case "keys":
+        switch (subCmd) {
+          case "list":
+            await listKeys(flags.app, flags.env);
+            break;
+          case "create":
+            await createKey(flags.app, flags.env, flags.type);
+            break;
+          case "revoke":
+            await revokeKey(rest[0] || flags.id);
+            break;
+          default:
+            error2(`Unknown keys command: ${subCmd}`);
+            process.exit(1);
+        }
+        break;
+      default:
+        error2(`Unknown command: ${cmd}`);
+        console.log(`Run ${yellow2("superflag --help")} for usage.`);
+        process.exit(1);
+    }
+  } catch (e) {
+    if (e instanceof Error) {
+      error2(e.message);
+    } else {
+      error2("An unexpected error occurred");
+    }
+    process.exit(1);
+  }
+}
+main();

package/package.json ADDED Viewed

@@ -0,0 +1,33 @@
+{
+  "name": "@superflag-sh/cli",
+  "version": "0.1.0",
+  "description": "CLI for Superflag feature flags",
+  "type": "module",
+  "bin": {
+    "superflag": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/superflag-sh/cli"
+  },
+  "keywords": [
+    "feature-flags",
+    "cli",
+    "superflag"
+  ],
+  "author": "Superflag",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/bun": "^1.3.5",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.0.0"
+  },
+  "scripts": {
+    "build": "rm -rf dist && bun build ./src/index.ts --outdir dist --target node --format esm && chmod +x dist/index.js",
+    "dev": "bun run src/index.ts",
+    "typecheck": "tsc --noEmit"
+  }
+}