ardent-cli-beta 0.0.1 → 0.0.3

package/README.md

@@ -4,14 +4,22 @@
 
 The Ardent CLI is the customer command-line client for the control-plane API.
 
-The Oclif foundation is implemented, including help, version, autocomplete, and
-native JSON command behavior. Ardent product commands, authentication, local
-context, and API requests are not implemented yet.
+The Oclif foundation and token authentication are implemented. `ardent login
+--token <token>` validates and stores an API token; `ARDENT_TOKEN` supplies the
+same flag non-interactively. `ardent status` and `ardent logout` inspect and
+remove that local session. The CLI always talks to Ardent's production control
+plane. Oclif provides help, version, autocomplete, and native JSON command
+behavior. Resource commands and resource context are not implemented yet.
+
+Set `ARDENT_API_URL` to point the CLI at a development control plane. Without
+it, the CLI uses `https://production.tryardent.com`.
 
 ```bash
 npm ci
 npm run build
 ./bin/run.js --help
+./bin/run.js login --token <token>
+ARDENT_API_URL=http://localhost:8080 ./bin/run.js login --token <token>
 ```
 
 Before changing this repository, read [ARDENT_CLI_DEVELOPMENT.md](ARDENT_CLI_DEVELOPMENT.md).

package/dist/api/client.d.ts

@@ -0,0 +1,7 @@
+export declare const API_URL: string;
+export declare class APIError extends Error {
+    readonly status: number;
+    readonly code?: string | undefined;
+    constructor(message: string, status: number, code?: string | undefined);
+}
+export declare function request<T>(token: string, path: string, init?: RequestInit): Promise<T>;

package/dist/api/client.js

@@ -0,0 +1,46 @@
+const DEFAULT_TIMEOUT_MS = 10_000;
+export const API_URL = process.env.ARDENT_API_URL || 'https://production.tryardent.com';
+export class APIError extends Error {
+    status;
+    code;
+    constructor(message, status, code) {
+        super(message);
+        this.status = status;
+        this.code = code;
+    }
+}
+export async function request(token, path, init = {}) {
+    let response;
+    try {
+        response = await fetch(new URL(path, `${API_URL}/`), {
+            ...init,
+            headers: {
+                Accept: 'application/json',
+                Authorization: `Bearer ${token}`,
+                ...(init.body === undefined ? {} : { 'Content-Type': 'application/json' }),
+                ...init.headers,
+            },
+            signal: init.signal ?? AbortSignal.timeout(DEFAULT_TIMEOUT_MS),
+        });
+    }
+    catch (error) {
+        throw new Error(`Could not reach the Ardent API: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const text = await response.text();
+    if (!response.ok) {
+        let detail = {};
+        try {
+            detail = JSON.parse(text);
+        }
+        catch {
+            // Plain-text errors still receive the status-based fallback below.
+        }
+        throw new APIError(detail.message ?? `Ardent API request failed with HTTP ${response.status}.`, response.status, detail.error);
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new Error('Ardent API returned an invalid JSON response.');
+    }
+}

package/dist/auth/credentials.d.ts

@@ -0,0 +1,6 @@
+export interface Session {
+    token: string;
+}
+export declare function loadSession(directory: string): Promise<Session | undefined>;
+export declare function saveSession(directory: string, session: Session): Promise<void>;
+export declare function clearSession(directory: string): Promise<void>;

package/dist/auth/credentials.js

@@ -0,0 +1,44 @@
+import { randomUUID } from 'node:crypto';
+import { chmod, mkdir, readFile, rename, unlink, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+const configPath = (directory) => join(directory, 'config.json');
+export async function loadSession(directory) {
+    let contents;
+    try {
+        contents = await readFile(configPath(directory), 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    }
+    try {
+        const session = JSON.parse(contents);
+        if (typeof session.token !== 'string' || session.token.length === 0)
+            throw new Error();
+        return { token: session.token };
+    }
+    catch {
+        throw new Error(`Ardent configuration at ${configPath(directory)} is invalid. Run ardent logout, then log in again.`);
+    }
+}
+export async function saveSession(directory, session) {
+    await mkdir(directory, { mode: 0o700, recursive: true });
+    await chmod(directory, 0o700);
+    const destination = configPath(directory);
+    const temporary = `${destination}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+        await writeFile(temporary, `${JSON.stringify(session, undefined, 2)}\n`, { flag: 'wx', mode: 0o600 });
+        await rename(temporary, destination);
+    }
+    catch (error) {
+        await unlink(temporary).catch(() => { });
+        throw error;
+    }
+}
+export async function clearSession(directory) {
+    await unlink(configPath(directory)).catch((error) => {
+        if (error.code !== 'ENOENT')
+            throw error;
+    });
+}

package/dist/auth/token.d.ts

@@ -0,0 +1,5 @@
+export interface Organization {
+    id: string;
+    name: string;
+}
+export declare function loginWithToken(directory: string, value: string): Promise<Organization[]>;

package/dist/auth/token.js

@@ -0,0 +1,17 @@
+import { request } from '../api/client.js';
+import { saveSession } from './credentials.js';
+export async function loginWithToken(directory, value) {
+    const token = value.trim();
+    if (!token)
+        throw new Error('Ardent API token cannot be empty.');
+    const organizations = await request(token, '/organizations');
+    if (!Array.isArray(organizations) ||
+        organizations.some((organization) => typeof organization !== 'object' ||
+            organization === null ||
+            typeof organization.id !== 'string' ||
+            typeof organization.name !== 'string')) {
+        throw new Error('Ardent API returned an invalid organization response.');
+    }
+    await saveSession(directory, { token });
+    return organizations;
+}

package/dist/commands/login.d.ts

@@ -0,0 +1,13 @@
+import { type Organization } from '../auth/token.js';
+import { ArdentCommand } from '../command.js';
+export default class Login extends ArdentCommand {
+    static description: string;
+    static helpGroup: string;
+    static flags: {
+        token: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<{
+        authenticated: true;
+        organizations: Organization[];
+    }>;
+}

package/dist/commands/login.js

@@ -0,0 +1,22 @@
+import { Flags } from '@oclif/core';
+import { loginWithToken } from '../auth/token.js';
+import { ArdentCommand } from '../command.js';
+export default class Login extends ArdentCommand {
+    static description = 'Log in to Ardent';
+    static helpGroup = 'Authentication';
+    static flags = {
+        token: Flags.string({ description: 'Existing Ardent API token', env: 'ARDENT_TOKEN', required: true }),
+    };
+    async run() {
+        const { flags } = await this.parse(Login);
+        const organizations = await loginWithToken(this.config.configDir, flags.token);
+        if (!this.jsonEnabled()) {
+            this.log('✓ Logged in to Ardent');
+            if (organizations.length === 1)
+                this.log(`  Organization: ${organizations[0].name} (${organizations[0].id})`);
+            else
+                this.log(`  Organizations: ${organizations.length}`);
+        }
+        return { authenticated: true, organizations };
+    }
+}

package/dist/commands/logout.d.ts

@@ -0,0 +1,8 @@
+import { ArdentCommand } from '../command.js';
+export default class Logout extends ArdentCommand {
+    static description: string;
+    static helpGroup: string;
+    run(): Promise<{
+        authenticated: false;
+    }>;
+}

package/dist/commands/logout.js

@@ -0,0 +1,12 @@
+import { clearSession } from '../auth/credentials.js';
+import { ArdentCommand } from '../command.js';
+export default class Logout extends ArdentCommand {
+    static description = 'Log out of Ardent on this device';
+    static helpGroup = 'Authentication';
+    async run() {
+        await clearSession(this.config.configDir);
+        if (!this.jsonEnabled())
+            this.log('✓ Logged out of Ardent');
+        return { authenticated: false };
+    }
+}

package/dist/commands/status.d.ts

@@ -0,0 +1,8 @@
+import { ArdentCommand } from '../command.js';
+export default class Status extends ArdentCommand {
+    static description: string;
+    static helpGroup: string;
+    run(): Promise<{
+        authenticated: boolean;
+    }>;
+}

package/dist/commands/status.js

@@ -0,0 +1,19 @@
+import { loadSession } from '../auth/credentials.js';
+import { ArdentCommand } from '../command.js';
+export default class Status extends ArdentCommand {
+    static description = 'Show your Ardent login status';
+    static helpGroup = 'Authentication';
+    async run() {
+        const session = await loadSession(this.config.configDir);
+        const result = { authenticated: session !== undefined };
+        if (!this.jsonEnabled()) {
+            if (session === undefined) {
+                this.log('Not logged in to Ardent');
+            }
+            else {
+                this.log('✓ Logged in to Ardent');
+            }
+        }
+        return result;
+    }
+}

package/dist/help.d.ts

@@ -0,0 +1,6 @@
+import { Help } from '@oclif/core/help';
+export default class ArdentHelp extends Help {
+    showHelp(arguments_: string[]): Promise<void>;
+    private authenticated;
+    private showArdentHelp;
+}

package/dist/help.js

@@ -0,0 +1,52 @@
+import { ux } from '@oclif/core';
+import { getHelpFlagAdditions, Help } from '@oclif/core/help';
+import { loadSession } from './auth/credentials.js';
+export default class ArdentHelp extends Help {
+    async showHelp(arguments_) {
+        const rootHelp = arguments_.every((argument) => getHelpFlagAdditions(this.config).includes(argument));
+        if (!rootHelp)
+            return super.showHelp(arguments_);
+        const authenticated = await this.authenticated();
+        if (arguments_.length > 0 || authenticated) {
+            this.showArdentHelp(authenticated);
+            return;
+        }
+        this.log('Get started:');
+        this.log('');
+        this.log(ux.colorize('green', '  ardent login                    Standard CLI login'));
+        this.log('  ardent login --token <token>    Non-interactive login (CI and automation)');
+        this.log('');
+        this.log('For all commands:');
+        this.log('');
+        this.log('  ardent --help');
+    }
+    async authenticated() {
+        try {
+            return (await loadSession(this.config.configDir)) !== undefined;
+        }
+        catch {
+            return false;
+        }
+    }
+    showArdentHelp(authenticated) {
+        this.log(`Ardent CLI ${ux.colorize('dim', `v${this.config.version}`)}`);
+        this.log('');
+        this.log(this.section('USAGE', '$ ardent <command>'));
+        const groups = new Map();
+        for (const command of this.sortedCommands) {
+            if (command.hidden || command.pluginName !== this.config.name || typeof command.helpGroup !== 'string')
+                continue;
+            const commands = groups.get(command.helpGroup) ?? [];
+            commands.push(command);
+            groups.set(command.helpGroup, commands);
+        }
+        for (const [group, commands] of groups) {
+            const rows = commands.map((command) => {
+                const name = `ardent ${command.id.replaceAll(':', ' ')}`;
+                return [!authenticated && command.id === 'login' ? ux.colorize('green', name) : name, this.summary(command)];
+            });
+            this.log('');
+            this.log(this.section(group.toUpperCase(), rows));
+        }
+    }
+}

package/oclif.manifest.json

@@ -1,4 +1,101 @@
 {
-  "commands": {},
-  "version": "0.0.1"
+  "commands": {
+    "login": {
+      "aliases": [],
+      "args": {},
+      "description": "Log in to Ardent",
+      "flags": {
+        "json": {
+          "description": "Format output as json.",
+          "helpGroup": "GLOBAL",
+          "name": "json",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "token": {
+          "description": "Existing Ardent API token",
+          "env": "ARDENT_TOKEN",
+          "name": "token",
+          "required": true,
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "login",
+      "pluginAlias": "ardent-cli-beta",
+      "pluginName": "ardent-cli-beta",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": true,
+      "helpGroup": "Authentication",
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "login.js"
+      ]
+    },
+    "logout": {
+      "aliases": [],
+      "args": {},
+      "description": "Log out of Ardent on this device",
+      "flags": {
+        "json": {
+          "description": "Format output as json.",
+          "helpGroup": "GLOBAL",
+          "name": "json",
+          "allowNo": false,
+          "type": "boolean"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "logout",
+      "pluginAlias": "ardent-cli-beta",
+      "pluginName": "ardent-cli-beta",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": true,
+      "helpGroup": "Authentication",
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "logout.js"
+      ]
+    },
+    "status": {
+      "aliases": [],
+      "args": {},
+      "description": "Show your Ardent login status",
+      "flags": {
+        "json": {
+          "description": "Format output as json.",
+          "helpGroup": "GLOBAL",
+          "name": "json",
+          "allowNo": false,
+          "type": "boolean"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "status",
+      "pluginAlias": "ardent-cli-beta",
+      "pluginName": "ardent-cli-beta",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": true,
+      "helpGroup": "Authentication",
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "status.js"
+      ]
+    }
+  },
+  "version": "0.0.3"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ardent-cli-beta",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "The Ardent command-line interface",
   "license": "Apache-2.0",
   "type": "module",
@@ -25,23 +25,23 @@
     "bin": "ardent",
     "dirname": "ardent",
     "commands": "./dist/commands",
+    "helpClass": "./dist/help",
     "plugins": [
-      "@oclif/plugin-autocomplete",
-      "@oclif/plugin-help"
+      "@oclif/plugin-autocomplete"
     ],
     "topicSeparator": " "
   },
   "scripts": {
-    "build": "tsc -b --clean && tsc -b",
+    "build": "npm run clean && tsc -b",
+    "clean": "node -e \"const {rmSync} = require('node:fs'); for (const path of ['dist', 'tsconfig.tsbuildinfo']) rmSync(path, {force: true, recursive: true})\"",
     "manifest": "oclif manifest",
     "prepack": "npm run build && npm run manifest",
-    "test": "npm run build && node --test test/*.test.js",
+    "test": "npm run build && npm run manifest && node --test \"test/**/*.test.js\"",
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
     "@oclif/core": "^5.0.0",
-    "@oclif/plugin-autocomplete": "^4.0.0",
-    "@oclif/plugin-help": "^7.0.0"
+    "@oclif/plugin-autocomplete": "^4.0.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",