@suronai/cli 0.1.39 → 0.1.41

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@suronai/cli",
-  "version": "0.1.39",
+  "version": "0.1.41",
   "description": "Suron CLI — secrets delivery",
   "type": "module",
   "bin": {

package/src/commands.js

@@ -1,19 +1,235 @@
 import { Command } from "commander";
-import { intro, outro, spinner, select, text, isCancel } from "@clack/prompts";
+import { spinner, select, text, isCancel } from "@clack/prompts";
 import { existsSync, readFileSync, writeFileSync } from "fs";
-import { join } from "path";
-import { exec } from "child_process";
+import { join, basename, relative } from "path";
+import { spawn, execSync } from "child_process";
 import ui from "./utils/colors.js";
 import { getToken, requireToken, saveConfig, clearToken } from "./utils/config.js";
 import { api, BASE_URL } from "./utils/api.js";
 
-function cancel(msg) {
+// ── Shared helpers ────────────────────────────────────────────────────────────
+
+function cancel(msg, hint) {
   console.log(ui.blank());
-  console.log(ui.errBlock(msg));
+  console.log(ui.errBlock(msg, hint));
   console.log(ui.blank());
   process.exit(1);
 }
 
+function sanitiseName(name) {
+  return name.replace(/[^a-zA-Z0-9]/g, "");
+}
+
+function openBrowser(url) {
+  if (process.platform === "win32") {
+    spawn("cmd", ["/c", "start", "", url], { detached: true, stdio: "ignore" }).unref();
+  } else if (process.platform === "darwin") {
+    spawn("open", [url], { detached: true, stdio: "ignore" }).unref();
+  } else {
+    spawn("xdg-open", [url], { detached: true, stdio: "ignore" }).unref();
+  }
+}
+
+function waitForEnter(prompt) {
+  process.stdout.write(prompt);
+  return new Promise(resolve => {
+    const handler = (buf) => {
+      if (buf.toString().includes("\n")) {
+        process.stdin.removeListener("data", handler);
+        process.stdin.pause();
+        resolve();
+      }
+    };
+    process.stdin.resume();
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", handler);
+  });
+}
+
+function detectPackageManager(cwd) {
+  if (existsSync(join(cwd, "bun.lockb")) || existsSync(join(cwd, "bun.lock"))) return "bun";
+  if (existsSync(join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync(join(cwd, "yarn.lock")))       return "yarn";
+  return "npm";
+}
+
+function pmAddCmd(pm) {
+  return pm === "npm" ? "install" : "add";
+}
+
+// ── .gitignore ────────────────────────────────────────────────────────────────
+
+const GITIGNORE_ENTRIES = [".env", ".suron.json"];
+
+function ensureGitignore(cwd) {
+  const gitignorePath = join(cwd, ".gitignore");
+  if (!existsSync(gitignorePath)) {
+    writeFileSync(gitignorePath, GITIGNORE_ENTRIES.join("\n") + "\n", "utf-8");
+    return "created";
+  }
+  const content  = readFileSync(gitignorePath, "utf-8");
+  const existing = new Set(content.split("\n").map(l => l.trim()));
+  const missing  = GITIGNORE_ENTRIES.filter(e => !existing.has(e));
+  if (missing.length === 0) return "ok";
+  const sep = content.endsWith("\n") ? "" : "\n";
+  writeFileSync(gitignorePath, content + sep + missing.join("\n") + "\n", "utf-8");
+  return `added ${missing.join(", ")}`;
+}
+
+// ── SDK install ───────────────────────────────────────────────────────────────
+
+function installSdk(cwd) {
+  const pkgJsonPath = join(cwd, "package.json");
+  if (!existsSync(pkgJsonPath)) return { status: "skip", note: "no package.json" };
+
+  let alreadyInstalled = false;
+  let isEsm = false;
+  try {
+    const pkg = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+    alreadyInstalled = !!(pkg.dependencies?.["@suronai/sdk"] || pkg.devDependencies?.["@suronai/sdk"]);
+    isEsm = pkg.type === "module";
+  } catch {
+    return { status: "skip", note: "could not read package.json" };
+  }
+
+  if (alreadyInstalled) return { status: "skip", note: "already installed", isEsm };
+
+  const pm = detectPackageManager(cwd);
+  try {
+    execSync(`${pm} ${pmAddCmd(pm)} @suronai/sdk`, { cwd, stdio: "pipe" });
+    return { status: "done", isEsm };
+  } catch {
+    return { status: "fail", note: `run: npm install @suronai/sdk`, isEsm };
+  }
+}
+
+// ── Entry-point patching ──────────────────────────────────────────────────────
+
+async function patchEntryPoint(cwd, isEsm) {
+  const candidates = isEsm
+    ? ["index.js", "index.mjs", "src/index.js", "src/index.mjs"]
+    : ["index.js", "index.cjs", "src/index.js", "src/index.cjs"];
+
+  let entryPath = null;
+  for (const rel of candidates) {
+    const abs = join(cwd, rel);
+    if (existsSync(abs)) { entryPath = abs; break; }
+  }
+
+  if (!entryPath) { printSnippet(isEsm); return; }
+
+  let src;
+  try { src = readFileSync(entryPath, "utf-8"); } catch { return; }
+
+  const lines = src.split("\n");
+  const toReplace   = [];
+  const seenIndices = new Set();
+
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    const indent  = lines[i].match(/^(\s*)/)[1];
+
+    if (lines[i].includes("dotenv")) {
+      seenIndices.add(i);
+      let replacement = null;
+      if (isEsm) {
+        if (trimmed.startsWith("import")) {
+          replacement = indent + trimmed.replace(/(from\s+)['"]dotenv(?:\/config)?['"]/, '$1"@suronai/sdk"');
+        }
+      } else {
+        if (trimmed.includes("require")) {
+          replacement = indent + 'const { config } = require("@suronai/sdk");\n' + indent + "await config();";
+        }
+      }
+      toReplace.push({ index: i, content: lines[i], replacement });
+    }
+  }
+
+  if (isEsm) {
+    for (let i = 0; i < lines.length; i++) {
+      if (seenIndices.has(i)) continue;
+      const trimmed = lines[i].trim();
+      const indent  = lines[i].match(/^(\s*)/)[1];
+      if (/^config\s*\(.*\);?$/.test(trimmed) && !trimmed.startsWith("//")) {
+        toReplace.push({
+          index: i,
+          content: lines[i],
+          replacement: indent + trimmed.replace(/^config\s*\(/, "await config("),
+        });
+      }
+    }
+    toReplace.sort((a, b) => a.index - b.index);
+  }
+
+  if (toReplace.length === 0) { printSnippet(isEsm); return; }
+
+  const relEntry = relative(cwd, entryPath);
+
+  console.log(ui.kv("ENTRY", relEntry, 8));
+  console.log(ui.blank());
+
+  for (const { content, replacement } of toReplace) {
+    console.log(ui.diff("remove", content.trim()));
+    if (replacement !== null) {
+      for (const l of replacement.split("\n")) console.log(ui.diff("add", l.trim()));
+    } else {
+      console.log(ui.diff("unknown", ""));
+    }
+    console.log(ui.blank());
+  }
+
+  await waitForEnter(ui.promptLine("apply patch?  [Y/n]"));
+  const answer = "";
+  const confirmed = answer === "" || /^y(es)?$/i.test(answer);
+  console.log(ui.blank());
+  console.log(ui.hr());
+  console.log(ui.blank());
+
+  if (!confirmed) { printSnippet(isEsm); return; }
+
+  const indexMap = new Map(toReplace.map(r => [r.index, r]));
+  const outLines = lines.map((line, i) => {
+    const r = indexMap.get(i);
+    return (r && r.replacement !== null) ? r.replacement : line;
+  });
+
+  if (isEsm) {
+    const callLineIndex   = outLines.findIndex(l => /^\s*await config\s*\(/.test(l));
+    const lastImportIndex = outLines.reduce((last, l, i) => l.trimStart().startsWith("import ") ? i : last, -1);
+    if (callLineIndex !== -1 && callLineIndex > lastImportIndex + 2) {
+      const callLine = outLines[callLineIndex];
+      outLines.splice(callLineIndex, 1);
+      if (outLines[callLineIndex]?.trim() === "") outLines.splice(callLineIndex, 1);
+      const newLastImport = outLines.reduce((last, l, i) => l.trimStart().startsWith("import ") ? i : last, -1);
+      outLines.splice(newLastImport + 1, 0, "", callLine, "");
+    }
+  }
+
+  try {
+    writeFileSync(entryPath, outLines.join("\n"), "utf-8");
+  } catch (err) {
+    console.error(ui.errBlock("could not write " + relEntry, err.message));
+    printSnippet(isEsm);
+  }
+}
+
+function printSnippet(isEsm) {
+  console.log(ui.infoBlock("add to your entry point:"));
+  console.log(ui.blank());
+  if (isEsm) {
+    console.log(ui.INDENT + "   " + ui.amber('import { config } from "@suronai/sdk"'));
+    console.log(ui.INDENT + "   " + ui.amber("await config()"));
+  } else {
+    console.log(ui.INDENT + "   " + ui.amber('const { config } = require("@suronai/sdk")'));
+    console.log(ui.INDENT + "   " + ui.amber("await config()"));
+  }
+  console.log(ui.blank());
+  console.log(ui.hr());
+  console.log(ui.blank());
+}
+
+// ── Commands ──────────────────────────────────────────────────────────────────
+
 export const loginCommand = new Command("login")
   .description("Authenticate via browser")
   .option("--force", "Re-authenticate even if already logged in")
@@ -42,12 +258,14 @@ export const loginCommand = new Command("login")
 
     const loginUrl = `${BASE_URL}/clilogin?code=${code}`;
 
-    console.log(ui.infoBlock("Opening browser to complete login..."));
+    console.log(ui.infoBlock("press Enter to open login in your browser"));
     console.log(ui.blank());
     console.log(ui.kv("URL", loginUrl, 6));
     console.log(ui.blank());
 
-    exec(`open "${loginUrl}" 2>/dev/null || xdg-open "${loginUrl}" 2>/dev/null || cmd /c start "" "${loginUrl}" 2>/dev/null`);
+    await waitForEnter(ui.promptLine("open browser"));
+    openBrowser(loginUrl);
+    console.log(ui.blank());
 
     const s = spinner();
     s.start("Waiting for approval");
@@ -90,9 +308,7 @@ export const logoutCommand = new Command("logout")
   .description("Clear local session token")
   .action(async () => {
     clearToken();
-    try {
-      await api("/auth/logout", { method: "POST" });
-    } catch {}
+    try { await api("/auth/logout", { method: "POST" }); } catch {}
     console.log(ui.blank());
     console.log(ui.okBlock("logged out"));
     console.log(ui.blank());
@@ -100,19 +316,21 @@ export const logoutCommand = new Command("logout")
 
 export const initCommand = new Command("init")
   .description("Initialize Suron in this project")
-  .action(async () => {
-    const token = requireToken();
+  .option("--name <n>", "App name (skips interactive prompt)")
+  .action(async (opts) => {
+    requireToken();
+    const cwd = process.cwd();
 
-    if (existsSync(".suron.json")) {
+    if (existsSync(join(cwd, ".suron.json"))) {
       console.log(ui.blank());
       console.log(ui.errBlock(".suron.json already exists", "use suron up to push a new version"));
       console.log(ui.blank());
       process.exit(1);
     }
 
-    if (!existsSync(".env")) {
+    if (!existsSync(join(cwd, ".env"))) {
       console.log(ui.blank());
-      console.log(ui.errBlock(".env not found", "create a .env file first"));
+      console.log(ui.errBlock(".env not found", "create a .env file with your secrets first"));
       console.log(ui.blank());
       process.exit(1);
     }
@@ -122,40 +340,49 @@ export const initCommand = new Command("init")
     console.log(ui.hr());
     console.log(ui.blank());
 
+    // ── App selection ─────────────────────────────────────────────────────────
+
     const mode = await select({
       message: "How do you want to link this project?",
       options: [
-        { value: "new", label: "Create new app" },
+        { value: "new",      label: "Create new app"      },
         { value: "existing", label: "Link to existing app" },
       ],
     });
-
     if (isCancel(mode)) cancel("cancelled");
 
     let app_id, app_name;
 
     if (mode === "new") {
-      const name = await text({
-        message: "App name (alphanumeric)",
-        validate: v => /^[a-zA-Z0-9]+$/.test(v) ? undefined : "Alphanumeric only",
-      });
-      if (isCancel(name)) cancel("cancelled");
+      const suggested = sanitiseName(basename(cwd) || "myapp");
+      let rawName;
+
+      if (opts.name) {
+        rawName = opts.name;
+      } else {
+        rawName = await text({
+          message: `App name  [${suggested}]`,
+          placeholder: suggested,
+          validate: v => {
+            const s = sanitiseName(v || suggested);
+            return s.length ? undefined : "Alphanumeric only";
+          },
+        });
+        if (isCancel(rawName)) cancel("cancelled");
+      }
+
+      const name = sanitiseName(rawName || suggested);
 
       const result = await api("/apps", {
         method: "POST",
         body: JSON.stringify({ name }),
       }).catch(err => cancel(err.message));
 
-      app_id = result.app_id;
+      app_id   = result.app_id;
       app_name = result.name;
     } else {
       const apps = await api("/apps").catch(err => cancel(err.message));
-
-      if (!apps.length) {
-        console.log(ui.blank());
-        console.log(ui.errBlock("no apps found", "use 'Create new app' instead"));
-        process.exit(1);
-      }
+      if (!apps.length) cancel("no apps found", "use 'Create new app' instead");
 
       const chosen = await select({
         message: "Select an app",
@@ -164,59 +391,119 @@ export const initCommand = new Command("init")
       if (isCancel(chosen)) cancel("cancelled");
 
       const found = apps.find(a => a.app_id === chosen);
-      app_id = found.app_id;
+      app_id   = found.app_id;
       app_name = found.name;
     }
 
-    const env_plaintext = readFileSync(".env", "utf-8");
+    console.log(ui.blank());
+    console.log(ui.kv("APP", app_name));
+    console.log(ui.kv("DIR", ui.slate(cwd)));
+    console.log(ui.blank());
+    console.log(ui.hr());
+    console.log(ui.blank());
+
+    // ── Step tracker ──────────────────────────────────────────────────────────
 
-    const s = spinner();
-    s.start("Pushing v1");
+    const steps = {
+      upload:    { label: "upload    .env",           status: "pending" },
+      gitignore: { label: "gitignore .gitignore",     status: "pending" },
+      sdk:       { label: "sdk       @suronai/sdk",   status: "pending" },
+      patch:     { label: "patch     entry point",    status: "pending" },
+    };
 
-    const result = await api(`/apps/${app_id}/versions`, {
-      method: "POST",
-      body: JSON.stringify({ env_plaintext }),
-    }).catch(err => { s.stop("failed"); cancel(err.message); });
+    const printSteps = () => {
+      for (const s of Object.values(steps)) {
+        console.log(ui.step(s.status, s.label, s.note));
+      }
+    };
 
-    s.stop("Done");
+    // ── Upload ────────────────────────────────────────────────────────────────
 
-    const suronJson = { app_name, app_id, version: result.version };
-    writeFileSync(".suron.json", JSON.stringify(suronJson, null, 2) + "\n");
+    steps.upload.status = "run";
+    const env_plaintext = readFileSync(join(cwd, ".env"), "utf-8");
 
-    console.log(ui.blank());
-    console.log(ui.step("done", "encrypted and uploaded .env"));
-    console.log(ui.step("done", `version  ${result.version}`));
-    console.log(ui.step("done", "wrote  .suron.json"));
+    let uploadResult;
+    try {
+      uploadResult = await api(`/apps/${app_id}/versions`, {
+        method: "POST",
+        body: JSON.stringify({ env_plaintext }),
+      });
+      steps.upload.status = "done";
+      steps.upload.note   = `v${uploadResult.version}`;
+    } catch (err) {
+      steps.upload.status = "fail";
+      printSteps();
+      console.log(ui.blank());
+      cancel(err.message);
+    }
+
+    // ── .suron.json ───────────────────────────────────────────────────────────
+
+    writeFileSync(
+      join(cwd, ".suron.json"),
+      JSON.stringify({ app_name, app_id, version: uploadResult.version }, null, 2) + "\n",
+      "utf-8"
+    );
+
+    // ── .gitignore ────────────────────────────────────────────────────────────
+
+    steps.gitignore.status = "run";
+    const gitResult = ensureGitignore(cwd);
+    steps.gitignore.status = "done";
+    steps.gitignore.note   = gitResult;
+
+    // ── SDK install ───────────────────────────────────────────────────────────
+
+    steps.sdk.status = "run";
+    const sdkResult = installSdk(cwd);
+    steps.sdk.status = sdkResult.status;
+    steps.sdk.note   = sdkResult.note;
+
+    // ── Print steps before patch (patch is interactive) ───────────────────────
+
+    steps.patch.status = "run";
+    printSteps();
     console.log(ui.blank());
     console.log(ui.hr());
     console.log(ui.blank());
-    console.log(ui.infoBlock("add .suron.json to git  ·  add .env to .gitignore"));
+
+    // ── Entry-point patch ─────────────────────────────────────────────────────
+
+    await patchEntryPoint(cwd, sdkResult.isEsm ?? false);
+    steps.patch.status = "done";
+
+    // ── Ready ─────────────────────────────────────────────────────────────────
+
+    console.log(ui.readyBlock([
+      { label: ".env",        note: "uploaded  ·  keep out of git"  },
+      { label: ".suron.json", note: "safe to commit"                 },
+      { label: ".gitignore",  note: gitResult                        },
+    ]));
     console.log(ui.blank());
   });
 
-export const upCommand = new Command("up")
-  .description("Push a new version of .env")
+export const whoamiCommand = new Command("whoami")
+  .description("Show the current logged-in user")
   .action(async () => {
     requireToken();
+    const user = await api("/auth/me").catch(err => cancel(err.message));
+    console.log(ui.blank());
+    console.log(ui.kv("EMAIL", user.email));
+    console.log(ui.kv("ROLE",  user.role));
+    console.log(ui.blank());
+  });
 
-    if (!existsSync(".suron.json")) {
-      console.log(ui.blank());
-      console.log(ui.errBlock(".suron.json not found", "run: suron init"));
-      console.log(ui.blank());
-      process.exit(1);
-    }
-
-    if (!existsSync(".env")) {
-      console.log(ui.blank());
-      console.log(ui.errBlock(".env not found"));
-      console.log(ui.blank());
-      process.exit(1);
-    }
+export const upCommand = new Command("up")
+  .action(async () => {
+    requireToken();
+    const cwd = process.cwd();
 
-    const suronJson = JSON.parse(readFileSync(".suron.json", "utf-8"));
-    const { app_id, app_name } = suronJson;
+    if (!existsSync(join(cwd, ".suron.json"))) cancel(".suron.json not found", "run: suron init");
+    if (!existsSync(join(cwd, ".env")))         cancel(".env not found");
 
-    const env_plaintext = readFileSync(".env", "utf-8");
+    const suronJson     = JSON.parse(readFileSync(join(cwd, ".suron.json"), "utf-8"));
+    const { app_id }    = suronJson;
+    const env_plaintext = readFileSync(join(cwd, ".env"), "utf-8");
 
     const s = spinner();
     s.start("Pushing new version");
@@ -229,7 +516,7 @@ export const upCommand = new Command("up")
     s.stop("Done");
 
     suronJson.version = result.version;
-    writeFileSync(".suron.json", JSON.stringify(suronJson, null, 2) + "\n");
+    writeFileSync(join(cwd, ".suron.json"), JSON.stringify(suronJson, null, 2) + "\n");
 
     console.log(ui.blank());
     console.log(ui.step("done", `version  ${result.version}  pushed`));

package/src/index.js

@@ -2,7 +2,7 @@
 
 import { Command } from "commander";
 import { createRequire } from "module";
-import { loginCommand, logoutCommand, initCommand, upCommand } from "./commands.js";
+import { loginCommand, logoutCommand, initCommand, upCommand, whoamiCommand } from "./commands.js";
 
 const require = createRequire(import.meta.url);
 const { version } = require("../package.json");
@@ -16,6 +16,7 @@ program
 
 program.addCommand(loginCommand);
 program.addCommand(logoutCommand);
+program.addCommand(whoamiCommand);
 program.addCommand(initCommand);
 program.addCommand(upCommand);
 

package/src/utils/api.js

@@ -1,13 +1,15 @@
 import { getToken } from "./config.js";
 
-const BASE_URL = "https://suron.vercel.app";
+const WEB_URL = process.env.SURON_WEB_URL ?? "https://suron.vercel.app";
+const API_URL = `${WEB_URL}/api`;
+const BASE_URL = WEB_URL;
 
 export async function api(path, options = {}) {
   const token = getToken();
   const headers = { "Content-Type": "application/json", ...options.headers };
   if (token) headers["Authorization"] = `Bearer ${token}`;
 
-  const res = await fetch(`${BASE_URL}${path}`, { ...options, headers });
+  const res = await fetch(`${API_URL}${path}`, { ...options, headers });
 
   if (!res.ok) {
     const data = await res.json().catch(() => ({}));