@letterapp/cli 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,56 +1,540 @@
 #!/usr/bin/env node
-import { COMMANDS, DEFAULT_COMMAND, findCommand } from "./commands/registry.js";
-import { banner, color, error, log } from "./lib/ui.js";
-const VERSION = "0.1.0";
-function printHelp() {
-    banner();
-    log(`${color.bold("Usage")}  letter <command> [options]`);
-    log();
-    log(color.bold("Commands"));
-    for (const c of COMMANDS) {
-        const names = [c.name, ...(c.aliases ?? [])].join(", ");
-        log(`  ${names.padEnd(18)} ${color.dim(c.summary)}`);
-    }
-    log(`  ${"help".padEnd(18)} ${color.dim("Show this help")}`);
-    log();
-    log(color.bold("Login options"));
-    log(`  ${"--no-open".padEnd(18)} ${color.dim("Don't auto-open the browser; print the URL")}`);
-    log(`  ${"--yes, -y".padEnd(18)} ${color.dim("Non-interactive (for agents/CI prompts)")}`);
-    log(`  ${"--no-install".padEnd(18)} ${color.dim("Skip installing @letterapp/node")}`);
-    log(`  ${"--base-url <url>".padEnd(18)} ${color.dim("Target a self-hosted / local Letter")}`);
-    log(`  ${"--api-key <key>".padEnd(18)} ${color.dim("CI only: write a key without the device flow")}`);
-    log();
-    log(color.dim("Docs: https://letter.app/docs/agent-setup"));
-    log();
-}
-async function main() {
-    const argv = process.argv.slice(2);
-    const first = argv[0];
-    if (first === "--version" || first === "-v") {
-        log(VERSION);
-        return 0;
-    }
-    if (first === "help" || first === "--help" || first === "-h") {
-        printHelp();
-        return 0;
-    }
-    // No command, or a flag-first invocation (e.g. `letter --no-open`): run the
-    // default command with all args.
-    if (!first || first.startsWith("-")) {
-        const cmd = findCommand(DEFAULT_COMMAND);
-        return cmd.run(argv);
-    }
-    const cmd = findCommand(first);
-    if (!cmd) {
-        error(`Unknown command: ${first}`);
-        log(`Run ${color.cyan("letter help")} to see available commands.`);
-        return 1;
-    }
-    return cmd.run(argv.slice(1));
-}
-main()
-    .then((code) => process.exit(code))
-    .catch((err) => {
-    error(err instanceof Error ? err.message : String(err));
-    process.exit(1);
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/output.ts
+import chalk from "chalk";
+import ora from "ora";
+import { createInterface } from "readline";
+var jsonMode = false;
+function setJsonMode(enabled) {
+  jsonMode = enabled;
+}
+function isJsonMode() {
+  return jsonMode;
+}
+function printJson(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+function log(msg = "") {
+  if (jsonMode) return;
+  console.log(msg);
+}
+function printSuccess(msg) {
+  if (jsonMode) return;
+  console.log(chalk.green("\u2713") + " " + msg);
+}
+function printInfo(msg) {
+  if (jsonMode) return;
+  console.log(chalk.cyan("\u203A") + " " + msg);
+}
+function printWarning(msg) {
+  if (jsonMode) return;
+  console.log(chalk.yellow("!") + " " + msg);
+}
+function printError(err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  if (jsonMode) {
+    printJson({ error: msg });
+    return;
+  }
+  console.error(chalk.red("\u2717") + " " + msg);
+}
+function banner() {
+  if (jsonMode) return;
+  console.log("");
+  console.log("  " + chalk.bold("Letter") + chalk.red(".") + " " + chalk.dim("CLI"));
+  console.log("");
+}
+function spinner(text) {
+  return ora({ text, color: "cyan", isEnabled: !jsonMode });
+}
+function prompt(question) {
+  if (!process.stdin.isTTY) return Promise.resolve("");
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+var c = chalk;
+
+// src/config.ts
+import Conf from "conf";
+import { homedir } from "os";
+import path from "path";
+import { mkdir, readFile, writeFile, rm } from "fs/promises";
+var DEFAULT_BASE_URL = "https://api.letter.app";
+var config = new Conf({
+  projectName: "letterapp-cli",
+  schema: {
+    baseUrl: { type: "string", default: DEFAULT_BASE_URL }
+  }
+});
+function getBaseUrl(flag) {
+  const raw = flag || process.env.LETTER_BASE_URL || config.get("baseUrl") || DEFAULT_BASE_URL;
+  return raw.replace(/\/$/, "");
+}
+function setBaseUrl(url) {
+  config.set("baseUrl", url.replace(/\/$/, ""));
+}
+function getConfigPath() {
+  return config.path;
+}
+function resetConfig() {
+  config.clear();
+}
+function credentialsPath() {
+  return path.join(homedir(), ".letter", "credentials.json");
+}
+async function saveCredential(cred) {
+  const file = credentialsPath();
+  await mkdir(path.dirname(file), { recursive: true, mode: 448 });
+  await writeFile(file, `${JSON.stringify(cred, null, 2)}
+`, { mode: 384 });
+  return file;
+}
+async function readCredential() {
+  try {
+    const raw = await readFile(credentialsPath(), "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function clearCredential() {
+  await rm(credentialsPath(), { force: true });
+}
+
+// src/client.ts
+var USER_AGENT = "@letterapp/cli";
+async function startDeviceAuth(base) {
+  const res = await fetch(`${base}/v1/cli/auth/start`, {
+    method: "POST",
+    headers: { "content-type": "application/json", "user-agent": USER_AGENT },
+    body: "{}"
+  });
+  if (!res.ok) {
+    throw new Error(
+      `Could not start login (HTTP ${res.status}). Is ${base} reachable?`
+    );
+  }
+  return await res.json();
+}
+async function pollDeviceAuth(base, deviceCode) {
+  const res = await fetch(`${base}/v1/cli/auth/poll`, {
+    method: "POST",
+    headers: { "content-type": "application/json", "user-agent": USER_AGENT },
+    body: JSON.stringify({ device_code: deviceCode })
+  });
+  if (res.status === 429) {
+    const retryAfter = Number(res.headers.get("retry-after") ?? "5");
+    return { status: "slow_down", retryAfter };
+  }
+  if (!res.ok) {
+    throw new Error(`Login poll failed (HTTP ${res.status}).`);
+  }
+  return await res.json();
+}
+var LetterClient = class {
+  maxRetries = 3;
+  async resolveAuth() {
+    const cred = await readCredential();
+    const token = process.env.LETTER_API_KEY || cred?.apiKey || "";
+    if (!token) {
+      throw new Error(
+        "Not connected. Run `letter login` (or set LETTER_API_KEY) first."
+      );
+    }
+    const base = getBaseUrl(process.env.LETTER_API_KEY ? void 0 : cred?.baseUrl);
+    return { base, token };
+  }
+  async request(method, path3, attempt = 1) {
+    const { base, token } = await this.resolveAuth();
+    const res = await fetch(`${base}${path3}`, {
+      method,
+      headers: {
+        authorization: `Bearer ${token}`,
+        accept: "application/json",
+        "user-agent": USER_AGENT
+      }
+    });
+    if (res.status === 429 && attempt <= this.maxRetries) {
+      const retryAfter = Number(res.headers.get("retry-after") || 2);
+      await new Promise((r) => setTimeout(r, retryAfter * 1e3 * attempt));
+      return this.request(method, path3, attempt + 1);
+    }
+    const data = res.status === 204 ? {} : await res.json();
+    if (!res.ok) {
+      const msg = data?.error?.message || `HTTP ${res.status}`;
+      const err = new Error(msg);
+      err.status = res.status;
+      throw err;
+    }
+    return { status: res.status, data };
+  }
+  get(path3) {
+    return this.request("GET", path3);
+  }
+};
+var client = new LetterClient();
+
+// src/browser.ts
+import { spawn } from "child_process";
+function openUrl(url) {
+  const platform = process.platform;
+  let command;
+  let args;
+  if (platform === "darwin") {
+    command = "open";
+    args = [url];
+  } else if (platform === "win32") {
+    command = "cmd";
+    args = ["/c", "start", "", url];
+  } else {
+    command = "xdg-open";
+    args = [url];
+  }
+  try {
+    const child = spawn(command, args, { stdio: "ignore", detached: true });
+    child.on("error", () => {
+    });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/env-file.ts
+import path2 from "path";
+import { readFile as readFile2, writeFile as writeFile2, stat } from "fs/promises";
+async function upsertEnv(cwd, file, entries) {
+  const filePath = path2.join(cwd, file);
+  let contents = "";
+  try {
+    contents = await readFile2(filePath, "utf8");
+  } catch {
+    contents = "";
+  }
+  let next = contents;
+  for (const [key, value] of Object.entries(entries)) {
+    const line = `${key}=${value}`;
+    const re = new RegExp(`^${escapeRegExp(key)}=.*$`, "m");
+    if (re.test(next)) {
+      next = next.replace(re, line);
+    } else {
+      if (next.length && !next.endsWith("\n")) next += "\n";
+      next += `${line}
+`;
+    }
+  }
+  await writeFile2(filePath, next, "utf8");
+  return filePath;
+}
+async function fileExists(cwd, name) {
+  try {
+    await stat(path2.join(cwd, name));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/pm.ts
+import { spawn as spawn2 } from "child_process";
+import { readFile as readFile3 } from "fs/promises";
+async function detectPackageManager(cwd) {
+  if (await fileExists(cwd, "pnpm-lock.yaml")) return "pnpm";
+  if (await fileExists(cwd, "yarn.lock")) return "yarn";
+  if (await fileExists(cwd, "bun.lockb")) return "bun";
+  if (await fileExists(cwd, "package-lock.json")) return "npm";
+  const ua = process.env.npm_config_user_agent ?? "";
+  if (ua.startsWith("pnpm")) return "pnpm";
+  if (ua.startsWith("yarn")) return "yarn";
+  if (ua.startsWith("bun")) return "bun";
+  return "npm";
+}
+async function detectFramework(cwd) {
+  try {
+    const pkg = JSON.parse(await readFile3(`${cwd}/package.json`, "utf8"));
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    if (deps.next) return "Next.js";
+    if (deps.nuxt) return "Nuxt";
+    if (deps["@remix-run/node"] || deps["@remix-run/react"]) return "Remix";
+    if (deps.express) return "Express";
+    if (deps.fastify) return "Fastify";
+    if (deps.hono) return "Hono";
+    if (deps["@sveltejs/kit"]) return "SvelteKit";
+    return null;
+  } catch {
+    return null;
+  }
+}
+function installCommand(pm, pkg) {
+  switch (pm) {
+    case "pnpm":
+      return `pnpm add ${pkg}`;
+    case "yarn":
+      return `yarn add ${pkg}`;
+    case "bun":
+      return `bun add ${pkg}`;
+    default:
+      return `npm install ${pkg}`;
+  }
+}
+function runInstall(pm, pkg, cwd) {
+  const args = pm === "npm" ? ["install", pkg] : ["add", pkg];
+  return new Promise((resolve) => {
+    const child = spawn2(pm, args, {
+      cwd,
+      stdio: "inherit",
+      shell: process.platform === "win32"
+    });
+    child.on("error", () => resolve(1));
+    child.on("close", (code) => resolve(code ?? 1));
+  });
+}
+
+// src/commands/login.ts
+var SDK_PACKAGE = "@letterapp/node";
+var ENV_FILE = ".env.local";
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function registerLoginCommand(program2) {
+  program2.command("login", { isDefault: true }).alias("init").description("Connect this project to Letter (interactive device login)").option("--no-open", "Don't open the browser; print the URL to open manually").option("-y, --yes", "Non-interactive: don't wait for Enter (agents/CI)").option("--no-install", "Skip installing the SDK").option("--base-url <url>", "Target a self-hosted or local Letter instance").option(
+    "--api-key <key>",
+    "CI only: write a key without the device flow (never use in chat)"
+  ).action(async (opts) => {
+    const code = await runLogin(opts);
+    if (code !== 0) process.exitCode = code;
+  });
+}
+async function runLogin(opts) {
+  const base = getBaseUrl(opts.baseUrl);
+  const cwd = process.cwd();
+  const interactive = process.stdin.isTTY && !opts.yes;
+  banner();
+  if (opts.apiKey) {
+    const entries = { LETTER_API_KEY: opts.apiKey };
+    if (base !== DEFAULT_BASE_URL) entries.LETTER_BASE_URL = base;
+    const file = await upsertEnv(cwd, ENV_FILE, entries);
+    printSuccess(`Saved LETTER_API_KEY to ${rel(cwd, file)} (--api-key).`);
+    printWarning("--api-key is for CI. For interactive setup, run `letter login`.");
+    return 0;
+  }
+  let flow;
+  try {
+    flow = await startDeviceAuth(base);
+  } catch (err) {
+    printError(err);
+    return 1;
+  }
+  log(c.bold("Confirm this code in your browser:"));
+  log();
+  log("    " + c.cyan(c.bold(flow.user_code)));
+  log();
+  if (interactive && opts.open) {
+    await prompt(c.dim("Press Enter to open your browser\u2026 "));
+  }
+  if (opts.open) openUrl(flow.verification_uri_complete);
+  printInfo("If your browser didn't open, visit:");
+  log("    " + c.blue(flow.verification_uri_complete));
+  log();
+  printInfo("Waiting for you to approve\u2026 (Ctrl+C to cancel)");
+  const deadline = Date.now() + flow.expires_in * 1e3;
+  let intervalMs = Math.max(1, flow.interval) * 1e3;
+  while (Date.now() < deadline) {
+    await sleep(intervalMs);
+    let res;
+    try {
+      res = await pollDeviceAuth(base, flow.device_code);
+    } catch (err) {
+      printError(err);
+      return 1;
+    }
+    if (res.status === "authorization_pending") continue;
+    if (res.status === "slow_down") {
+      intervalMs += 1e3;
+      continue;
+    }
+    if (res.status === "access_denied") {
+      printError(new Error("Request denied in the browser. Nothing was changed."));
+      return 1;
+    }
+    if (res.status === "expired_token") {
+      printError(new Error("This login expired. Run the command again to retry."));
+      return 1;
+    }
+    return finish(res.api_key, res.base_url, res.project, cwd, opts.install);
+  }
+  printError(new Error("Timed out waiting for approval. Run the command again."));
+  return 1;
+}
+async function finish(apiKey, baseUrl, project, cwd, doInstall) {
+  log();
+  printSuccess(`Approved for project ${c.bold(project.name)}.`);
+  const entries = { LETTER_API_KEY: apiKey };
+  if (baseUrl && baseUrl !== DEFAULT_BASE_URL) entries.LETTER_BASE_URL = baseUrl;
+  const envFile = await upsertEnv(cwd, ENV_FILE, entries);
+  printSuccess(`Saved LETTER_API_KEY to ${rel(cwd, envFile)}.`);
+  try {
+    const credFile = await saveCredential({
+      apiKey,
+      baseUrl: baseUrl || DEFAULT_BASE_URL,
+      project,
+      savedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    printSuccess(`Stored credentials in ${tildify(credFile)} for tooling (MCP).`);
+  } catch {
+    printWarning("Could not write ~/.letter/credentials.json (continuing).");
+  }
+  const pm = await detectPackageManager(cwd);
+  if (doInstall) {
+    printInfo(`Installing ${SDK_PACKAGE} with ${pm}\u2026`);
+    const code = await runInstall(pm, SDK_PACKAGE, cwd);
+    if (code === 0) printSuccess(`Installed ${SDK_PACKAGE}.`);
+    else printWarning(`Install failed. Run: ${installCommand(pm, SDK_PACKAGE)}`);
+  } else {
+    printInfo(`Skipped install. Run: ${installCommand(pm, SDK_PACKAGE)}`);
+  }
+  printNextSteps(await detectFramework(cwd));
+  return 0;
+}
+function printNextSteps(framework) {
+  log();
+  log(c.bold("Next steps"));
+  if (framework) log(c.dim(`Detected ${framework}.`));
+  log(`  1. Create a server-side client that reads ${c.cyan("process.env.LETTER_API_KEY")}.`);
+  log(`  2. Call ${c.cyan("letter.identify(...)")} where users sign up or log in.`);
+  log(`  3. Call ${c.cyan("letter.track(...)")} on 2-3 key actions.`);
+  log();
+  log(c.dim("Check it landed: ") + c.bold("letter status"));
+  log(c.dim("Your API key is in .env.local - keep it out of source control."));
+  log();
+}
+function rel(cwd, file) {
+  return file.startsWith(cwd) ? file.slice(cwd.length + 1) || file : file;
+}
+function tildify(file) {
+  const home = process.env.HOME || process.env.USERPROFILE;
+  return home && file.startsWith(home) ? `~${file.slice(home.length)}` : file;
+}
+
+// src/commands/auth.ts
+function mask(key) {
+  return key.length > 12 ? key.slice(0, 8) + "\u2026" + key.slice(-4) : "set";
+}
+function registerAuthCommands(program2) {
+  const auth = program2.command("auth").description("Manage the stored Letter connection");
+  auth.command("status").description("Show whether this machine is connected to Letter").action(async () => {
+    const cred = await readCredential();
+    const envKey = process.env.LETTER_API_KEY;
+    if (!cred && !envKey) {
+      if (isJsonMode()) printJson({ connected: false });
+      else printInfo("Not connected. Run " + c.bold("letter login") + " to set up.");
+      return;
+    }
+    if (isJsonMode()) {
+      printJson({
+        connected: true,
+        source: envKey ? "env" : "credentials",
+        project: cred?.project ?? null,
+        base_url: cred?.baseUrl ?? null,
+        key: envKey ? "env" : cred ? mask(cred.apiKey) : null
+      });
+      return;
+    }
+    printSuccess("Connected" + (cred ? ` to ${c.bold(cred.project.name)}` : ""));
+    if (cred) {
+      console.log(c.dim("  Project: ") + cred.project.slug);
+      console.log(c.dim("  Key:     ") + mask(cred.apiKey));
+      console.log(c.dim("  API:     ") + cred.baseUrl);
+    }
+    if (envKey) console.log(c.dim("  LETTER_API_KEY is set in the environment."));
+  });
+  auth.command("logout").description("Remove the stored credential (~/.letter/credentials.json)").action(async () => {
+    await clearCredential();
+    printSuccess("Removed stored credential.");
+  });
+}
+
+// src/commands/status.ts
+function registerStatusCommand(program2) {
+  program2.command("status").description("Check whether your project has received any contacts or events").action(async () => {
+    const spin = spinner("Checking your Letter project\u2026").start();
+    try {
+      const { data } = await client.get("/v1/status");
+      spin.stop();
+      if (isJsonMode()) {
+        printJson(data);
+        return;
+      }
+      const cred = await readCredential();
+      const contacts = data.contacts ?? 0;
+      const events = data.events ?? 0;
+      if (cred) printInfo(`Project ${c.bold(cred.project.name)}`);
+      if (contacts > 0 || events > 0) {
+        printSuccess(`Connected. ${contacts} contact(s), ${events} event(s) received.`);
+      } else {
+        printInfo("Connected, but no data yet. Fire your first identify/track call.");
+      }
+    } catch (err) {
+      spin.stop();
+      printError(err);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/config.ts
+function registerConfigCommands(program2) {
+  const cfg = program2.command("config").description("Manage CLI configuration");
+  cfg.command("set").description("Set a config value").argument("<key>", "Config key: base-url").argument("<value>", "Value to set").action((key, value) => {
+    switch (key) {
+      case "base-url":
+        setBaseUrl(value);
+        printSuccess(`Base URL set to ${getBaseUrl()}`);
+        break;
+      default:
+        printError(new Error(`Unknown config key: ${key}. Valid keys: base-url`));
+        process.exitCode = 1;
+    }
+  });
+  cfg.command("get").description("Show CLI configuration").argument("[key]", "Config key (omit to show all)").action((key) => {
+    const all = { base_url: getBaseUrl(), config_path: getConfigPath() };
+    if (key && key !== "base-url" && key !== "path") {
+      printError(new Error(`Unknown config key: ${key}`));
+      process.exitCode = 1;
+      return;
+    }
+    if (isJsonMode()) {
+      printJson(key === "base-url" ? { base_url: all.base_url } : key === "path" ? { config_path: all.config_path } : all);
+      return;
+    }
+    if (key === "base-url") console.log(all.base_url);
+    else if (key === "path") console.log(all.config_path);
+    else for (const [k, v] of Object.entries(all)) console.log(c.bold(k + ":") + " " + v);
+  });
+  cfg.command("reset").description("Reset CLI configuration to defaults").action(() => {
+    resetConfig();
+    printSuccess("Configuration reset.");
+  });
+}
+
+// src/index.ts
+var program = new Command();
+program.name("letter").description("Connect your app to Letter, then manage it from the command line").version("0.2.0").option("--json", "Output raw JSON (for scripting / agents)").hook("preAction", (thisCommand) => {
+  if (thisCommand.opts().json) setJsonMode(true);
 });
+registerLoginCommand(program);
+registerAuthCommands(program);
+registerStatusCommand(program);
+registerConfigCommands(program);
+program.parseAsync();
+//# sourceMappingURL=index.js.map