@metrio-ai/cli 1.0.0

package/dist/console/client.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleClient = exports.ConsoleApiError = void 0;
+exports.resolveConsoleAuth = resolveConsoleAuth;
+const credentials_1 = require("../auth/credentials");
+const oauth_1 = require("../auth/oauth");
+const errors_1 = require("../errors");
+Object.defineProperty(exports, "ConsoleApiError", { enumerable: true, get: function () { return errors_1.ConsoleApiError; } });
+/** Refresh this long before expiry so a request never starts with a dying token. */
+const EXPIRY_SKEW_MS = 60_000;
+/** After a failed refresh, how long to wait for a concurrent process to persist its rotated credentials. */
+const ROTATION_READ_ATTEMPTS = 5;
+const ROTATION_READ_DELAY_MS = 200;
+/**
+ * METRIO_TOKEN (+ METRIO_CONSOLE_URL) wins over the stored login and is used
+ * as-is. Otherwise the stored login is used, refreshed first if it is about to
+ * expire.
+ */
+async function resolveConsoleAuth() {
+    const envToken = process.env.METRIO_TOKEN;
+    if (envToken) {
+        // Env path never reads the credentials file: a stored login may point elsewhere.
+        return {
+            consoleUrl: (0, credentials_1.normalizeConsoleUrl)(process.env.METRIO_CONSOLE_URL || credentials_1.DEFAULT_CONSOLE_URL),
+            token: envToken,
+        };
+    }
+    const stored = (0, credentials_1.readCredentials)();
+    if (!stored) {
+        throw new errors_1.CliError('Not logged in. Run "metrio login" (or set METRIO_TOKEN).', 3);
+    }
+    let current = stored;
+    const refresh = async () => {
+        try {
+            current = await (0, oauth_1.refreshCredentials)(current);
+        }
+        catch (err) {
+            if (err instanceof errors_1.ConsoleApiError) {
+                // Refresh tokens rotate: another process may have already refreshed, but
+                // it may not have persisted the new pair yet, so re-read briefly.
+                for (let attempt = 0; attempt < ROTATION_READ_ATTEMPTS; attempt++) {
+                    if (attempt > 0)
+                        await new Promise((r) => setTimeout(r, ROTATION_READ_DELAY_MS));
+                    const latest = (0, credentials_1.readCredentials)();
+                    if (latest &&
+                        latest.refresh_token !== current.refresh_token &&
+                        latest.console_url === current.console_url) {
+                        current = latest;
+                        return current.access_token;
+                    }
+                }
+                throw new errors_1.CliError('Session expired or revoked. Run "metrio login".', 3);
+            }
+            throw err;
+        }
+        (0, credentials_1.writeCredentials)(current);
+        return current.access_token;
+    };
+    if (Date.parse(current.expires_at) - EXPIRY_SKEW_MS <= Date.now()) {
+        await refresh();
+    }
+    return { consoleUrl: current.console_url, token: current.access_token, refresh };
+}
+class ConsoleClient {
+    auth;
+    constructor(auth) {
+        this.auth = auth;
+    }
+    async listTools() {
+        return (await this.request('GET', '/api/v1/tools'));
+    }
+    async callTool(name, args) {
+        return this.request('POST', `/api/v1/tools/${encodeURIComponent(name)}`, args ?? {});
+    }
+    /** GET a console endpoint that answers with a bare JSON body (e.g. /api/oauth/userinfo). */
+    async getJson(path) {
+        return this.send('GET', path, undefined, true);
+    }
+    async request(method, path, body) {
+        const json = (await this.send(method, path, body, true));
+        return json.data;
+    }
+    async send(method, path, body, retryOn401) {
+        const res = await fetch(`${this.auth.consoleUrl}${path}`, {
+            method,
+            headers: {
+                Authorization: `Bearer ${this.auth.token}`,
+                ...(body === undefined ? {} : { 'Content-Type': 'application/json' }),
+            },
+            body: body === undefined ? undefined : JSON.stringify(body),
+        });
+        if (res.status === 401 && retryOn401 && this.auth.refresh) {
+            this.auth.token = await this.auth.refresh();
+            return this.send(method, path, body, false);
+        }
+        const json = (await res.json().catch(() => ({})));
+        if (!res.ok) {
+            const error = (json.error ?? {});
+            const message = typeof json.error === 'string'
+                ? String(json.error_description ?? json.error)
+                : String(error.message ?? `HTTP ${res.status}`);
+            const code = typeof json.error === 'string' ? json.error : String(error.code ?? 'http_error');
+            throw new errors_1.ConsoleApiError(message, res.status, code, error.issues);
+        }
+        return json;
+    }
+}
+exports.ConsoleClient = ConsoleClient;

package/dist/errors.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleApiError = exports.CliError = void 0;
+/** A user-facing CLI error with the process exit code it should produce. */
+class CliError extends Error {
+    exitCode;
+    constructor(message, exitCode = 2) {
+        super(message);
+        this.exitCode = exitCode;
+        this.name = 'CliError';
+    }
+}
+exports.CliError = CliError;
+/** A non-2xx answer from the console (REST or OAuth endpoints). */
+class ConsoleApiError extends Error {
+    status;
+    code;
+    details;
+    constructor(message, status, code, details) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.details = details;
+        this.name = 'ConsoleApiError';
+    }
+}
+exports.ConsoleApiError = ConsoleApiError;

package/dist/index.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HELP = void 0;
+exports.main = main;
+exports.reportError = reportError;
+/**
+ * metrio — the MetrioAI CLI.
+ *
+ * Execution commands (chat, workflow run, run-batch) call the MetrioAI API with
+ * a project API key. Management commands (tools, call) call the console's
+ * /api/v1/tools REST with an OAuth token from `metrio login`.
+ */
+const client_1 = require("@metrio-ai/client");
+const errors_1 = require("./errors");
+const auth_1 = require("./commands/auth");
+const chat_1 = require("./commands/chat");
+const prompt_1 = require("./commands/prompt");
+const workflow_1 = require("./commands/workflow");
+const tools_1 = require("./commands/tools");
+exports.HELP = `metrio - MetrioAI CLI
+
+Usage: metrio <command> [options]
+
+Run (project API key, see "metrio chat --help"):
+  chat                  Run a chat completion
+  workflow run          Run a workflow completion (metrio workflow --help)
+  workflow run-batch    Run several workflow cases in one process
+  prompt run-batch      Run several prompt cases in one process (metrio prompt --help)
+  prompt create-version Create a prompt version from a file
+
+Account (console OAuth):
+  login                 Sign in to the Metrio console in your browser
+  logout                Revoke and delete the stored login
+  whoami                Show the signed-in user and scopes
+
+Manage (console OAuth):
+  tools                 List the console tools your login can call
+  call <tool>           Call a console tool with JSON args (-f file | --args json)
+
+  -h, --help            Show this help
+  -v, --version         Show the CLI version
+`;
+async function main(argv) {
+    const [command] = argv;
+    switch (command) {
+        case undefined:
+        case '-h':
+        case '--help':
+            process.stdout.write(exports.HELP);
+            return;
+        case '-v':
+        case '--version':
+            process.stdout.write(`${require('../package.json').version}\n`);
+            return;
+        case 'chat':
+            return (0, chat_1.runChatCommand)(argv.slice(1));
+        case 'workflow':
+            return (0, workflow_1.runWorkflowCommand)(argv.slice(1));
+        case 'prompt':
+            return (0, prompt_1.runPromptCommand)(argv.slice(1));
+        case 'login':
+            return (0, auth_1.runLoginCommand)(argv.slice(1));
+        case 'logout':
+            return (0, auth_1.runLogoutCommand)(argv.slice(1));
+        case 'whoami':
+            return (0, auth_1.runWhoamiCommand)(argv.slice(1));
+        case 'tools':
+            return (0, tools_1.runToolsCommand)(argv.slice(1));
+        case 'call':
+            return (0, tools_1.runCallCommand)(argv.slice(1));
+        default:
+            if (command.startsWith('-')) {
+                process.stderr.write('metrio: running chat without a subcommand is deprecated; use "metrio chat".\n');
+                return (0, chat_1.runChatCommand)(argv);
+            }
+            throw new errors_1.CliError(`Unknown command: ${command}. Run "metrio --help".`);
+    }
+}
+/** Writes a friendly message for `err` to stderr and returns the exit code. */
+function reportError(err) {
+    if (err instanceof client_1.MetrioApiError) {
+        process.stderr.write(`MetrioAI API error: ${err.message}\n`);
+        if (err.responseData) {
+            process.stderr.write(`${JSON.stringify(err.responseData, null, 2)}\n`);
+        }
+        return 1;
+    }
+    if (err instanceof errors_1.ConsoleApiError) {
+        process.stderr.write(`Metrio console error (${err.status} ${err.code}): ${err.message}\n`);
+        if (err.details)
+            process.stderr.write(`${JSON.stringify(err.details, null, 2)}\n`);
+        if (err.status === 401 || err.status === 403)
+            return 3;
+        return err.status === 400 ? 2 : 1;
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`Error: ${message}\n`);
+    return err instanceof errors_1.CliError ? err.exitCode : 1;
+}
+if (require.main === module) {
+    main(process.argv.slice(2)).catch((err) => {
+        process.exit(reportError(err));
+    });
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@metrio-ai/cli",
+  "version": "1.0.0",
+  "packageManager": "yarn@4.14.1",
+  "description": "Metrio AI command-line interface: run prompts and workflows, manage Metrio resources",
+  "bin": {
+    "metrio": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "jest",
+    "prepublishOnly": "yarn build"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "author": "Steven Shen <steven@jidou.ai>",
+  "license": "BSD-3-Clause",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/JidouAI/metrioai-backend.git",
+    "directory": "packages/cli"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@metrio-ai/client": "^1.5.2"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "@types/node": "^20.10.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.5",
+    "typescript": "^5.6.3"
+  }
+}