@noimosai/platform-cli 0.1.2 → 0.1.4

package/dist/cli/cli.js

@@ -1,177 +1,567 @@
 import { parseArgs } from "node:util";
 import { createReadStream } from "node:fs";
-import { configFromEnvironment, PlatformClient, platformToolInputSchema, platformCreateExecutionSchema, platformArtifactIdSchema, platformExecutionListQuerySchema, platformToolDiscoverySchema } from "../client/index.js";
+import { dirname } from "node:path";
+import { configFromEnvironment, PlatformClient, PLATFORM_DISTRIBUTIONS, walletAutoTopUpFromEnvironment, platformQuoteRequestSchema, platformCreateExecutionSchema, platformArtifactIdSchema, platformExecutionIdSchema, platformExecutionListQuerySchema, platformConnectionCatalogQuerySchema, toolDiscoveryInputSchema, toolResultSelectionSchema, TOOL_RESULT_PAGE_MAX_ITEMS, executionReceiptContext } from "../client/index.js";
 import { downloadArtifact } from "./download.js";
 import { commandHelp } from "./command-help.js";
+import { CliInputError, cliInputReason, isCliInputFailure, jsonOption } from "./input-error.js";
 import { uploadLocalInput } from "../client/local-input.js";
-export const help = `NoimosAI Developer Platform CLI
+import { localProfilePath, runtimeConfig } from "../client/local-profile.js";
+import { localProjectConfig } from "../client/local-projects.js";
+import { runLocalCommand } from "./setup.js";
+import { isTeamResource, teamResourceCommand } from "./team-resources.js";
+import { runWalletCommand } from "./wallet.js";
+import { PLATFORM_CLI_VERSION } from "./version.js";
+import { AgentRun, agentRunSchema, agentParallelSchema, agentResultSchema, agentResultsSchema, agentResumeSchema, resultFilesFor as resultFiles } from "../client/agent-run.js";
+import { platformTeamQuerySchema } from "../client/index.js";
+import { platformProjectStatusQuerySchema } from "../client/index.js";
+import { deactivateProjectFiles } from "./project-files.js";
+import { projectSyncFactory } from "./project-sync.js";
+import { PLATFORM_META_LIMITS, PLATFORM_TOOL_REQUEST_MAX_BYTES, platformMetaSearchSchema, platformMetaSchemasSchema, platformMetaConnectionsSchema, platformMetaExecuteSchema, platformMetaWorkbenchSchema, platformMetaBashSchema, platformIdempotencyKeySchema, platformJsonObjectSchema, withEvidentValues } from "../client/index.js";
+function metaInput(schema, input) {
+    const json = platformJsonObjectSchema.safeParse(input);
+    return json.success ? withEvidentValues(schema, json.data) : input;
+}
+const READ_OPTIONS = { path: { type: "string" }, offset: { type: "string" }, limit: { type: "string" }, "max-chars": { type: "string" }, fields: { type: "string" },
+    find: { type: "string" }, pick: { type: "string" }, wait: { type: "string" } };
+function findTerms(text) {
+    try {
+        const list = JSON.parse(text);
+        if (Array.isArray(list) && list.every(term => typeof term === "string"))
+            return list;
+    }
+    catch { }
+    return [text];
+}
+const agentRead = (values) => ({ ...(values.path === undefined ? {} : { path: jsonOption("--path", values.path) }),
+    ...(values.fields === undefined ? {} : { fields: jsonOption("--fields", values.fields) }), ...(values.offset === undefined ? {} : { offset: Number(values.offset) }),
+    ...(values.limit === undefined ? {} : { limit: Number(values.limit) }), ...(values["max-chars"] === undefined ? {} : { maxChars: Number(values["max-chars"]) }),
+    ...(values.find === undefined ? {} : { find: findTerms(values.find) }),
+    ...(values.pick === undefined ? {} : { pick: jsonOption("--pick", values.pick) }), ...(values.wait === undefined ? {} : { waitSeconds: Number(values.wait) }) });
+const missedRequestedOutput = (result) => "resultError" in result || "fileError" in result || "upstreamRefusal" in result;
+function refuseDuplicates(tokens, message) {
+    const names = tokens.filter(token => token.kind === "option").map(token => token.name);
+    if (new Set(names).size !== names.length)
+        throw new CliInputError(message);
+}
+export const help = `Relvo CLI — discover and run project tools
+
+  tools --query <capability> --limit 1 --with-schemas
+      Find a tool and its input schema in one request; add --app for a connected service.
+      Search uses monthly free calls; overage is charged.
+  run <tool> '<arguments-json>' [--maximum-charge-micros <integer>] --idempotency-key <key>
+      Quote, save the exact purchase, submit, wait and select results in one call.
+      Optional: --provider <id> --path '<path-array>' --fields '<names-array>' --find '<terms>'
+                --pick '<label-to-paths-json>' --limit <n> --wait <1-60 seconds> --file
+  resume <run-id> [--wait <seconds>]
+      Recover the same saved purchase after a lost reply; never use a fresh key for unknown work.
+  parallel ('<request-json>' | - | --input-file <path>)
+      Start independent tools together; return every admission and execution ID without waiting.
+  result <execution-id> [--path '<path-array>'] [--fields '<names-array>'] [--find '<terms>'] [--wait <1-60 seconds>] [--file]
+      Read retained data without paying for another execution. --find keeps the lines of a
+      text that hold a term. --file writes the whole path as JSON Lines under ./.relvo/results.
+  results <execution-id>... [--path '<path-array>'] [--fields '<names-array>'] [--find '<terms>'] [--wait <1-60 seconds>]
+      Read several executions at once, such as every ID parallel returned.
+  setup     Sign in and connect your installed agents.
+  project list | add | use <project-id>
+      Approve and switch projects. Add --project <id> to a tool command for one call.
+  help <command> | help all
+      Load detailed instructions only when needed.
+
+1 USD = 1000000 micros. A budget does not authorize sending, publishing or account changes.
+Scope comes from the developer API key. Provider keys remain server-side.
+Environment: RELVO_API_KEY and RELVO_API_URL, or the login saved by setup.
+Other commands: tool, quote, execute, execution, wait, executions, connections, connect,
+project, usage, doctor, logout, update, skills, team-skills, custom-tools, monitors, triggers,
+wallet, cancel, artifact-url, download, upload. Legacy NoimosAI Platform also supports access.
+`;
+export const fullHelp = `Relvo CLI
 
-Usage: noimos-platform <command>
-       noimos-platform <command> --help | help <command>
+Usage: relvo <command>
+       relvo <command> --help | help <command>
 
-  project    Show the developer organization and project bound to the API key
+  setup --api-url <url> --console-url <origin> [--client auto|claude|codex|terminal]
+        [--mcp-runtime registry|installed] [--local] [--no-browser] [--new-project]
+             Sign in through the browser and configure every installed agent
+             (Claude Code and Codex) with one approval; auto is the default
+  doctor     Verify the saved login, live catalog and owned MCP connection
+  logout     Remove the local login; revoke the server key in the console
+  update [status|auto on|auto off|pin <version>|rollback]
+             Prepare a verified CLI/MCP release for the next process start
+  skills list | skills update [--client claude|codex|all]
+             Read or explicitly update current first-party guides
+  team-skills sync [--client all|<agent>[,<agent>…]] [--project <id>] [--allow-scripts] | team-skills push <SKILL.md, folder, AGENTS.md, CLAUDE.md, agent or rule file> [--kind skill|instructions|agent|rule] [--slug <slug>]
+             Copy the team skills, agents, rules and (with --allow-scripts) hooks you may use to every coding agent, or share a local one
+  team-skills check [--client <agents>] | apply <snapshot> --yes [--client <agents>] [--allow-scripts | --remove-executable-settings]
+  team-skills auto-sync on|off|status
+             Detect project changes, ask before importing, and configure local MCP notification checks
+  team-skills list | get <slug> | versions <slug> | restore <slug> --version <n> --expected-version <n> | delete <slug>
+             Read a team skill's kept versions, restore one, or delete the skill
+  login      Alias for setup
+  wallet sign-in [--api-url <url>] [--local] [--key-file <path>] | wallet top-up --amount <usd> --max <usd> [--key-file <path>]
+             Sign in or add funds with an EVM wallet; help wallet explains each
+  access list | access set <member-id> (--tools '<json array>' | --all) [legacy NoimosAI Platform]
+             Read or change what each member may use, with a key made for it
+
+  project    Show the API key's project; list/add/use approved local projects
   usage      Show the current project's monthly request count and spend
-  tools [--query <text>] [--category <research|seo|social|generation>]
-        [--available-only] [--summary]
-             List tools and USD prices; summary omits schemas and examples
+  team [--member-offset <integer>] [--invitation-offset <integer>] [--limit <1-100>]
+             Read the selected team and your roles; owners/admins can page members and invitations
+  connections [--provider <id>] [--offset <integer>] [--limit <1-20>]
+             List project OAuth connections, states and observed grants
+  connect <app>
+             Print the console pages where you connect an app or add an account
+  tools [--query <text>] [--app <name-or-id>] [--category <id>]
+        [--provider <id>] [--available-only | --include-unavailable] [--summary | --with-schemas]
+        [--max-charge-micros <integer>] [--quote-arguments '<json>']
+        [--funding all|relvo|provider|mixed] [--price-unit <unit>] [--sort-by relevance|price_asc]
+        [--include '<filter-json>'] [--exclude '<filter-json>']
+        [--limit <1-12>] [--mode auto|keyword|semantic]
+             Search up to 12 tool summaries and USD prices (default 8)
   tool <name>
              Inspect one tool's arguments, example and price
+  meta <search|schemas|connections|execute|workbench|bash> '<request-json>'
+             Use six session-scoped meta tools; stdin/file input accepts 1 MiB
   executions [--limit <1-100>] [--before <id>] [--status <state>] [--tool <name>]
              Recover the API key's project execution history
-  quote <tool> '<arguments-json>'
+  monitors list | popular | tools | delete <id> | resume <id> [--maximum-charge-micros-per-run <n>]
+  monitors quote|create --tool <name> [--args '<json>'] [--provider <id>] [--interval 15m|1h|1d | --cron "<5 fields>" [--time-zone <IANA>]] [--name <text>] [--maximum-charge-micros-per-run <n>]
+  monitors events [--monitor <id>] [--after <cursor>] [--limit <1-100>]
+  monitors destination-add <id> --destination '<json>' | destination-remove <id> --destination-id <dst_id>
+             Watch tools for changes, each run charged in full; help monitors explains each
+  triggers list | types --app <app> [--connection <id>] [--query <text>] [--offset <n>] [--limit <1-100>] | delete <id> | update <id> [--enabled true|false] [--name <text>]
+  triggers create --connection <id> (--tool <name> [--args '<json>'] [--interval 1m|5m|15m|1h] [--items-path </json/pointer>] [--maximum-charge-micros-per-poll <n>] | --type <app.event> [--config '<json>']) [--name <text>] [--destinations '<json>']
+  triggers events [--trigger <id>] [--after <cursor>] [--limit <1-100>]
+  triggers destination-add <id> --destination '<json>' | destination-remove <id> --destination-id <dst_id>
+             Get events from a connected app; help triggers explains each
+  custom-tools list | get <name> | versions <name> | delete <name> | restore <name> --version <n> --expected-version <n>
+  custom-tools create <slug> | update <name> --expected-version <n>   (definition from - or --input-file <path>)
+             Add Python or an API endpoint as a tool for the team; help custom-tools explains each
+  quote <tool> '<arguments-json>' [--provider <id>] [--session <id>] [--relevance-check auto|light] [--maximum-charge-micros <cap>]
              Get a free quote without running the tool
+  run <tool> '<arguments-json>' [--maximum-charge-micros <integer>] --idempotency-key <key> [--provider <id>] [--session <id>]
+          [--path '<path-array>'] [--fields '<names-array>'] [--find '<terms>'] [--pick '<label-to-paths-json>'] [--limit <n>] [--offset <n>] [--max-chars <n>] [--wait <1-60>] [--file] [--accept-external-billing | --decline-external-billing]
+             Quote, save, submit and wait for already-authorized work
+  resume <run-id> [--wait <seconds>]
+             Recover the saved exact purchase; takes run's result selection, never a change to the purchase
+  parallel ('<request-json>' | - | --input-file <path>)
+             Quote, save and start up to 50 independent calls; read each accepted execution ID with result
   execute <tool> '<arguments-json>' --maximum-charge-micros <integer>
-          --price-version <version> --idempotency-key <uuid>
+          --price-version <version> --idempotency-key <key> [--provider <id>] [--session <id>] [--relevance-check auto|light] [--raw]
              Reserve up to the quoted amount and enqueue paid work
-  execution <id>
-             Read status, output and the final USD charge
-  wait <id> [--timeout <seconds>]
+  execution <id> [--raw]
+             Read status, a bounded output preview and the final USD charge
+  result <id> [--path '<JSON-array>'] [--fields '<JSON-array>'] [--offset <n>] [--limit <1-${TOOL_RESULT_PAGE_MAX_ITEMS}>] [--max-chars <1-8000>] [--find '<terms>'] [--pick '<label-to-paths-json>'] [--wait <1-60 seconds>] [--file]
+             Read a selected page of the retained full result
+  results <id>... [--path '<JSON-array>'] [--fields '<JSON-array>'] [--offset <n>] [--limit <1-${TOOL_RESULT_PAGE_MAX_ITEMS}>] [--max-chars <n>] [--find '<terms>'] [--pick '<label-to-paths-json>'] [--wait <1-60 seconds>]
+             Read the same selection of several retained results at once
+  wait <id> [--timeout <seconds>] [--raw]
              Wait for completion (default 480 seconds, maximum 900)
-  cancel <id>
+  cancel <id> [--raw]
              Request cancellation of work that has not started
   artifact-url <execution-id> <artifact-id>
              Get a private output's download URL, valid for up to 5 minutes
   download <execution-id> <artifact-id> --out <file>
              Save an artifact after size/SHA-256 checks; never overwrite a file
   upload <file>
-             Upload one explicit JPG/PNG/WAV/MP3/MP4 input, at most 12 MiB
+             Upload one explicit JPG/PNG/WebP/WAV/MP3/MP4/MOV input, at most 12 MiB
 
-Get a quote first. Use its price version and maximum charge (1 USD = 1000000
-micros). Keep the same body and idempotency key when retrying a submission.
+run quotes internally and charges the project's balance; quote separately only when
+the user asks to approve a price. execute needs a quote first: use its price version
+and maximum charge (1 USD = 1000000 micros). Keep the same body and idempotency key
+when retrying a submission.
+Auto routing is the default (--provider auto is equivalent). Use --provider to pin a provider for both quote
+and execute; tools --provider only filters discovery.
 Execution is asynchronous. Poll at intervals of at least 5 seconds.
-Use - in place of arguments-json to read JSON from stdin (at most 64 KiB).
-Use --input-file <path> in place of arguments-json to read a JSON file.
+For quote, execute, run and meta, use - in place of arguments-json to read JSON from stdin,
+or --input-file <path> to read a JSON file (at most 1 MiB).
 wait exits 0 on success, 1 on failed/cancelled/needs_review, 3 on timeout.
 A timeout leaves accepted work running; read or wait on the same execution ID.
+Large outputs stay in the execution. Use result to select data; --raw explicitly
+returns the full output for execution, wait, execute or cancel.
 
-Standalone tools only: no workspace, brand, knowledge base, dataset, connected
-provider account, post, workspace skill or chat-session commands. Scope comes
-from the developer API key; supply prompts, public URLs, project files or artifacts.
+Scope comes from the developer API key. OAuth connection IDs belong to this
+project; inspect the selected tool's schema before using one. Workspace, brand,
+knowledge base, dataset, workspace skill and chat-session commands are unavailable.
+Use --project <id> on a tool command to select an already approved login for one call.
+project list/add/use manages saved approvals; reconnect MCP after changing the default.
+Start a managed MCP pinned to one approval with mcp --profile <managed-path> --project <id>.
 
-Environment: NOIMOS_PLATFORM_API_URL, NOIMOS_PLATFORM_API_KEY
-Local emulators only: NOIMOS_PLATFORM_ENV=local
+Environment: RELVO_API_URL, RELVO_API_KEY
+Project status: relvo project status [--member-offset <n>] [--invitation-offset <n>] [--limit <1-100>]
+Local emulators only: RELVO_ENV=local
 
-Manage organizations, members, keys and billing at platform.noimosai.com.
+Manage teams, members, keys and billing in the Relvo console.
 `;
-export async function runCli(args, env, output, error, transport = fetch, stdin = process.stdin) {
+export const RELVO_CLI_SURFACE = { distribution: PLATFORM_DISTRIBUTIONS.relvo, help, fullHelp, commandHelp, supports: () => true, savedLogins: true, clientNameHeader: "x-relvo-client-name" };
+export async function runCli(args, env, output, error, transport = fetch, stdin = process.stdin, profile, surface = RELVO_CLI_SURFACE) {
+    const { cliCommand, name } = surface.distribution;
+    let projectId;
+    const projectOption = args.indexOf("--project");
+    if (projectOption !== -1) {
+        if (!surface.savedLogins) {
+            error(`${name} has no saved project logins; use the API key of the project you want. Nothing was sent.`);
+            return 2;
+        }
+        const value = args[projectOption + 1];
+        if (!value?.trim() || value.startsWith("-") || args.lastIndexOf("--project") !== projectOption) {
+            error("Provide one --project <id>. Nothing was sent.");
+            return 2;
+        }
+        projectId = value;
+        args = [...args.slice(0, projectOption), ...args.slice(projectOption + 2)];
+    }
+    if (args.length === 2 && args[0] === "help" && args[1] === "all") {
+        output(surface.fullHelp);
+        return 0;
+    }
     if (!args.length || args[0] === "--help" || args[0] === "-h" || args.length === 1 && args[0] === "help") {
-        output(help);
+        output(surface.help);
         return 0;
     }
     if (args[0] === "help" || args.slice(1).some((arg) => arg === "--help" || arg === "-h")) {
-        const detail = commandHelp(args[0] === "help" ? args[1] : args[0]);
+        const detail = surface.commandHelp(args[0] === "help" ? args[1] : args[0]);
         if (!detail || args[0] === "help" && args.length !== 2) {
-            error("Unknown help command. Run noimos-platform --help.");
+            error(`Unknown help command. Run ${cliCommand} --help.`);
             return 2;
         }
         output(detail);
         return 0;
     }
     if (args.length === 1 && args[0] === "--version") {
-        output("0.1.1");
+        output(PLATFORM_CLI_VERSION);
         return 0;
     }
+    if (!surface.supports(args)) {
+        error(`${name} does not offer this command or option. Nothing was sent. Run ${cliCommand} --help.`);
+        return 2;
+    }
     let command;
     let exitCode = 0;
     try {
-        if (["quote", "execute"].includes(args[0]) && ["-", "--input-file"].includes(args[2])) {
-            const file = args[2] === "--input-file" ? args[3] : "-";
+        const readInput = async (file, limit = PLATFORM_TOOL_REQUEST_MAX_BYTES) => {
             if (!file || file.startsWith("--"))
-                throw new Error("Provide an input file");
-            const source = file === "-" ? stdin : createReadStream(file);
+                throw new CliInputError("Provide an input file");
             const chunks = [];
             let bytes = 0;
-            for await (const chunk of source) {
+            for await (const chunk of file === "-" ? stdin : createReadStream(file)) {
                 const buffer = Buffer.from(chunk);
                 bytes += buffer.byteLength;
-                if (bytes > 65536)
-                    throw new Error("Input exceeds 64 KiB");
+                if (bytes > limit)
+                    throw new CliInputError("Input exceeds its byte limit");
                 chunks.push(buffer);
             }
-            args = [args[0], args[1], Buffer.concat(chunks).toString("utf8"), ...args.slice(args[2] === "--input-file" ? 4 : 3)];
+            return Buffer.concat(chunks).toString("utf8");
+        };
+        if (["quote", "execute", "run", "meta"].includes(args[0]) && ["-", "--input-file"].includes(args[2])) {
+            const input = await readInput(args[2] === "--input-file" ? args[3] : "-", args[0] === "meta" ? PLATFORM_META_LIMITS.requestBytes : PLATFORM_TOOL_REQUEST_MAX_BYTES);
+            args = [args[0], args[1], input, ...args.slice(args[2] === "--input-file" ? 4 : 3)];
+        }
+        if (args[0] === "parallel") {
+            if (!(args.length === 2 || args.length === 3 && args[1] === "--input-file"))
+                throw new CliInputError("Provide one parallel request as JSON, - or --input-file <path>");
+            const source = args[1], text = source === "--input-file" ? await readInput(args[2]) : source === "-" ? await readInput("-") : source;
+            const input = agentParallelSchema.parse(metaInput(agentParallelSchema, JSON.parse(text)));
+            command = async (client, config) => {
+                const result = await new AgentRun(client, env.RELVO_RUN_DIRECTORY, resultFiles(env), walletAutoTopUpFromEnvironment(env, config)).parallel(input);
+                exitCode = result.allAccepted ? 0 : 1;
+                return result;
+            };
+        }
+        else if (args.length === 3 && args[0] === "meta") {
+            const input = JSON.parse(args[2]);
+            if (args[1] === "search") {
+                const value = platformMetaSearchSchema.parse(metaInput(platformMetaSearchSchema, input));
+                command = client => client.searchMetaTools(value);
+            }
+            else if (args[1] === "schemas") {
+                const value = platformMetaSchemasSchema.parse(metaInput(platformMetaSchemasSchema, input));
+                command = client => client.getToolSchemas(value);
+            }
+            else if (args[1] === "connections") {
+                const value = platformMetaConnectionsSchema.parse(metaInput(platformMetaConnectionsSchema, input));
+                command = client => client.manageConnections(value);
+            }
+            else if (args[1] === "execute") {
+                const value = platformMetaExecuteSchema.parse(metaInput(platformMetaExecuteSchema, input));
+                command = async (client) => { const result = await client.multiExecute(value); if (!result.data.allAccepted)
+                    exitCode = 1; return result; };
+            }
+            else if (args[1] === "workbench") {
+                const value = platformMetaWorkbenchSchema.parse(metaInput(platformMetaWorkbenchSchema, input));
+                command = client => client.remoteWorkbench(value);
+            }
+            else if (args[1] === "bash") {
+                const value = platformMetaBashSchema.parse(metaInput(platformMetaBashSchema, input));
+                command = client => client.remoteBash(value);
+            }
+            else
+                throw new CliInputError("Unknown meta tool");
         }
-        if (args.length === 2 && args[0] === "upload" && args[1].trim())
+        else if (args.length === 2 && args[0] === "upload" && args[1].trim())
             command = (client) => uploadLocalInput(client, args[1]);
+        else if (args[0] === "project" && args[1] === "status") {
+            const { values, tokens } = parseArgs({ args: args.slice(2), tokens: true, options: {
+                    "member-offset": { type: "string" }, "invitation-offset": { type: "string" }, limit: { type: "string" }
+                } });
+            refuseDuplicates(tokens, "Duplicate project status option");
+            const input = platformProjectStatusQuerySchema.parse({ memberOffset: values["member-offset"], invitationOffset: values["invitation-offset"], limit: values.limit });
+            command = client => client.projectStatus(input);
+        }
+        else if (args[0] === "team") {
+            const { values, tokens } = parseArgs({ args: args.slice(1), tokens: true, options: {
+                    "member-offset": { type: "string" }, "invitation-offset": { type: "string" }, limit: { type: "string" }
+                } });
+            refuseDuplicates(tokens, "Duplicate team option");
+            const input = platformTeamQuerySchema.parse({ memberOffset: values["member-offset"], invitationOffset: values["invitation-offset"], limit: values.limit });
+            command = client => client.team(input);
+        }
         else if (args.length === 1 && args[0] === "project")
             command = (client) => client.project();
         else if (args.length === 1 && args[0] === "usage")
             command = (client) => client.usage();
+        else if (args.length === 2 && args[0] === "connect" && args[1].trim() && !args[1].startsWith("-"))
+            command = client => client.connectApp({ app: args[1] });
+        else if (args[0] === "connections") {
+            const { values, tokens } = parseArgs({ args: args.slice(1), tokens: true, options: { provider: { type: "string" }, offset: { type: "string" }, limit: { type: "string" } } });
+            refuseDuplicates(tokens, "Duplicate connection option");
+            const input = platformConnectionCatalogQuerySchema.parse({ provider: values.provider, offset: values.offset === undefined ? undefined : Number(values.offset), limit: values.limit === undefined ? undefined : Number(values.limit) });
+            command = client => client.connections(input);
+        }
         else if (args[0] === "tools") {
             const { values, tokens } = parseArgs({ args: args.slice(1), tokens: true, options: {
-                    query: { type: "string" }, category: { type: "string" }, "available-only": { type: "boolean" }, summary: { type: "boolean" },
+                    query: { type: "string" }, app: { type: "string" }, category: { type: "string" }, provider: { type: "string" }, "available-only": { type: "boolean" }, "include-unavailable": { type: "boolean" }, summary: { type: "boolean" }, "with-schemas": { type: "boolean" }, limit: { type: "string" }, mode: { type: "string" },
+                    "max-charge-micros": { type: "string" }, "quote-arguments": { type: "string" }, funding: { type: "string" }, "price-unit": { type: "string" }, "sort-by": { type: "string" },
+                    include: { type: "string" }, exclude: { type: "string" },
                 } });
-            const names = tokens.filter((token) => token.kind === "option").map((token) => token.name);
-            if (new Set(names).size !== names.length)
-                throw new Error("Duplicate discovery option");
-            const input = platformToolDiscoverySchema.parse({ query: values.query, category: values.category, availableOnly: values["available-only"], summary: values.summary });
-            command = (client) => client.discoverTools(input);
+            refuseDuplicates(tokens, "Duplicate discovery option");
+            if (values["available-only"] && values["include-unavailable"])
+                throw new CliInputError("Conflicting availability filters");
+            if (values.summary && values["with-schemas"])
+                throw new CliInputError("Conflicting schema options");
+            if (values["max-charge-micros"] !== undefined && !values["max-charge-micros"].trim())
+                throw new CliInputError("Invalid cost cap");
+            const input = toolDiscoveryInputSchema.parse({ query: values.query, app: values.app, category: values.category, provider: values.provider,
+                maxChargeMicros: values["max-charge-micros"] === undefined ? undefined : Number(values["max-charge-micros"]),
+                quoteArguments: values["quote-arguments"] === undefined ? undefined : jsonOption("--quote-arguments", values["quote-arguments"]),
+                funding: values.funding, priceUnit: values["price-unit"], sortBy: values["sort-by"],
+                include: values.include === undefined ? undefined : jsonOption("--include", values.include), exclude: values.exclude === undefined ? undefined : jsonOption("--exclude", values.exclude),
+                availableOnly: values["include-unavailable"] ? false : true, summary: !values["with-schemas"], limit: values.limit === undefined ? undefined : Number(values.limit), mode: values.mode });
+            command = (client) => client.searchTools(input);
         }
         else if (args.length === 2 && args[0] === "tool" && /^[a-z][a-z0-9_]{1,63}$/.test(args[1]))
-            command = (client) => client.tool(args[1]);
-        else if (args[0] === "executions" && args.length % 2 === 1) {
-            const flags = {};
-            for (let index = 1; index < args.length; index += 2) {
-                const name = args[index].slice(2);
-                if (!["--limit", "--before", "--status", "--tool"].includes(args[index]) || Object.hasOwn(flags, name))
-                    throw new Error("Invalid history flag");
-                flags[name] = name === "limit" ? Number(args[index + 1]) : args[index + 1];
-            }
-            const input = platformExecutionListQuerySchema.parse(flags);
+            command = (client) => client.inspectTool(args[1]);
+        else if (args[0] === "executions") {
+            const { values, tokens } = parseArgs({ args: args.slice(1), tokens: true, options: { limit: { type: "string" }, before: { type: "string" }, status: { type: "string" }, tool: { type: "string" } } });
+            refuseDuplicates(tokens, "Duplicate history option");
+            const input = platformExecutionListQuerySchema.parse({ limit: values.limit === undefined ? undefined : Number(values.limit), before: values.before, status: values.status, tool: values.tool });
             command = (client) => client.executions(input);
         }
-        else if (args[0] === "wait" && (args.length === 2 || args.length === 4 && args[2] === "--timeout") && /^[A-Za-z0-9_-]{1,128}$/.test(args[1])) {
-            const seconds = args.length === 4 ? Number(args[3]) : 480;
+        else if (args[0] === "result") {
+            const id = platformExecutionIdSchema.parse(args[1]);
+            const { values, tokens } = parseArgs({ args: args.slice(2), tokens: true, options: { ...READ_OPTIONS, file: { type: "boolean" } } });
+            refuseDuplicates(tokens, "Duplicate result option");
+            if (values.file && (values.offset !== undefined || values.limit !== undefined || values["max-chars"] !== undefined || values.find !== undefined))
+                throw new CliInputError("--file writes the whole path; omit paging options");
+            if (values.file || values.find !== undefined || values.pick !== undefined || values.wait !== undefined) {
+                const input = agentResultSchema.parse({ id, ...agentRead(values), ...(values.file ? { file: true } : {}) });
+                command = async (client) => {
+                    const result = await new AgentRun(client, env.RELVO_RUN_DIRECTORY, resultFiles(env)).result(input);
+                    exitCode = "timedOut" in result && result.timedOut ? 3 : result.status === "succeeded" && !missedRequestedOutput(result) ? 0 : 1;
+                    return result;
+                };
+            }
+            else {
+                const selection = toolResultSelectionSchema.parse({ path: values.path === undefined ? undefined : jsonOption("--path", values.path),
+                    offset: values.offset === undefined ? undefined : Number(values.offset), limit: values.limit === undefined ? undefined : Number(values.limit),
+                    maxChars: values["max-chars"] === undefined ? undefined : Number(values["max-chars"]),
+                    fields: values.fields === undefined ? undefined : jsonOption("--fields", values.fields),
+                });
+                command = async (client) => {
+                    const result = await client.readExecutionResult(id, selection);
+                    if (result.data.status && result.data.status !== "succeeded")
+                        exitCode = ["queued", "running", "waiting"].includes(result.data.status) ? 3 : 1;
+                    else if (result.data.upstreamRefusal)
+                        exitCode = 1;
+                    return result;
+                };
+            }
+        }
+        else if (args[0] === "results") {
+            const { values, positionals, tokens } = parseArgs({ args: args.slice(1), tokens: true, allowPositionals: true, options: READ_OPTIONS });
+            refuseDuplicates(tokens, "Duplicate results option");
+            const input = agentResultsSchema.parse({ ids: positionals, ...agentRead(values) });
+            command = async (client) => {
+                const reply = await new AgentRun(client, env.RELVO_RUN_DIRECTORY, resultFiles(env)).results(input);
+                const pending = reply.results.some(item => "status" in item && ["queued", "running", "waiting"].includes(String(item.status)));
+                const delivered = reply.results.every(item => "status" in item && item.status === "succeeded" && !missedRequestedOutput(item));
+                exitCode = delivered ? 0 : pending ? 3 : 1;
+                return reply;
+            };
+        }
+        else if (args[0] === "wait") {
+            const id = platformExecutionIdSchema.parse(args[1]);
+            const { values, tokens } = parseArgs({ args: args.slice(2), tokens: true, options: { timeout: { type: "string" }, raw: { type: "boolean" } } });
+            refuseDuplicates(tokens, "Duplicate wait option");
+            const seconds = values.timeout === undefined ? 480 : Number(values.timeout);
             if (!Number.isInteger(seconds) || seconds < 1 || seconds > 900)
-                throw new Error("Invalid wait timeout");
+                throw new CliInputError("Invalid wait timeout");
             command = async (client) => {
-                const result = await client.waitExecution(args[1], seconds * 1000);
-                exitCode = result.timedOut ? 3 : result.data?.status === "succeeded" ? 0 : 1;
+                const result = values.raw ? await client.waitExecution(id, seconds * 1000) : await client.waitExecutionContext(id, seconds * 1000);
+                exitCode = result.timedOut ? 3 : result.data?.status === "succeeded" && !result.data.upstreamRefusal ? 0 : 1;
                 return result;
             };
         }
-        else if (args.length === 2 && ["execution", "cancel"].includes(args[0]) && /^[A-Za-z0-9_-]{1,128}$/.test(args[1])) {
-            command = (client) => args[0] === "execution" ? client.execution(args[1]) : client.cancelExecution(args[1]);
+        else if (["execution", "cancel"].includes(args[0])) {
+            const id = platformExecutionIdSchema.parse(args[1]);
+            const { values, tokens } = parseArgs({ args: args.slice(2), tokens: true, options: { raw: { type: "boolean" } } });
+            if (tokens.length > 1)
+                throw new CliInputError("Duplicate output option");
+            command = async (client) => {
+                if (args[0] === "execution")
+                    return values.raw ? client.execution(id) : client.executionContext(id);
+                const result = await client.cancelExecution(id);
+                return values.raw ? result : executionReceiptContext(result);
+            };
         }
-        else if (args.length === 5 && args[0] === "download" && args[3] === "--out" && args[4].trim() && /^[A-Za-z0-9_-]{1,128}$/.test(args[1])) {
+        else if (args.length === 5 && args[0] === "download" && args[3] === "--out" && args[4].trim()) {
+            const id = platformExecutionIdSchema.parse(args[1]);
             const artifactId = platformArtifactIdSchema.parse(args[2]);
-            command = (client) => downloadArtifact(client, args[1], artifactId, args[4], transport);
+            command = (client) => downloadArtifact(client, id, artifactId, args[4], transport);
         }
-        else if (args.length === 3 && args[0] === "artifact-url" && /^[A-Za-z0-9_-]{1,128}$/.test(args[1])) {
+        else if (args.length === 3 && args[0] === "artifact-url") {
+            const id = platformExecutionIdSchema.parse(args[1]);
             const artifactId = platformArtifactIdSchema.parse(args[2]);
-            command = (client) => client.artifactDownload(args[1], artifactId);
+            command = (client) => client.artifactDownload(id, artifactId);
+        }
+        else if ((args[0] === "run" && args.length >= 3) || (args[0] === "resume" && args.length >= 2)) {
+            const resume = args[0] === "resume";
+            const { values, tokens } = parseArgs({ args: args.slice(resume ? 2 : 3), tokens: true, options: { ...READ_OPTIONS,
+                    "maximum-charge-micros": { type: "string" }, "idempotency-key": { type: "string" }, provider: { type: "string" }, session: { type: "string" },
+                    file: { type: "boolean" }, "accept-external-billing": { type: "boolean" }, "decline-external-billing": { type: "boolean" },
+                } });
+            refuseDuplicates(tokens, "Duplicate run option");
+            if (values["accept-external-billing"] && values["decline-external-billing"])
+                throw new CliInputError("Conflicting external billing options");
+            const { waitSeconds, pick, ...selection } = agentRead(values);
+            const view = { waitSeconds, pick, file: values.file, selection };
+            if (resume) {
+                if (values["maximum-charge-micros"] || values["idempotency-key"] || values.provider || values.session || values["accept-external-billing"] || values["decline-external-billing"])
+                    throw new CliInputError("Resume retains the original purchase");
+                const input = agentResumeSchema.parse({ runId: args[1], ...view });
+                command = async (client, config) => {
+                    const result = await new AgentRun(client, env.RELVO_RUN_DIRECTORY, resultFiles(env), walletAutoTopUpFromEnvironment(env, config)).resume(input);
+                    exitCode = "timedOut" in result && result.timedOut ? 3 : result.status === "succeeded" && !missedRequestedOutput(result) ? 0 : 1;
+                    return result;
+                };
+            }
+            else {
+                const maximum = values["maximum-charge-micros"];
+                if (maximum !== undefined && !/^\d+$/.test(maximum))
+                    throw new CliInputError("Invalid run ceiling");
+                const input = agentRunSchema.parse({ tool: args[1], arguments: jsonOption("<arguments-json>", args[2]), ...(maximum === undefined ? {} : { maximumChargeMicros: Number(maximum) }),
+                    idempotencyKey: values["idempotency-key"], provider: values.provider, sessionId: values.session,
+                    ...(values["decline-external-billing"] ? { externalBillingAccepted: false } : {}), ...view });
+                command = async (client, config) => {
+                    const result = await new AgentRun(client, env.RELVO_RUN_DIRECTORY, resultFiles(env), walletAutoTopUpFromEnvironment(env, config)).run(input);
+                    exitCode = "status" in result ? result.timedOut ? 3 : result.status === "succeeded" && !missedRequestedOutput(result) ? 0 : 1 : 1;
+                    return result;
+                };
+            }
         }
-        else if (args.length === 3 && args[0] === "quote") {
-            const input = platformToolInputSchema.parse({ tool: args[1], arguments: JSON.parse(args[2]) });
+        else if (args.length >= 3 && args[0] === "quote") {
+            const { values, tokens } = parseArgs({ args: args.slice(3), tokens: true, options: { provider: { type: "string" }, session: { type: "string" },
+                    "relevance-check": { type: "string" }, "maximum-charge-micros": { type: "string" } } });
+            refuseDuplicates(tokens, "Duplicate quote option");
+            const maximum = values["maximum-charge-micros"];
+            if (maximum !== undefined && !/^\d+$/.test(maximum))
+                throw new CliInputError("Invalid quote cap");
+            const input = platformQuoteRequestSchema.parse({ tool: args[1], arguments: jsonOption("<arguments-json>", args[2]), sessionId: values.session, ...(values.provider === undefined ? {} : { provider: values.provider }),
+                ...(values["relevance-check"] === undefined ? {} : { relevanceCheck: values["relevance-check"] }), ...(maximum === undefined ? {} : { maximumChargeMicros: Number(maximum) }) });
             command = (client) => client.quote(input);
         }
-        else if (args.length === 9 && args[0] === "execute") {
-            const flags = new Map();
-            for (let index = 3; index < args.length; index += 2) {
-                if (!["--maximum-charge-micros", "--price-version", "--idempotency-key"].includes(args[index]) || flags.has(args[index]))
-                    throw new Error("Invalid flag");
-                flags.set(args[index], args[index + 1]);
-            }
-            const maximum = flags.get("--maximum-charge-micros"), idempotencyKey = flags.get("--idempotency-key");
-            if (!maximum || !/^\d+$/.test(maximum) || !idempotencyKey || !/^[A-Za-z0-9._:-]{8,128}$/.test(idempotencyKey))
-                throw new Error("Invalid execution confirmation");
-            const input = platformCreateExecutionSchema.parse({ tool: args[1], arguments: JSON.parse(args[2]), maximumChargeMicros: Number(maximum), priceVersion: flags.get("--price-version") });
-            command = (client) => client.createExecution(input, idempotencyKey);
+        else if (args.length >= 3 && args[0] === "execute") {
+            const { values, tokens } = parseArgs({ args: args.slice(3), tokens: true, options: {
+                    "maximum-charge-micros": { type: "string" }, "price-version": { type: "string" }, "idempotency-key": { type: "string" }, provider: { type: "string" }, session: { type: "string" }, raw: { type: "boolean" },
+                    "relevance-check": { type: "string" },
+                } });
+            refuseDuplicates(tokens, "Duplicate execution option");
+            const maximum = values["maximum-charge-micros"], idempotencyKey = values["idempotency-key"];
+            if (!maximum || !/^\d+$/.test(maximum) || !idempotencyKey || !platformIdempotencyKeySchema.safeParse(idempotencyKey).success)
+                throw new CliInputError("Invalid execution confirmation");
+            const input = platformCreateExecutionSchema.parse({ tool: args[1], arguments: jsonOption("<arguments-json>", args[2]), sessionId: values.session, maximumChargeMicros: Number(maximum), priceVersion: values["price-version"], ...(values.provider === undefined ? {} : { provider: values.provider }),
+                ...(values["relevance-check"] === undefined ? {} : { relevanceCheck: values["relevance-check"] }) });
+            command = async (client) => {
+                const result = await client.createExecution(input, idempotencyKey);
+                return values.raw ? result : executionReceiptContext(result);
+            };
         }
+        else if (isTeamResource(args[0]))
+            command = await teamResourceCommand(args, source => readInput(source));
         else
-            throw new Error("Invalid command");
+            throw new CliInputError("Invalid command");
     }
-    catch {
-        error(`Invalid command, JSON arguments or input file.\n\n${commandHelp(args[0]) ?? help}`);
+    catch (failure) {
+        error(`${cliInputReason(failure)}. Nothing was sent. Run ${cliCommand} ${surface.commandHelp(args[0]) ? `help ${args[0]}` : "--help"}.`);
         return 2;
     }
     try {
-        const client = new PlatformClient(configFromEnvironment(env, "cli"), transport);
-        const result = await command(client);
-        output(JSON.stringify(result, null, 2));
+        if (projectId && !profile)
+            throw new Error(`--project needs a saved login. Run ${cliCommand} setup first.`);
+        const config = projectId && profile ? await localProjectConfig(profile, projectId, env, "cli", transport)
+            : profile ? await runtimeConfig(env, "cli", profile) : configFromEnvironment(env, "cli", surface.distribution);
+        const header = surface.clientNameHeader, client = env.CLAUDECODE === "1" ? "claude-code" : `${cliCommand}-cli`;
+        const result = await command(new PlatformClient(config, header ? (input, init) => transport(input, { ...init, headers: { ...init?.headers, [header]: client } }) : transport), config);
+        output(JSON.stringify(result));
         return exitCode;
     }
     catch (failure) {
-        error(failure instanceof Error ? failure.message : "Platform request failed.");
+        error(failure instanceof Error ? failure.message : `${name} request failed.`);
         return 1;
     }
 }
+export async function runRelvoCli(args, env, output, error, transport = fetch, stdin = process.stdin, options = {}) {
+    if (args[0] === "mcp") {
+        try {
+            const { values } = parseArgs({ args: args.slice(1), options: { profile: { type: "string" }, mode: { type: "string" }, project: { type: "string" } } });
+            if (!values.profile)
+                throw new Error("relvo mcp requires the managed --profile path.");
+            const { startPlatformMcp } = await import("../mcp/runtime.js");
+            const profileHome = dirname(dirname(dirname(values.profile)));
+            await startPlatformMcp(options.version, values.profile, values.mode, values.project, id => deactivateProjectFiles(id, env, profileHome), projectSyncFactory(env, profileHome));
+            return process.exitCode ? 1 : 0;
+        }
+        catch {
+            error("Relvo MCP could not start. Run relvo doctor to inspect the managed connection.");
+            return 1;
+        }
+    }
+    const localFailure = (failure, fallback) => {
+        if (!isCliInputFailure(failure)) {
+            error(failure instanceof Error ? failure.message : fallback);
+            return 1;
+        }
+        error(`${cliInputReason(failure).replace(/\.$/u, "")}. Nothing was changed. Run relvo help ${args[0]}.`);
+        return 2;
+    };
+    if (args[0] === "wallet" && !args.some((arg) => ["--help", "-h"].includes(arg))) {
+        try {
+            await runWalletCommand(args, env, output, transport, options);
+            return 0;
+        }
+        catch (failure) {
+            return localFailure(failure, "Relvo wallet command failed.");
+        }
+    }
+    const local = ["setup", "login", "doctor", "logout", "skills"].includes(args[0]) || args[0] === "team-skills" && ["sync", "push", "check", "apply", "dismiss", "auto-sync"].includes(args[1]) || args[0] === "project" && ["list", "add", "use"].includes(args[1]);
+    if (local && !args.some((arg) => ["--help", "-h"].includes(arg))) {
+        try {
+            await runLocalCommand(args, env, output, transport, options);
+            return 0;
+        }
+        catch (failure) {
+            return localFailure(failure, "Relvo local setup failed.");
+        }
+    }
+    return runCli(args, env, output, error, transport, stdin, localProfilePath(options.home));
+}