@datalabrotterdam/nova-ai-cli 1.1.0 → 1.2.0-alpha.1

package/dist/index.js

@@ -1,25 +1,163 @@
 #!/usr/bin/env node
-import { runBrowserAuth } from "./acp/auth-server.js";
-import chat from "./tui/index.js";
-import web from "./webui/index.js";
-import acp from "./acp/index.js";
+import {
+  readPackageVersion
+} from "./chunk-Q7WL3DXP.js";
+
+// src/cli.ts
+var SUBCOMMANDS = {
+  login: "login",
+  logout: "logout",
+  help: "help",
+  version: "version"
+};
+var MODE_FLAGS = {
+  "--acp": "acp",
+  "-p": "print",
+  "--print": "print",
+  "--headless": "print",
+  "--setup": "login",
+  "--version": "version",
+  "-v": "version",
+  "--web": "web"
+};
+function parseCli(argv) {
+  const first = argv[0];
+  if (first !== void 0 && SUBCOMMANDS[first]) {
+    return { mode: SUBCOMMANDS[first], args: argv.slice(1) };
+  }
+  const end = argv.indexOf("--");
+  const options = end >= 0 ? argv.slice(0, end) : argv;
+  const modes = new Set(options.flatMap((arg) => MODE_FLAGS[arg] ? [MODE_FLAGS[arg]] : []));
+  if (modes.size > 1) {
+    return { mode: "error", message: `Choose one mode, not ${[...modes].join(" and ")}.` };
+  }
+  const mode = [...modes][0];
+  const wantsHelp = options.includes("--help") || options.includes("-h");
+  if (!mode) return wantsHelp ? { mode: "help", args: [] } : { mode: "tui", args: argv };
+  const drop = /* @__PURE__ */ new Set(["--acp", "--headless", "--setup", "--version", "-v", "--web"]);
+  return { mode, args: argv.filter((arg, index) => !(drop.has(arg) && (end < 0 || index < end))) };
+}
+function versionText() {
+  return `nova-ai ${readPackageVersion() ?? "unknown"}`;
+}
+var MAIN_HELP = `Nova AI \u2014 agentic coding in your terminal, and an ACP agent for editors.
+
+Usage:
+  nova-ai [options]                 Interactive terminal UI
+  nova-ai -p [options] [prompt]     Run one request headless (see nova-ai -p --help)
+  nova-ai --acp                     Agent Client Protocol over stdio (for editors)
+  nova-ai login [--no-browser]      Connect your Nova AI account
+  nova-ai logout                    Remove the stored API key
+
+Interactive options:
+      --resume <session-id>         Continue a saved session
+  -c, --continue                    Continue the most recent session in this folder
+      --model <id>                  Use this model
+
+General:
+  -h, --help                        Show help
+  -v, --version                     Show the version
+
+Environment:
+  NOVA_API_KEY, NOVA_MODEL          Use this key / model instead of the stored ones
+  NOVA_BASE_URL                     Use another Nova gateway
+  NOVA_AI_HOME                      Settings folder (default ~/.nova-ai)
+  NOVA_TOOL_PROTOCOL                Force "native" or "text" tool calling`;
+function parseTuiArgs(args) {
+  const options = { resume: null, continueLast: false, model: null };
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    const value = (name) => {
+      const next = args[++index];
+      if (!next || next.startsWith("-")) throw new Error(`${name} requires a value.`);
+      return next;
+    };
+    if (arg === "--resume") options.resume = value(arg);
+    else if (arg.startsWith("--resume=")) options.resume = arg.slice("--resume=".length);
+    else if (arg === "--continue" || arg === "-c") options.continueLast = true;
+    else if (arg === "--model") options.model = value(arg);
+    else if (arg.startsWith("--model=")) options.model = arg.slice("--model=".length);
+    else throw new Error(`Unknown option for the interactive UI: ${arg}`);
+  }
+  if (options.resume && options.continueLast) {
+    throw new Error("Use either --continue or --resume, not both.");
+  }
+  return options;
+}
+
+// src/index.ts
 async function main() {
-    const args = process.argv.slice(2);
-    if (args.includes("--setup")) {
-        await runBrowserAuth();
-        return;
+  const command = parseCli(process.argv.slice(2));
+  switch (command.mode) {
+    case "error":
+      process.stderr.write(`${command.message}
+
+${MAIN_HELP}
+`);
+      return 2;
+    case "help":
+      process.stdout.write(`${MAIN_HELP}
+`);
+      return 0;
+    case "version":
+      process.stdout.write(`${versionText()}
+`);
+      return 0;
+    case "acp": {
+      if (command.args.length) {
+        process.stderr.write(`--acp takes no other arguments (got ${command.args.join(" ")}).
+`);
+        return 2;
+      }
+      const { default: runAcp } = await import("./acp-ZYOQ6PON.js");
+      await runAcp();
+      return 0;
+    }
+    case "print": {
+      const { default: runHeadless } = await import("./headless-ZYUSTZDL.js");
+      return runHeadless(command.args);
+    }
+    case "login": {
+      const { runLogin } = await import("./login-6U7QS7EA.js");
+      return runLogin(command.args);
+    }
+    case "logout": {
+      const { runLogout } = await import("./login-6U7QS7EA.js");
+      return runLogout();
     }
-    if (args.includes("--acp")) {
-        await acp(...args.slice(1));
-        return;
+    case "web": {
+      const { default: runWebUi } = await import("./webui-L4GGMXJ3.js");
+      await runWebUi();
+      return 0;
     }
-    if (args.includes("--web")) {
-        await web(...args.slice(1));
-        return;
+    case "tui": {
+      let options;
+      try {
+        options = parseTuiArgs(command.args);
+      } catch (error) {
+        process.stderr.write(`${error.message}
+
+${MAIN_HELP}
+`);
+        return 2;
+      }
+      if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        process.stderr.write(
+          'nova-ai needs an interactive terminal. For scripts and pipes use `nova-ai -p "<prompt>"`, for editors `nova-ai --acp`.\n'
+        );
+        return 2;
+      }
+      const { default: runChat } = await import("./tui-XOKXPXN2.js");
+      return runChat(options);
     }
-    await chat(...args.slice(1));
+  }
 }
-main().catch((err) => {
+main().then(
+  (code) => {
+    process.exitCode = code;
+  },
+  (err) => {
     console.error(err);
     process.exit(1);
-});
+  }
+);

package/dist/login-6U7QS7EA.js

@@ -0,0 +1,118 @@
+import {
+  credentialsPath,
+  deleteCredentials,
+  runBrowserAuth,
+  validateApiKey,
+  writeCredentials
+} from "./chunk-JAEXUFAS.js";
+
+// src/commands/login.ts
+import { NovaAIError } from "@datalabrotterdam/nova-sdk";
+var defaultIo = () => ({ stdin: process.stdin, stdout: process.stdout, stderr: process.stderr });
+var LOGIN_HELP = `Usage: nova-ai login [--no-browser]
+
+Connects nova-ai to your Nova AI account and stores the API key in
+${"~"}/.nova-ai/credentials.json (readable only by you).
+
+  (default)       Opens a local page in your browser to enter the key
+  --no-browser    Asks for the key in this terminal (input is hidden)
+  piped stdin     Reads the key from stdin, e.g.  echo "$KEY" | nova-ai login
+
+Get a key at https://platform.nova.datalabrotterdam.nl/dashboard/api-keys`;
+async function runLogin(args, io = defaultIo()) {
+  const unknown = args.filter((arg) => arg !== "--no-browser" && arg !== "--help" && arg !== "-h");
+  if (args.includes("--help") || args.includes("-h")) {
+    io.stdout.write(`${LOGIN_HELP}
+`);
+    return 0;
+  }
+  if (unknown.length) {
+    io.stderr.write(`Unknown option: ${unknown[0]}
+
+${LOGIN_HELP}
+`);
+    return 2;
+  }
+  if (!io.stdin.isTTY) {
+    return storeKey((await readAll(io.stdin)).trim(), io);
+  }
+  if (args.includes("--no-browser")) {
+    return storeKey((await readHidden(io, "Nova API key: ")).trim(), io);
+  }
+  try {
+    await runBrowserAuth();
+    io.stdout.write(`Logged in. The key is stored in ${credentialsPath()}.
+`);
+    return 0;
+  } catch (error) {
+    io.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+    io.stderr.write("Tip: run `nova-ai login --no-browser` to enter the key in this terminal.\n");
+    return 1;
+  }
+}
+function runLogout(io = defaultIo()) {
+  const removed = deleteCredentials();
+  io.stdout.write(removed ? "Logged out: the stored API key was removed.\n" : "No stored API key to remove.\n");
+  if (process.env.NOVA_API_KEY) {
+    io.stdout.write("Note: NOVA_API_KEY is set in your environment and still logs you in.\n");
+  }
+  return 0;
+}
+async function storeKey(apiKey, io) {
+  if (!apiKey) {
+    io.stderr.write("No API key given.\n");
+    return 1;
+  }
+  try {
+    writeCredentials(await validateApiKey(apiKey));
+  } catch (error) {
+    io.stderr.write(
+      error instanceof NovaAIError ? `Nova AI rejected this key (status ${error.status}): ${error.message}
+` : `Could not validate the key: ${error instanceof Error ? error.message : String(error)}
+`
+    );
+    return 1;
+  }
+  io.stdout.write(`Logged in. The key is stored in ${credentialsPath()}.
+`);
+  return 0;
+}
+async function readAll(stream) {
+  const chunks = [];
+  for await (const chunk of stream) chunks.push(Buffer.from(chunk));
+  return Buffer.concat(chunks).toString("utf8");
+}
+function readHidden(io, prompt) {
+  return new Promise((resolve, reject) => {
+    const { stdin } = io;
+    io.stdout.write(prompt);
+    let value = "";
+    const wasRaw = stdin.isRaw;
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    const finish = (error) => {
+      stdin.setRawMode(wasRaw);
+      stdin.pause();
+      stdin.removeListener("data", onData);
+      io.stdout.write("\n");
+      if (error) reject(error);
+      else resolve(value);
+    };
+    const onData = (chunk) => {
+      for (const char of chunk) {
+        if (char === "\r" || char === "\n") return finish();
+        if (char === "") return finish(new Error("Login cancelled."));
+        if (char === "\x7F" || char === "\b") value = value.slice(0, -1);
+        else if (char >= " ") value += char;
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+export {
+  LOGIN_HELP,
+  runLogin,
+  runLogout
+};