@nlxai/cli 1.2.2-alpha.5 → 1.2.2-alpha.8

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

@@ -10,6 +10,15 @@ async function saveTokens(account, tokenData) {
     await keytar.setPassword("nlx-cli", account, JSON.stringify(tokenData));
 }
 async function loadTokens() {
+    if (process.env.NLX_ACCESS_TOKEN) {
+        try {
+            console.log("Using access token from NLX_ACCESS_TOKEN environment variable");
+            return JSON.parse(atob(process.env.NLX_ACCESS_TOKEN));
+        }
+        catch (error) {
+            consola.error("Failed to parse NLX_ACCESS_TOKEN:", error);
+        }
+    }
     try {
         const data = fs.readFileSync(ACCOUNTS_PATH, "utf8");
         const accounts = JSON.parse(data);
@@ -68,7 +77,8 @@ const CLIENT_ID = process.env.AUTH0_CLIENT_ID || "A0qluq7wJQjFjMLle9pvrWWaVHM1QH
 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 () => {
+    .option("--print-token", "Print the access token after login (useful for CI)")
+    .action(async (opts) => {
     // Step 1: Start device flow
     const deviceCodeRes = await fetch(`https://${AUTH0_DOMAIN}/oauth/device/code`, {
         method: "POST",
@@ -132,6 +142,9 @@ export const loginCommand = new Command("login")
     // Step 4: Store token securely
     tokenData.obtained_at = Math.floor(Date.now() / 1000);
     await saveTokens(userData.email, tokenData);
+    if (opts.printToken) {
+        console.log("Access token", btoa(JSON.stringify([userData.email, tokenData])));
+    }
     consola.success("Login successful! Access token stored securely.");
 });
 // Example usage: get a valid access token

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,145 @@
+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";
+import keytar from "keytar";
+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/commands/test.js

@@ -22,7 +22,7 @@ export const testCommand = new Command("test")
         let { tests } = (await fetchManagementApi(`bots/${applicationId}/conversationTests`, "GET"));
         if (opts.onlyExecuteAtBuild) {
             let total = tests.length;
-            tests = tests.filter((test) => test.runAtBuild);
+            tests = tests.filter((test) => test.executeAtBuild);
             if (tests.length === 0) {
                 consola.error("No tests found.");
                 process.exit(1);

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

@@ -5,15 +5,19 @@ import { dataRequestsCommand } from "./commands/data-requests/index.js";
 import { httpCommand } from "./commands/http.js";
 import { testCommand } from "./commands/test.js";
 import { consola } from "consola";
+import { readFileSync } from "fs";
+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")
+    .option("-v, --verbose", "enable verbose logging")
     .hook("preAction", (thisCommand) => {
     if (thisCommand.opts().verbose) {
         consola.level = 4; // Debug level
     }
 });
 program.configureHelp({ showGlobalOptions: true });
+program.version(packageJson.version);
 program.addCommand(authCommand);
 program.addCommand(modalitiesCommand);
 program.addCommand(dataRequestsCommand);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nlxai/cli",
-  "version": "1.2.2-alpha.5",
+  "version": "1.2.2-alpha.8",
   "description": "Tools for integrating with NLX apps",
   "keywords": [
     "NLX",
@@ -58,5 +58,5 @@
     "@vitest/ui": "^3.2.4",
     "vitest": "^3.2.4"
   },
-  "gitHead": "4b5deca0d624501a62eb849646b05fca1fe4d84d"
+  "gitHead": "2829feb4c0a570906493c8f6d8671b14886d705c"
 }