@metrio-ai/cli 1.0.0

package/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2025, Steven Shen <steven@jidou.ai>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,38 @@
+# @metrio-ai/cli
+
+The `metrio` command-line interface for [MetrioAI](https://metrio.ai): run prompts and workflows, and manage Metrio resources from files.
+
+```bash
+npm i -g @metrio-ai/cli
+```
+
+## Run prompts and workflows (project API key)
+
+Set `METRIOAI_API_KEY` (or `METRIO_API_KEY` / `METRIO_PROJECT_API_KEY`) in the environment or a `.env` file; `-e/--env <file>` picks another env file.
+
+```bash
+metrio chat --messages messages.json --prompt-id 7
+metrio workflow run -w my-flow --message "hello" --json
+metrio workflow run-batch -w my-flow --cases cases.jsonl
+metrio prompt run-batch -p 7 --cases cases.jsonl
+metrio prompt create-version -p 7 -f system.md
+```
+
+`metrio chat --help`, `metrio workflow --help` and `metrio prompt --help` list every option.
+
+## Manage resources (console login)
+
+```bash
+metrio login                      # browser sign-in; token stored in ~/.config/metrio/credentials.json
+metrio whoami
+metrio tools                      # every console tool your login can call
+metrio call list_prompts --args '{"project_slug":"my-project"}'
+metrio call create_workflow_version -f args.json
+metrio logout
+```
+
+For CI set `METRIO_TOKEN` (and `METRIO_CONSOLE_URL` if not `https://app.metrio.ai`). It must be an OAuth access token, valid for about 1 hour (e.g. `access_token` from `~/.config/metrio/credentials.json`), so it suits short jobs. For long-running headless use, run `metrio login` once on that machine; the stored login refreshes itself.
+
+Exit codes: `0` ok, `1` failure, `2` usage or validation error, `3` not logged in / not allowed. Codes 2 and 3 apply to the account/management commands (`login`, `logout`, `whoami`, `tools`, `call`); the run commands keep their original behavior (errors exit 1).
+
+Migrating from `@metrio-ai/client`'s bundled CLI: if the old CLI was installed globally, run `npm rm -g @metrio-ai/client` before `npm i -g @metrio-ai/cli` (both install a `metrio` bin). Every command and flag is unchanged. Bare `metrio --messages …` still works but is deprecated in favor of `metrio chat --messages …`.

package/dist/auth/credentials.js

@@ -0,0 +1,81 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CONSOLE_URL = void 0;
+exports.normalizeConsoleUrl = normalizeConsoleUrl;
+exports.credentialsPath = credentialsPath;
+exports.readCredentials = readCredentials;
+exports.writeCredentials = writeCredentials;
+exports.deleteCredentials = deleteCredentials;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+exports.DEFAULT_CONSOLE_URL = 'https://app.metrio.ai';
+function normalizeConsoleUrl(url) {
+    return url.replace(/\/+$/, '');
+}
+function credentialsPath() {
+    const dir = process.env.METRIO_CONFIG_DIR || path.join(os.homedir(), '.config', 'metrio');
+    return path.join(dir, 'credentials.json');
+}
+function readCredentials() {
+    try {
+        return JSON.parse(fs.readFileSync(credentialsPath(), 'utf8'));
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return null;
+        throw err;
+    }
+}
+function writeCredentials(creds) {
+    const file = credentialsPath();
+    fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+    // Atomic: concurrent CLI processes never observe a half-written file.
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, `${JSON.stringify(creds, null, 2)}\n`, { mode: 0o600 });
+    fs.renameSync(tmp, file);
+}
+function deleteCredentials() {
+    try {
+        fs.unlinkSync(credentialsPath());
+        return true;
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return false;
+        throw err;
+    }
+}

package/dist/auth/login.js

@@ -0,0 +1,143 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOGIN_SCOPE = void 0;
+exports.browserCommand = browserCommand;
+exports.openBrowser = openBrowser;
+exports.login = login;
+const child_process_1 = require("child_process");
+const crypto_1 = require("crypto");
+const http = __importStar(require("http"));
+const errors_1 = require("../errors");
+const credentials_1 = require("./credentials");
+const oauth_1 = require("./oauth");
+/** admin is only granted to site admins; openid lets `whoami` read /api/oauth/userinfo. */
+exports.LOGIN_SCOPE = 'read write admin openid';
+/** Never routes the URL through a shell (cmd.exe would split it at `&`). */
+function browserCommand(url, platform = process.platform) {
+    if (platform === 'darwin')
+        return ['open', [url]];
+    if (platform === 'win32')
+        return ['rundll32', ['url.dll,FileProtocolHandler', url]];
+    return ['xdg-open', [url]];
+}
+function openBrowser(url) {
+    const [cmd, args] = browserCommand(url);
+    const child = (0, child_process_1.spawn)(cmd, args, { stdio: 'ignore', detached: true });
+    child.on('error', () => undefined); // the URL is printed too, so a missing opener is fine
+    child.unref();
+}
+/** Resolves with the authorization code delivered to the loopback /callback. */
+function waitForCallback(server, state, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error('Timed out waiting for the browser login.')), timeoutMs);
+        server.on('request', (req, res) => {
+            const url = new URL(req.url ?? '/', 'http://127.0.0.1');
+            if (url.pathname !== '/callback') {
+                res.writeHead(404).end();
+                return;
+            }
+            const finish = (status, message) => res.writeHead(status, { 'Content-Type': 'text/plain; charset=utf-8' }).end(message);
+            clearTimeout(timer);
+            const error = url.searchParams.get('error');
+            if (error) {
+                finish(400, 'Metrio CLI login failed. You can close this tab.');
+                reject(new Error(`Authorization denied: ${url.searchParams.get('error_description') || error}`));
+            }
+            else if (url.searchParams.get('state') !== state) {
+                finish(400, 'Metrio CLI login failed (state mismatch). You can close this tab.');
+                reject(new Error('Login failed: state mismatch in the OAuth callback.'));
+            }
+            else {
+                finish(200, 'Metrio CLI login complete. You can close this tab.');
+                resolve(url.searchParams.get('code') ?? '');
+            }
+        });
+    });
+}
+/**
+ * Browser login against the console's OAuth server: register a client for this
+ * run's loopback port (the console matches loopback ports exactly), authorize
+ * with a random state, then exchange the code with the client secret.
+ */
+async function login(consoleUrlRaw, deps) {
+    const consoleUrl = (0, credentials_1.normalizeConsoleUrl)(consoleUrlRaw);
+    const server = http.createServer();
+    await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+    try {
+        const { port } = server.address();
+        const redirectUri = `http://127.0.0.1:${port}/callback`;
+        const regRes = await fetch(`${consoleUrl}/api/oauth/register`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                client_name: 'metrio-cli',
+                redirect_uris: [redirectUri],
+                grant_types: ['authorization_code', 'refresh_token'],
+                response_types: ['code'],
+                token_endpoint_auth_method: 'client_secret_post',
+                scope: exports.LOGIN_SCOPE,
+            }),
+        });
+        const reg = (await regRes.json().catch(() => ({})));
+        if (!regRes.ok) {
+            throw new errors_1.ConsoleApiError(reg.error_description || `Client registration failed (HTTP ${regRes.status})`, regRes.status, reg.error || 'registration_failed');
+        }
+        const state = (0, crypto_1.randomBytes)(16).toString('hex');
+        const authorize = new URL(`${consoleUrl}/api/oauth/authorize`);
+        authorize.search = new URLSearchParams({
+            response_type: 'code',
+            client_id: reg.client_id,
+            redirect_uri: redirectUri,
+            scope: exports.LOGIN_SCOPE,
+            state,
+        }).toString();
+        const code = waitForCallback(server, state, deps.timeoutMs ?? 5 * 60_000);
+        deps.log(`Opening your browser to sign in. If it does not open, visit:\n  ${authorize}\n`);
+        deps.openBrowser(authorize.toString());
+        const token = (await (0, oauth_1.postForm)(`${consoleUrl}/api/oauth/token`, {
+            grant_type: 'authorization_code',
+            code: await code,
+            redirect_uri: redirectUri,
+            client_id: reg.client_id,
+            client_secret: reg.client_secret,
+        }));
+        return (0, oauth_1.toCredentials)(consoleUrl, reg.client_id, reg.client_secret, token);
+    }
+    finally {
+        server.closeAllConnections?.();
+        server.close();
+    }
+}

package/dist/auth/oauth.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postForm = postForm;
+exports.toCredentials = toCredentials;
+exports.refreshCredentials = refreshCredentials;
+const errors_1 = require("../errors");
+const credentials_1 = require("./credentials");
+/** POSTs an x-www-form-urlencoded body (OAuth token/revoke endpoints). */
+async function postForm(url, params) {
+    const res = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        body: new URLSearchParams(params).toString(),
+    });
+    const body = (await res.json().catch(() => ({})));
+    if (!res.ok) {
+        const message = String(body.error_description ?? body.error ?? `HTTP ${res.status}`);
+        throw new errors_1.ConsoleApiError(message, res.status, String(body.error ?? 'oauth_error'));
+    }
+    return body;
+}
+function toCredentials(consoleUrl, clientId, clientSecret, token, now = Date.now()) {
+    return {
+        console_url: (0, credentials_1.normalizeConsoleUrl)(consoleUrl),
+        client_id: clientId,
+        client_secret: clientSecret,
+        access_token: token.access_token,
+        refresh_token: token.refresh_token,
+        expires_at: new Date(now + token.expires_in * 1000).toISOString(),
+        scope: token.scope ?? '',
+    };
+}
+async function refreshCredentials(creds) {
+    const token = (await postForm(`${creds.console_url}/api/oauth/token`, {
+        grant_type: 'refresh_token',
+        refresh_token: creds.refresh_token,
+        client_id: creds.client_id,
+        client_secret: creds.client_secret,
+    }));
+    return toCredentials(creds.console_url, creds.client_id, creds.client_secret, {
+        ...token,
+        scope: token.scope ?? creds.scope,
+    });
+}

package/dist/commands/auth.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runLoginCommand = runLoginCommand;
+exports.runLogoutCommand = runLogoutCommand;
+exports.runWhoamiCommand = runWhoamiCommand;
+const credentials_1 = require("../auth/credentials");
+const login_1 = require("../auth/login");
+const oauth_1 = require("../auth/oauth");
+const client_1 = require("../console/client");
+const errors_1 = require("../errors");
+const LOGIN_HELP = `metrio login - sign in to the Metrio console in your browser
+
+Usage: metrio login [--console-url <url>]
+
+  --console-url <url>  Console to sign in to (default: METRIO_CONSOLE_URL or ${credentials_1.DEFAULT_CONSOLE_URL})
+
+The login is stored in ~/.config/metrio/credentials.json (override the directory
+with METRIO_CONFIG_DIR). For CI or headless agents, set METRIO_TOKEN instead.
+`;
+async function runLoginCommand(argv, deps) {
+    let consoleUrl = process.env.METRIO_CONSOLE_URL || credentials_1.DEFAULT_CONSOLE_URL;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === '-h' || arg === '--help') {
+            process.stdout.write(LOGIN_HELP);
+            return;
+        }
+        if (arg === '--console-url' && argv[i + 1]) {
+            consoleUrl = argv[(i += 1)];
+        }
+        else {
+            throw new errors_1.CliError(`Unknown argument: ${arg}`);
+        }
+    }
+    const creds = await (0, login_1.login)(consoleUrl, deps ?? { openBrowser: login_1.openBrowser, log: (m) => process.stderr.write(m) });
+    (0, credentials_1.writeCredentials)(creds);
+    process.stdout.write(`Logged in to ${creds.console_url} (scopes: ${creds.scope})\n`);
+}
+async function runLogoutCommand(argv) {
+    if (argv.length > 0)
+        throw new errors_1.CliError(`Unknown argument: ${argv[0]}`);
+    const creds = (0, credentials_1.readCredentials)();
+    if (!creds) {
+        process.stdout.write('Not logged in.\n');
+        return;
+    }
+    // Best effort, each independently: an unreachable console must not keep tokens on disk.
+    // Revoking the refresh token also drops its access token; the access-token call covers
+    // the reverse and is harmless if already gone.
+    const revoke = (token, hint) => (0, oauth_1.postForm)(`${creds.console_url}/api/oauth/revoke`, {
+        token,
+        token_type_hint: hint,
+        client_id: creds.client_id,
+        client_secret: creds.client_secret,
+    }).catch(() => undefined);
+    await revoke(creds.refresh_token, 'refresh_token');
+    await revoke(creds.access_token, 'access_token');
+    (0, credentials_1.deleteCredentials)();
+    process.stdout.write(`Logged out of ${creds.console_url}\n`);
+}
+async function runWhoamiCommand(argv) {
+    const asJson = argv.includes('--json');
+    const unknown = argv.find((a) => a !== '--json');
+    if (unknown)
+        throw new errors_1.CliError(`Unknown argument: ${unknown}`);
+    const auth = await (0, client_1.resolveConsoleAuth)();
+    const info = (await new client_1.ConsoleClient(auth).getJson('/api/oauth/userinfo'));
+    if (asJson) {
+        process.stdout.write(`${JSON.stringify({ ...info, console_url: auth.consoleUrl }, null, 2)}\n`);
+        return;
+    }
+    const who = info.email ? `${info.name} <${info.email}>` : String(info.name ?? info.sub);
+    process.stdout.write(`${who}\nconsole: ${auth.consoleUrl}\nscopes: ${info.scope}\n`);
+}

package/dist/commands/chat.js

@@ -0,0 +1,235 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runChatCommand = runChatCommand;
+const client_1 = require("@metrio-ai/client");
+const shared_1 = require("./shared");
+const path = __importStar(require("path"));
+const HELP = `metrio - MetrioAI CLI
+
+Commands:
+  metrio chat [options]         Run a chat completion
+  metrio workflow run [options] Run a workflow completion
+                                (see: metrio workflow --help)
+  metrio prompt run-batch       Run several prompt cases in one process
+                                (see: metrio prompt --help)
+  metrio prompt create-version  Create a prompt version from a file
+
+Chat completion usage:
+  metrio chat --messages <file> [--prompt-id <id>] [options]
+
+Required:
+  -m, --messages <file>    Path to the messages JSON file
+
+Options:
+  -p, --prompt-id <id>     Prompt ID to run (integer; or set METRIO_PROMPT_ID)
+  -s, --system <text>      System message prepended as the first message
+  -e, --env <file>         Env file to load (default: .env in the current dir)
+  -t, --tag <tag>          Version tag to pin (defaults to active version)
+      --var <name=value>   Template variable (repeatable)
+      --request-tag <tag>  Request-level tag recorded on the run, e.g. "test"
+                           (repeatable; max 5; each 1-32 chars, lowercase
+                           alphanumeric start, may contain "-" and "_")
+      --timezone <tz>      IANA timezone, e.g. "Asia/Taipei"
+      --text               Print only the response text (default: full JSON)
+      --stream             Stream tokens to stderr live while running
+      --api-key <key>      API key (overrides env file / environment)
+      --base-url <url>     Base API URL (overrides env file / environment)
+  -h, --help               Show this help
+
+Environment (read from the env file or the shell; flags take precedence):
+  METRIOAI_API_KEY / METRIO_API_KEY / METRIO_PROJECT_API_KEY   API key
+  METRIO_PROMPT_ID / METRIOAI_PROMPT_ID                        Prompt ID
+  METRIOAI_BASE_URL                                            Base URL
+
+Use -e/--env to keep one env file per project (e.g. project-a.env) and run
+the same messages file against different projects for testing.
+
+Messages file format (a JSON array):
+  [
+    { "role": "system", "content": "You are a helpful assistant." },
+    { "role": "user", "content": "Describe this image", "file": "./cat.png" },
+    { "role": "user", "file": "./report.pdf" }
+  ]
+
+A message with both "content" and "file" is automatically split into two
+messages (text first, then the file) because the API allows a single content
+block per message.
+`;
+/** Parses argv into structured CLI options. Throws on malformed input. */
+function parseArgs(argv) {
+    const options = {
+        variables: [],
+        tags: [],
+        text: false,
+        stream: false,
+        help: false,
+    };
+    const next = (i, flag) => {
+        const value = argv[i + 1];
+        if (value === undefined) {
+            throw new Error(`Missing value for ${flag}`);
+        }
+        return value;
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        switch (arg) {
+            case '-p':
+            case '--prompt-id': {
+                const raw = next(i++, arg);
+                const id = Number(raw);
+                if (!Number.isInteger(id) || id <= 0) {
+                    throw new Error(`--prompt-id must be a positive integer, got "${raw}"`);
+                }
+                options.promptId = id;
+                break;
+            }
+            case '-m':
+            case '--messages':
+                options.messagesFile = next(i++, arg);
+                break;
+            case '-s':
+            case '--system':
+                options.system = next(i++, arg);
+                break;
+            case '-e':
+            case '--env':
+                options.envFile = next(i++, arg);
+                break;
+            case '-t':
+            case '--tag':
+                options.tag = next(i++, arg);
+                break;
+            case '--timezone':
+                options.timezone = next(i++, arg);
+                break;
+            case '--var': {
+                const raw = next(i++, arg);
+                const eq = raw.indexOf('=');
+                if (eq === -1) {
+                    throw new Error(`--var must be in the form name=value, got "${raw}"`);
+                }
+                const name = raw.slice(0, eq).trim();
+                if (!name) {
+                    throw new Error(`--var name cannot be empty, got "${raw}"`);
+                }
+                options.variables.push({ name, value: raw.slice(eq + 1) });
+                break;
+            }
+            case '--request-tag': {
+                const tag = next(i++, arg).trim();
+                if (!tag) {
+                    throw new Error('--request-tag cannot be empty');
+                }
+                options.tags.push(tag);
+                break;
+            }
+            case '--api-key':
+                options.apiKey = next(i++, arg);
+                break;
+            case '--base-url':
+                options.baseUrl = next(i++, arg);
+                break;
+            case '--text':
+                options.text = true;
+                break;
+            case '--stream':
+                options.stream = true;
+                break;
+            case '-h':
+            case '--help':
+                options.help = true;
+                break;
+            default:
+                throw new Error(`Unknown argument: ${arg}`);
+        }
+    }
+    return options;
+}
+/** The default command: run a chat completion. */
+async function runChatCommand(argv) {
+    const options = parseArgs(argv);
+    if (options.help) {
+        process.stdout.write(HELP);
+        return;
+    }
+    if (!options.messagesFile) {
+        throw new Error('Missing required option: --messages');
+    }
+    (0, shared_1.loadEnv)(options.envFile);
+    // Prompt ID may come from the flag or the env file; the flag wins.
+    const promptId = (0, shared_1.resolvePromptId)(options.promptId);
+    const baseDir = path.dirname(path.resolve(options.messagesFile));
+    const messages = (0, shared_1.buildMessages)((0, shared_1.readMessagesFile)(options.messagesFile), baseDir);
+    if (messages.length === 0) {
+        throw new Error('Messages file cannot be empty');
+    }
+    // A --system message is prepended as the first message in the conversation.
+    if (options.system !== undefined) {
+        const systemPrompt = options.system.trim();
+        if (systemPrompt === '') {
+            throw new Error('--system message cannot be empty');
+        }
+        messages.unshift({ role: 'system', content: { type: 'text', text: systemPrompt } });
+    }
+    const client = new client_1.MetrioAI({
+        apiKey: (0, shared_1.resolveApiKey)(options.apiKey),
+        baseUrl: (0, shared_1.resolveBaseUrl)(options.baseUrl),
+    });
+    const params = {
+        promptId,
+        messages,
+        tag: options.tag,
+        timezone: options.timezone,
+        variables: options.variables.length ? options.variables : undefined,
+        tags: options.tags.length ? options.tags : undefined,
+        stream: options.stream,
+    };
+    const response = options.stream
+        ? await client.chatCompletion(params, (chunk) => {
+            if (chunk.chunk)
+                process.stderr.write(chunk.chunk);
+        })
+        : await client.chatCompletion(params);
+    if (options.stream)
+        process.stderr.write('\n');
+    if (options.text) {
+        process.stdout.write(`${response.response}\n`);
+    }
+    else {
+        process.stdout.write(`${JSON.stringify(response, null, 2)}\n`);
+    }
+}