@nlxai/cli 1.2.2-alpha.6 → 1.2.2-alpha.9

package/README.md

@@ -17,6 +17,8 @@ Intereact with NLX from the command line
 
 Options:
   -h, --help                             display help for command
+  -v, --verbose                          enable verbose logging
+  -V, --version                          show program version
 
 Commands:
   auth                                   Authentication and user management

package/lib/commands/auth/login.js

@@ -4,9 +4,16 @@ import open from "open";
 import * as os from "os";
 import * as path from "path";
 import { consola } from "consola";
-import keytar from "keytar";
 export const ACCOUNTS_PATH = path.join(os.homedir(), ".nlx-cli-auth.json");
+let _keytar;
+async function getKeytar() {
+    if (_keytar)
+        return _keytar;
+    _keytar = await import("keytar");
+    return _keytar;
+}
 async function saveTokens(account, tokenData) {
+    const keytar = await getKeytar();
     await keytar.setPassword("nlx-cli", account, JSON.stringify(tokenData));
 }
 async function loadTokens() {
@@ -23,6 +30,7 @@ async function loadTokens() {
         const data = fs.readFileSync(ACCOUNTS_PATH, "utf8");
         const accounts = JSON.parse(data);
         if (accounts.currentAccount) {
+            const keytar = await getKeytar();
             const res = await keytar.getPassword("nlx-cli", accounts.currentAccount);
             if (res)
                 return [accounts.currentAccount, JSON.parse(res)];

package/lib/commands/fetch.js

@@ -0,0 +1,59 @@
+import { Command } from "commander";
+import * as fs from "fs";
+import { fetchManagementApi } from "../utils/index.js";
+export const fetchCommand = new Command("fetch")
+    .description("Perform an authenticated request to the management API")
+    .argument("<method>", "HTTP method (GET, POST, PUT, DELETE, etc.)")
+    .argument("<path>", "API path (e.g. /models)")
+    .argument("[body]", "Request body as JSON string, name of a JSON file or -- for Standard Input")
+    .option("-p, --paginate", "Enable pagination", false)
+    .action(async (method, apiPath, body, opts) => {
+    if (body === "--") {
+        // Read from stdin
+        body = "";
+        process.stdin.setEncoding("utf8");
+        for await (const chunk of process.stdin)
+            body += chunk;
+        try {
+            body = JSON.parse(body);
+        }
+        catch (ed) {
+            console.error("Invalid JSON string from stdin: " + ed);
+            process.exit(1);
+        }
+    }
+    else if (body != null) {
+        // Try to parse as file path or JSON string
+        try {
+            if (fs.existsSync(body)) {
+                body = JSON.parse(fs.readFileSync(body, "utf8"));
+            }
+            else {
+                body = JSON.parse(body);
+            }
+        }
+        catch {
+            console.error("Invalid JSON string or file path: " + body);
+            process.exit(1);
+        }
+    }
+    let result = await fetchManagementApi(apiPath +
+        (opts.paginate
+            ? apiPath.includes("?")
+                ? "&size=1000"
+                : "?size=2&page=0"
+            : ""), method.toUpperCase(), body);
+    let agg;
+    if (opts.paginate) {
+        const key = Object.keys(result).filter((k) => k !== "nextPageId")[0];
+        agg = result[key];
+        while (result.nextPageId) {
+            result = await fetchManagementApi(apiPath + `?pageId=${result.nextPageId}`, method.toUpperCase(), body);
+            agg.push(...result[key]);
+        }
+    }
+    else {
+        agg = result;
+    }
+    console.log(JSON.stringify(agg, null, 2));
+});

package/lib/commands/login.d.ts

@@ -0,0 +1 @@
+export declare const loginCommand: import("commander").Command;

package/lib/commands/login.js

@@ -0,0 +1,153 @@
+import { Command } from "commander";
+import * as fs from "fs";
+import open from "open";
+import * as os from "os";
+import * as path from "path";
+import { consola } from "consola";
+const ACCOUNTS_PATH = path.join(os.homedir(), ".nlx-cli-auth.json");
+async function saveTokens(account, tokenData) {
+  await keytar.setPassword("nlx-cli", account, JSON.stringify(tokenData));
+}
+async function loadTokens() {
+  try {
+    const data = fs.readFileSync(ACCOUNTS_PATH, "utf8");
+    const accounts = JSON.parse(data);
+    if (accounts.currentAccount) {
+      const res = await keytar.getPassword("nlx-cli", accounts.currentAccount);
+      if (res) return [accounts.currentAccount, JSON.parse(res)];
+    }
+    throw new Error("No tokens found for current account");
+  } catch {
+    throw new Error("Failed to load tokens");
+  }
+}
+async function refreshTokenIfNeeded() {
+  let account, tokens;
+  try {
+    [account, tokens] = await loadTokens();
+  } catch (error) {
+    consola.error("Error loading tokens");
+    return null;
+  }
+  if (!tokens || !tokens.refresh_token) return null;
+  // Check expiry
+  const now = Math.floor(Date.now() / 1000);
+  if (
+    tokens.expires_in &&
+    tokens.obtained_at &&
+    now < tokens.obtained_at + tokens.expires_in - 60
+  ) {
+    consola.debug("Access token is still valid.");
+    return tokens.access_token;
+  }
+  consola.debug("Access token is expired or invalid. Refreshing...");
+  // Refresh
+  const res = await fetch(`https://${AUTH0_DOMAIN}/oauth/token`, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "refresh_token",
+      client_id: CLIENT_ID,
+      refresh_token: tokens.refresh_token,
+    }),
+  });
+  const newTokens = await res.json();
+  if (newTokens.access_token) {
+    newTokens.refresh_token = newTokens.refresh_token || tokens.refresh_token;
+    newTokens.obtained_at = now;
+    await saveTokens(account, newTokens);
+    return newTokens.access_token;
+  }
+  return null;
+}
+const AUTH0_DOMAIN = process.env.AUTH0_DOMAIN || "nlxdev.us.auth0.com"; // e.g. 'dev-xxxxxx.us.auth0.com'
+const CLIENT_ID =
+  process.env.AUTH0_CLIENT_ID || "A0qluq7wJQjFjMLle9pvrWWaVHM1QHE3";
+const AUDIENCE =
+  process.env.AUTH0_AUDIENCE || "https://nlxdev.us.auth0.com/api/v2/";
+export const loginCommand = new Command("login")
+  .description("Authenticate with NLX")
+  .action(async () => {
+    // Step 1: Start device flow
+    const deviceCodeRes = await fetch(
+      `https://${AUTH0_DOMAIN}/oauth/device/code`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({
+          client_id: CLIENT_ID,
+          scope: "openid profile email offline_access",
+          audience: AUDIENCE,
+        }),
+      },
+    );
+    const deviceCodeData = await deviceCodeRes.json();
+    open(deviceCodeData.verification_uri_complete);
+    consola.box(
+      `Please visit ${deviceCodeData.verification_uri_complete} and enter code: ${deviceCodeData.user_code}`,
+    );
+    // Step 2: Poll for token
+    let tokenData;
+    while (!tokenData) {
+      await new Promise((r) => setTimeout(r, deviceCodeData.interval * 1000));
+      const tokenRes = await fetch(`https://${AUTH0_DOMAIN}/oauth/token`, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({
+          grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+          device_code: deviceCodeData.device_code,
+          client_id: CLIENT_ID,
+        }),
+      });
+      const resData = await tokenRes.json();
+      if (resData.access_token) {
+        tokenData = resData;
+      } else if (resData.error !== "authorization_pending") {
+        consola.error("Error:", resData.error_description || resData.error);
+        return;
+      }
+    }
+    // Step 3: Fetch user object
+    let accounts = { currentAccount: null, accounts: [] };
+    if (fs.existsSync(ACCOUNTS_PATH)) {
+      const data = fs.readFileSync(ACCOUNTS_PATH, "utf8");
+      accounts = JSON.parse(data);
+    }
+    const userRes = await fetch(`https://${AUTH0_DOMAIN}/userinfo`, {
+      headers: {
+        Authorization: `Bearer ${tokenData.access_token}`,
+      },
+    });
+    const userData = await userRes.json();
+    if (!accounts.currentAccount) {
+      await fs.promises.writeFile(
+        ACCOUNTS_PATH,
+        JSON.stringify({
+          currentAccount: userData.email,
+          accounts: [userData.email],
+        }),
+      );
+    } else if (accounts.currentAccount !== userData.email) {
+      accounts.currentAccount = userData.email;
+      await fs.promises.writeFile(
+        ACCOUNTS_PATH,
+        JSON.stringify({
+          currentAccount: userData.email,
+          accounts: [userData.email, ...accounts.accounts],
+        }),
+      );
+    }
+    // Step 4: Store token securely
+    tokenData.obtained_at = Math.floor(Date.now() / 1000);
+    await saveTokens(userData.email, tokenData);
+    consola.success("Login successful! Access token stored securely.");
+  });
+// Example usage: get a valid access token
+export async function ensureToken() {
+  const accessToken = await refreshTokenIfNeeded();
+  if (!accessToken) {
+    consola.error("Not authenticated. Please run 'login' first.");
+    process.exit(1);
+  }
+  return accessToken;
+}

package/lib/commands/modalities.js

@@ -0,0 +1,26 @@
+import { Command } from "commander";
+import { compile } from "json-schema-to-typescript";
+import * as fs from "fs";
+import * as path from "path";
+import { fetchManagementApi } from "../utils/index.js";
+export const modalitiesCommand = new Command("modalities")
+    .description("Fetch modalities and generate TypeScript interfaces")
+    .option("-o, --out <file>", "Output TypeScript file", "modalities-types.d.ts")
+    .action(async (opts) => {
+    const data = await fetchManagementApi(`models`);
+    // Generate TypeScript interfaces for each modelId
+    let output = "// Auto-generated from NLX\n// Please do not edit manually\n\n";
+    for (const item of data.items) {
+        const name = item.modelId.replace(/[^a-zA-Z0-9_]/g, "");
+        const schema = item.schema;
+        const ts = await compile(schema, name, {
+            bannerComment: "",
+            additionalProperties: false,
+        });
+        output += ts + "\n";
+    }
+    // Write to file specified by flag or default
+    const outPath = path.resolve(process.cwd(), opts.out);
+    fs.writeFileSync(outPath, output);
+    console.log(`TypeScript interfaces written to ${outPath}`);
+});

package/lib/custom-modality.js

@@ -0,0 +1,4 @@
+const foot = (f) => {
+    return Math.ceil(f.gramsCO2 ?? 0);
+};
+export {};

package/lib/index.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/index.js

@@ -6,7 +6,8 @@ import { httpCommand } from "./commands/http.js";
 import { testCommand } from "./commands/test.js";
 import { consola } from "consola";
 import { readFileSync } from "fs";
-const packageJson = JSON.parse(readFileSync("../../package.json", "utf-8"));
+import { resolve } from "path";
+const packageJson = JSON.parse(readFileSync(resolve(import.meta.dirname, "../package.json"), "utf-8"));
 program.description("Intereact with NLX from the command line");
 program
     .option("-v, --verbose", "enable verbose logging")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nlxai/cli",
-  "version": "1.2.2-alpha.6",
+  "version": "1.2.2-alpha.9",
   "description": "Tools for integrating with NLX apps",
   "keywords": [
     "NLX",
@@ -58,5 +58,5 @@
     "@vitest/ui": "^3.2.4",
     "vitest": "^3.2.4"
   },
-  "gitHead": "b69e0d6fe441fe23b7193023f34e24d6c429590e"
+  "gitHead": "690c384cd98ec1fba1811e6913c8c5a5b498bd59"
 }