@frevana/cli 0.1.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Frevana
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,68 @@
+# frevana
+
+Frevana is the command-line client for `frevana-server`.
+
+It is designed to help users authenticate with Frevana and run terminal-based workflows backed by Frevana services.
+
+## What This CLI Does
+
+- Sign in with device authorization
+- Store the API key locally for reuse
+- Connect terminal workflows to Frevana server capabilities
+
+## Requirements
+
+- Node.js 20 or later
+- npm
+
+## Install
+
+```bash
+npm install -g @frevana/cli
+```
+
+## Available Commands
+
+### Show help
+
+```bash
+frevana --help
+```
+
+### Show version
+
+```bash
+frevana --version
+```
+
+### Login
+
+By default, the CLI uses the production server:
+
+```bash
+frevana login
+```
+
+Use a custom server when needed:
+
+```bash
+frevana login --server http://localhost:3000
+```
+
+Current default server:
+
+```text
+https://api.frevana.com
+```
+
+## How Login Works
+
+1. Run `frevana login`
+2. Complete the device authorization flow in your browser
+3. The CLI stores your API key locally after a successful login
+
+The saved config file is:
+
+```text
+~/.frevana/cli-config.json
+```

package/dist/cli.js

@@ -0,0 +1,213 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import fs2 from "fs";
+import { Command } from "commander";
+import chalk2 from "chalk";
+
+// src/commands/login.ts
+import chalk from "chalk";
+import inquirer from "inquirer";
+
+// src/lib/auth/device-authorization.ts
+async function startDeviceAuthorization(serverUrl, scopes) {
+  const response = await fetch(`${serverUrl}/device-authorization/start`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json"
+    },
+    body: JSON.stringify({
+      client_name: "frevana-cli",
+      scopes
+    })
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Start authorization failed (${response.status}): ${text}`);
+  }
+  return await response.json();
+}
+async function pollDeviceAuthorization(serverUrl, deviceCode) {
+  const response = await fetch(`${serverUrl}/device-authorization/poll`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json"
+    },
+    body: JSON.stringify({
+      device_code: deviceCode
+    })
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Poll failed (${response.status}): ${text}`);
+  }
+  return await response.json();
+}
+
+// src/lib/config/credentials.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+var CONFIG_DIR = path.join(os.homedir(), ".frevana");
+var CONFIG_PATH = path.join(CONFIG_DIR, "cli-config.json");
+function saveCredentials(credentials) {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(
+    CONFIG_PATH,
+    `${JSON.stringify(credentials, null, 2)}
+`,
+    "utf-8"
+  );
+}
+
+// src/lib/utils/browser.ts
+import { spawn } from "child_process";
+function openUrl(url) {
+  const platform = process.platform;
+  const command = platform === "darwin" ? "open" : platform === "win32" ? "cmd" : "xdg-open";
+  const args = platform === "win32" ? ["/c", "start", "", url] : [url];
+  try {
+    const child = spawn(command, args, {
+      stdio: "ignore",
+      detached: true
+    });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getApiKeyPageUrl(verificationUri) {
+  try {
+    const parsed = new URL(verificationUri);
+    return `${parsed.origin}/dashboard`;
+  } catch {
+    return `${verificationUri}/dashboard`;
+  }
+}
+
+// src/commands/login.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function sleepWithLoading(ms, label) {
+  if (!process.stdout.isTTY) {
+    await sleep(ms);
+    return;
+  }
+  const frames = ["", ".", "..", "..."];
+  let frameIndex = 0;
+  const intervalMs = 250;
+  const endAt = Date.now() + ms;
+  const render = () => {
+    const text = `${label}${frames[frameIndex]}`;
+    process.stdout.write(`\r${chalk.gray(text.padEnd(48, " "))}`);
+    frameIndex = (frameIndex + 1) % frames.length;
+  };
+  render();
+  await new Promise((resolve) => {
+    const timer = setInterval(() => {
+      if (Date.now() >= endAt) {
+        clearInterval(timer);
+        resolve();
+        return;
+      }
+      render();
+    }, intervalMs);
+  });
+  process.stdout.write(`\r${" ".repeat(64)}\r`);
+}
+async function loginCommand(serverUrl) {
+  const normalizedServer = serverUrl.replace(/\/+$/, "");
+  const start = await startDeviceAuthorization(normalizedServer, []);
+  const expiresAt = Date.now() + start.expires_in * 1e3;
+  let waitSeconds = start.interval;
+  let waitingHintPrinted = false;
+  console.log(chalk.blue("\nDevice authorization started.\n"));
+  console.log(`Code: ${chalk.bold(start.user_code)}`);
+  console.log(`Authorization URL: ${start.verification_uri_complete}
+`);
+  const opened = openUrl(start.verification_uri_complete);
+  if (opened) {
+    console.log(chalk.green("Opened authorization page in your browser.\n"));
+  } else {
+    console.log(
+      chalk.yellow("Could not open browser automatically. Open URL manually.\n")
+    );
+  }
+  while (Date.now() < expiresAt) {
+    const result = await pollDeviceAuthorization(normalizedServer, start.device_code);
+    if (result.status === "approved" && result.api_key) {
+      saveCredentials({
+        server_url: normalizedServer,
+        api_key: result.api_key,
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      console.log(chalk.green("Login successful. API key saved to local config."));
+      return;
+    }
+    if (result.status === "pending") {
+      if (!waitingHintPrinted && !process.stdout.isTTY) {
+        console.log(chalk.gray("Waiting for authorization..."));
+        waitingHintPrinted = true;
+      }
+      await sleepWithLoading(waitSeconds * 1e3, "Waiting for authorization");
+      continue;
+    }
+    if (result.status === "slow_down") {
+      waitSeconds = Math.min(waitSeconds + 2, 15);
+      if (!waitingHintPrinted && !process.stdout.isTTY) {
+        console.log(chalk.gray("Waiting for authorization..."));
+        waitingHintPrinted = true;
+      }
+      await sleepWithLoading(waitSeconds * 1e3, "Waiting for authorization");
+      continue;
+    }
+    if (result.status === "denied" || result.status === "expired") {
+      throw new Error(result.error_message || "Authorization failed.");
+    }
+    await sleep(waitSeconds * 1e3);
+  }
+  const apiKeyPage = getApiKeyPageUrl(start.verification_uri);
+  console.log(chalk.yellow("\nAuthorization timed out."));
+  console.log(`Open API Key page: ${apiKeyPage}`);
+  const { apiKey } = await inquirer.prompt([
+    {
+      type: "password",
+      name: "apiKey",
+      message: "Paste API Key:",
+      mask: "*",
+      validate: (value) => value.trim() ? true : "API Key is required"
+    }
+  ]);
+  saveCredentials({
+    server_url: normalizedServer,
+    api_key: apiKey.trim(),
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  console.log(chalk.green("API key saved to local config."));
+}
+
+// src/cli.ts
+var packageJson = JSON.parse(
+  fs2.readFileSync(new URL("../package.json", import.meta.url), "utf-8")
+);
+var program = new Command();
+program.name("frevana").description("Frevana command line tool").version(packageJson.version);
+program.command("login").description("Login with device authorization flow").option(
+  "--server <url>",
+  "Frevana server URL",
+  process.env.FREVANA_SERVER_URL || "https://api.frevana.com"
+).action(async (opts) => {
+  try {
+    await loginCommand(opts.server);
+  } catch (error) {
+    console.error(chalk2.red(`Login failed: ${error}`));
+    process.exit(1);
+  }
+});
+program.parseAsync().catch((error) => {
+  console.error(chalk2.red(`Command failed: ${error}`));
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@frevana/cli",
+  "version": "0.1.2",
+  "description": "Frevana CLI for calling frevana-server APIs and using server capabilities",
+  "type": "module",
+  "bin": {
+    "frevana": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.map",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "check": "tsc --noEmit",
+    "release": "npm run build && npm publish --access public",
+    "release:dry-run": "npm run build && npm publish --access public --dry-run"
+  },
+  "keywords": [
+    "frevana",
+    "cli",
+    "device-auth",
+    "api-key"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "inquirer": "^9.3.7"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.9",
+    "@types/node": "^25.5.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
+  }
+}