@zocomputer/cli 0.0.0-stage → 0.1.0

package/dist/catalog.js

@@ -0,0 +1,193 @@
+import { defineRuntimeCatalog, SystemAPIError, } from "@zocomputer/system-api";
+import { loadNormalizedCatalog, } from "@zocomputer/system-api/catalog";
+import { canonicalNumberFromToken, JsonNumber, } from "@zocomputer/system-api/json";
+import { CliError } from "./errors.js";
+import { systemApiFailure } from "./http.js";
+const MAX_CATALOG_BYTES = 4 * 1024 * 1024;
+export function apiBaseUrl(context) {
+    return new URL("/zo-system-api/v1", context.apiOrigin).href;
+}
+function invalidCatalog(message) {
+    return new SystemAPIError({
+        code: "invalid_response",
+        message,
+        outcome: "not_started",
+    });
+}
+async function readCatalog(response) {
+    const reader = response.body?.getReader();
+    if (!reader)
+        throw invalidCatalog("The catalog response is empty.");
+    const chunks = [];
+    let size = 0;
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            size += value.byteLength;
+            if (size > MAX_CATALOG_BYTES) {
+                // Cancellation is cleanup; its failure must not hide the size error.
+                await reader.cancel().catch(() => undefined);
+                throw invalidCatalog("The catalog response exceeds the supported size.");
+            }
+            chunks.push(value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    const bytes = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return bytes;
+}
+export async function loadCatalog(context, options = {}) {
+    if (!/^wsp_[A-Za-z0-9_-]+$/.test(context.workspaceId))
+        throw new CliError("Select a workspace with zo context use <workspace-id> or --workspace.");
+    if (context.signal?.aborted)
+        throw new SystemAPIError({
+            code: "interrupted",
+            message: "Interrupted.",
+            outcome: "not_started",
+        });
+    const mode = options.catalog ?? "scoped";
+    const url = new URL(`${apiBaseUrl(context)}/catalog/export`);
+    url.searchParams.set("workspace_id", context.workspaceId);
+    url.searchParams.set("catalog", mode);
+    const token = await context.accessToken();
+    if (!/^[\x21-\x7e]+$/.test(token))
+        throw new CliError("The access token is invalid. Replace ZO_SYSTEM_API_ACCESS_TOKEN if set, or unset it and run zo login.", 3, "unauthenticated");
+    const timeout = AbortSignal.timeout(30_000);
+    const signal = context.signal
+        ? AbortSignal.any([context.signal, timeout])
+        : timeout;
+    let response;
+    let bytes;
+    try {
+        response = await (context.fetch ?? fetch)(url, {
+            headers: { authorization: `Bearer ${token}`, accept: "application/json" },
+            redirect: "error",
+            cache: "no-store",
+            signal,
+        });
+        bytes = await readCatalog(response);
+    }
+    catch (error) {
+        if (signal.aborted)
+            throw new SystemAPIError({
+                code: context.signal?.aborted
+                    ? "interrupted"
+                    : "execution_deadline_exceeded",
+                message: context.signal?.aborted
+                    ? "Interrupted."
+                    : "The catalog request deadline expired.",
+                outcome: "not_started",
+            });
+        if (error instanceof SystemAPIError)
+            throw error;
+        throw new SystemAPIError({
+            code: "network",
+            message: "Could not read the workspace catalog.",
+            outcome: "not_started",
+        });
+    }
+    if (!response.ok)
+        throw systemApiFailure(response, bytes, "Catalog discovery");
+    let catalog;
+    try {
+        catalog = loadNormalizedCatalog(bytes).catalog;
+    }
+    catch {
+        throw invalidCatalog("The service returned an invalid catalog export.");
+    }
+    if (catalog.selection?.workspace !== context.workspaceId ||
+        catalog.selection.catalog !== mode) {
+        throw invalidCatalog("The catalog selection does not match the requested workspace and catalog.");
+    }
+    return {
+        authenticatedContext: { ...context, accessToken: async () => token },
+        catalog,
+        runtimeCatalog: defineRuntimeCatalog({
+            generatorVersion: "live",
+            actions: Object.fromEntries(catalog.operations.map((operation) => [
+                operation.action,
+                {
+                    ...(operation.defaultVersion !== undefined
+                        ? { defaultVersion: operation.defaultVersion }
+                        : {}),
+                    versions: Object.fromEntries(operation.versions.map((version) => [
+                        version.version,
+                        { digest: version.digest },
+                    ])),
+                },
+            ])),
+        }),
+    };
+}
+export function parseVersion(value) {
+    if (!/^[1-9][0-9]*$/.test(value) || Number(value) > 2_147_483_647)
+        throw new CliError("--version must be a positive 32-bit integer.");
+    return Number(value);
+}
+function findAction(catalog, action) {
+    const entry = catalog.operations.find((entry) => entry.action === action);
+    if (!entry)
+        throw new CliError(`No callable contract for ${action} is visible in this catalog. Use zo actions list or zo actions describe ${action} --catalog all to inspect definitions.`, 2, "action_not_found");
+    return entry;
+}
+export function resolveAction(catalog, action, explicitVersion) {
+    const entry = findAction(catalog, action);
+    const version = explicitVersion ?? entry.defaultVersion;
+    if (version === undefined)
+        throw new CliError(`${action} has no default version. Choose --version from zo actions describe ${action}.`, 2, "version_required");
+    const contract = entry.versions.find((candidate) => candidate.version === version);
+    if (!contract)
+        throw new CliError(`${action} version ${version} is absent from this catalog. Available versions: ${entry.versions.map((item) => item.version).join(", ")}.`, 2, "unsupported_version");
+    return contract;
+}
+function number(value) {
+    return canonicalNumberFromToken(String(value));
+}
+function versionSummary(version) {
+    return {
+        version: number(version.version),
+        digest: version.digest,
+        ...(version.description !== undefined
+            ? { description: version.description }
+            : {}),
+        ...(version.availability !== undefined
+            ? { availability: version.availability }
+            : {}),
+    };
+}
+export function listActions(catalog) {
+    return catalog.operations.map((operation) => ({
+        action: operation.action,
+        default_version: operation.defaultVersion === undefined
+            ? null
+            : number(operation.defaultVersion),
+        versions: operation.versions.map(versionSummary),
+    }));
+}
+export function describeAction(catalog, action, version) {
+    const operation = findAction(catalog, action);
+    const versions = version === undefined
+        ? operation.versions
+        : [resolveAction(catalog, action, version)];
+    return {
+        action,
+        default_version: operation.defaultVersion === undefined
+            ? null
+            : number(operation.defaultVersion),
+        versions: versions.map((entry) => ({
+            ...versionSummary(entry),
+            input_schema: entry.input,
+            output_schema: entry.output,
+            ...(entry.query !== undefined ? { query_schema: entry.query } : {}),
+        })),
+    };
+}

package/dist/commands.d.ts

@@ -0,0 +1,9 @@
+import { type InvocationContext } from "./catalog.ts";
+import { type RpcResult, type RpcOptions } from "./rpc.ts";
+export declare function matchBuiltinCommand(args: readonly string[]): {
+    action: string;
+    args: string[];
+} | undefined;
+export declare function runBuiltin(context: InvocationContext, action: string, args: readonly string[], stdin?: RpcOptions["stdin"]): Promise<RpcResult>;
+export declare function builtinHelp(path?: readonly string[]): string;
+export declare function completionScript(shell: string): string;

package/dist/commands.js

@@ -0,0 +1,119 @@
+import { loadsJson, dumpsJson } from "@zocomputer/system-api/json";
+import { loadCatalog, parseVersion, resolveAction, } from "./catalog.js";
+import { CliError, safeText } from "./errors.js";
+import { encodeCommandFlags, inputFlags, parseCommandFlags, reservedOptions, resolvedSchema, scalarType, schemaObject, } from "./flags.js";
+import { commandManifest } from "./generated/commands.js";
+import { inputJson, runRpc } from "./rpc.js";
+export function matchBuiltinCommand(args) {
+    const command = commandManifest.commands.find((command) => command.path.every((segment, index) => args[index] === segment));
+    return command
+        ? { action: command.action, args: args.slice(command.path.length) }
+        : undefined;
+}
+export async function runBuiltin(context, action, args, stdin) {
+    if (!commandManifest.commands.some((command) => command.action === action))
+        throw new CliError("This action has no installed short command. Use zo rpc.");
+    const parsed = parseCommandFlags(args);
+    const versionText = parsed.values.get("version");
+    const version = versionText === undefined ? undefined : parseVersion(versionText);
+    if (parsed.values.has("input-file")) {
+        const input = await inputJson({
+            input: parsed.values.get("input"),
+            inputFile: parsed.values.get("input-file"),
+            stdin,
+            signal: context.signal,
+        });
+        parsed.values.delete("input-file");
+        parsed.values.set("input", input);
+    }
+    const loaded = await loadCatalog(context);
+    const contract = resolveAction(loaded.catalog, action, version);
+    const options = await encodeCommandFlags(parsed, contract, context.workspaceId, stdin, context.signal);
+    return runRpc(context, { action, version: contract.version, ...options }, loaded);
+}
+const invocationHelp = `
+  --input <json> | --input-file <path|->  Whole input; cannot mix with input flags
+  --version <integer>                  Select a live contract version
+  --preview                            Print request without invoking (not a server dry-run)
+  --json                               Complete result JSON
+  --envelope                           Complete success envelope
+  --workspace <id> --profile <name>     Select request context
+
+Boolean flags require true or false. Complex fields and explicit null use whole-input JSON.
+Declared workspace_id defaults to the selected workspace; a conflict is refused.
+Lists return one page; next_cursor is preserved. The CLI never retries an invocation.
+Async actions return their actual accepted/run/operation state; there is no universal --wait.
+`;
+export function builtinHelp(path = []) {
+    const commands = commandManifest.commands.filter((command) => path.every((segment, index) => command.path[index] === segment));
+    if (!commands.length)
+        throw new CliError("Unknown built-in command. Run zo --help.");
+    const command = commands.find((command) => command.path.length === path.length);
+    if (!command)
+        return `Built-in commands (installed metadata; availability is checked live)\n\n${commands.map((item) => `  zo ${item.path.join(" ")}`).join("\n")}\n\nRun a command with --help for its schema-derived flags.\n`;
+    const lines = [
+        `Usage: zo ${command.path.join(" ")} [options]`,
+        "",
+        `Action: ${command.action}`,
+        "Installed metadata only. The live catalog chooses the default version.",
+    ];
+    for (const version of command.versions) {
+        const input = loadsJson(version.inputJson);
+        lines.push("", `Version ${version.version}: ${safeText(version.description)}`, "Input flags:");
+        const flags = inputFlags(input);
+        for (const flag of flags)
+            lines.push(`  --${flag.name} <${flag.type}>${flag.required ? " (required)" : ""}${flag.field === "workspace_id" ? " (defaults to selected workspace)" : ""}${flag.choices ? `; choices: ${safeText(dumpsJson([...flag.choices]))}` : ""}${flag.description ? `  ${safeText(flag.description)}` : ""}`);
+        const properties = schemaObject(resolvedSchema(input)?.properties) ?? {};
+        const complex = Object.keys(properties).filter((field) => !flags.some((flag) => flag.field === field));
+        if (complex.length)
+            lines.push(`  Whole-input JSON fields: ${safeText(complex.join(", "))}`);
+        if ("queryJson" in version && version.queryJson) {
+            const query = loadsJson(version.queryJson);
+            const properties = schemaObject(resolvedSchema(query)?.properties) ?? {};
+            lines.push("Query options:", "  --query <json> (cannot mix with individual query options)");
+            for (const [name, schema] of Object.entries(properties)) {
+                if (["limit", "cursor", "sort", "search", "filter"].includes(name))
+                    lines.push(`  --${name} <${scalarType(schema, query) ?? "json"}>`);
+            }
+        }
+    }
+    if (command.action === "zo.function.invoke")
+        lines.push("  --idempotency-key <key>  Envelope key; repeating an invocation is never automatic.");
+    const readCommand = commandManifest.commands.find((candidate) => candidate.path.slice(0, -1).join(" ") ===
+        command.path.slice(0, -1).join(" ") && candidate.path.at(-1) === "get");
+    if (readCommand && !["get", "list"].includes(command.path.at(-1) ?? ""))
+        lines.push(`Inspect current state with zo ${readCommand.path.join(" ")} --help.`);
+    if (command.versions.some((version) => version.resultKind === "run"))
+        lines.push(`Inspect runs with zo ${command.action.startsWith("zo.workflow.") ? "workflow" : "function"} get-run --help.`);
+    return `${lines.join("\n")}\n${invocationHelp}`;
+}
+export function completionScript(shell) {
+    const words = [
+        ...new Set([
+            "login",
+            "logout",
+            "auth",
+            "context",
+            "actions",
+            "rpc",
+            "completion",
+            "status",
+            "token",
+            "list",
+            "describe",
+            "use",
+            "show",
+            ...[...reservedOptions].map((option) => `--${option}`),
+            ...commandManifest.commands.flatMap((command) => command.path),
+            ...commandManifest.commands.flatMap((command) => command.versions.flatMap((version) => inputFlags(loadsJson(version.inputJson)).map((flag) => `--${flag.name}`))),
+        ]),
+    ].sort();
+    const list = words.join(" ");
+    if (shell === "bash")
+        return `_zo_complete() { local words='${list}'; COMPREPLY=( $(compgen -W "$words" -- "\${COMP_WORDS[COMP_CWORD]}") ); }\ncomplete -F _zo_complete zo\n`;
+    if (shell === "zsh")
+        return `#compdef zo\n_zo() { local -a words; words=(${list}); _describe 'zo command or option' words; }\ncompdef _zo zo\n`;
+    if (shell === "fish")
+        return `complete -c zo -f -a '${list}'\n`;
+    throw new CliError("Completion shell must be bash, zsh or fish.");
+}

package/dist/context.d.ts

@@ -0,0 +1,15 @@
+import { AuthClient } from "./auth.ts";
+import { Profiles, type Profile } from "./profiles.ts";
+import type { Session, Workspace } from "./session.ts";
+export declare function authorizedWorkspace(session: Session, id: string): Workspace;
+export declare function useContext(profiles: Profiles, profile: Profile, auth: AuthClient, id: string, signal?: AbortSignal): Promise<Workspace>;
+export declare function contextStatus(profile: Profile, auth: AuthClient, explicit?: string, env?: NodeJS.ProcessEnv): Promise<{
+    profile: string;
+    environment: "production" | "staging";
+    issuer: string;
+    credential_kind: "sign_in" | "bearer";
+    approving_subject: import("./session.ts").Subject | null;
+    expires_at: string | null;
+    access_token_expires_at: string;
+    selected_workspace: Workspace | null;
+}>;

package/dist/context.js

@@ -0,0 +1,30 @@
+import { CliError } from "./errors.js";
+import { AuthClient } from "./auth.js";
+import { Profiles, selectedWorkspace } from "./profiles.js";
+export function authorizedWorkspace(session, id) {
+    const selected = session.workspaces.find((workspace) => workspace.workspace_id === id);
+    if (!selected)
+        throw new CliError("The selected workspace is not authorized. Run zo login to approve it or explicitly choose another workspace.", 4, "insufficient_scope");
+    return selected;
+}
+export async function useContext(profiles, profile, auth, id, signal) {
+    const selected = authorizedWorkspace(await auth.session(), id);
+    await profiles.select(profile, selected.workspace_id, signal);
+    return selected;
+}
+export async function contextStatus(profile, auth, explicit, env = process.env) {
+    const session = await auth.session();
+    const id = explicit ?? env.ZO_WORKSPACE_ID ?? profile.workspaceId;
+    return {
+        profile: profile.name,
+        environment: profile.environment,
+        issuer: auth.binding.issuer,
+        credential_kind: session.credential_kind,
+        approving_subject: session.approving_subject,
+        expires_at: session.expires_at,
+        access_token_expires_at: session.access_token_expires_at,
+        selected_workspace: id
+            ? authorizedWorkspace(session, selectedWorkspace(profile, explicit, env))
+            : null,
+    };
+}

package/dist/errors.d.ts

@@ -0,0 +1,9 @@
+export declare class CliError extends Error {
+    readonly exitCode: number;
+    readonly code: string;
+    constructor(message: string, exitCode?: number, code?: string);
+}
+export declare function throwIfInterrupted(signal?: AbortSignal | null): void;
+export declare function record(value: unknown): value is Record<string, unknown>;
+export declare function errorCode(error: unknown): string | undefined;
+export declare function safeText(text: string): string;

package/dist/errors.js

@@ -0,0 +1,25 @@
+export class CliError extends Error {
+    exitCode;
+    code;
+    constructor(message, exitCode = 2, code = "invalid_input") {
+        super(message);
+        this.exitCode = exitCode;
+        this.code = code;
+        this.name = "CliError";
+    }
+}
+export function throwIfInterrupted(signal) {
+    if (signal?.aborted)
+        throw new CliError("Interrupted.", 130, "interrupted");
+}
+export function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function errorCode(error) {
+    return record(error) && typeof error.code === "string"
+        ? error.code
+        : undefined;
+}
+export function safeText(text) {
+    return text.replace(/[\u0000-\u001f\u007f-\u009f]/g, (char) => `\\u${char.charCodeAt(0).toString(16).padStart(4, "0")}`);
+}

package/dist/flags.d.ts

@@ -0,0 +1,27 @@
+import { type JsonObject, type JsonValue } from "@zocomputer/system-api/json";
+import { type RpcOptions } from "./rpc.ts";
+export declare const reservedOptions: Set<string>;
+export type ScalarType = "string" | "boolean" | "integer" | "number";
+export interface InputFlag {
+    field: string;
+    name: string;
+    type: ScalarType;
+    required: boolean;
+    description?: string;
+    choices?: readonly JsonValue[];
+}
+export declare function schemaObject(value: JsonValue | undefined): JsonObject | undefined;
+export declare function resolvedSchema(schema: JsonValue, root?: JsonValue): JsonObject | undefined;
+export declare function scalarType(schema: JsonValue, root?: JsonValue): ScalarType | undefined;
+export declare function inputFlags(schema: JsonValue): InputFlag[];
+export declare function scalarValue(text: string, type: ScalarType, label: string): JsonValue;
+export interface ParsedFlags {
+    values: Map<string, string>;
+    preview: boolean;
+    envelope: boolean;
+}
+export declare function parseCommandFlags(args: readonly string[]): ParsedFlags;
+export declare function encodeCommandFlags(parsed: ParsedFlags, contract: {
+    input: JsonValue;
+    query?: JsonValue;
+}, workspaceId: string, stdin?: RpcOptions["stdin"], signal?: AbortSignal): Promise<Pick<RpcOptions, "input" | "query" | "idempotencyKey" | "preview">>;

package/dist/flags.js

@@ -0,0 +1,211 @@
+import { canonicalNumberFromToken, dumpsJson, JsonError, JsonNumber, } from "@zocomputer/system-api/json";
+import { CliError } from "./errors.js";
+import { inputJson, parseJsonObject } from "./rpc.js";
+export const reservedOptions = new Set([
+    "help",
+    "version",
+    "profile",
+    "workspace",
+    "json",
+    "envelope",
+    "preview",
+    "input",
+    "input-file",
+    "query",
+    "idempotency-key",
+    "limit",
+    "cursor",
+    "sort",
+    "search",
+    "filter",
+]);
+const queryOptions = new Set(["limit", "cursor", "sort", "search", "filter"]);
+export function schemaObject(value) {
+    return value !== null &&
+        typeof value === "object" &&
+        !Array.isArray(value) &&
+        !(value instanceof JsonNumber)
+        ? value
+        : undefined;
+}
+export function resolvedSchema(schema, root = schema) {
+    let object = schemaObject(schema);
+    const seen = new Set();
+    while (typeof object?.$ref === "string") {
+        const reference = object.$ref;
+        if (!reference.startsWith("#/") || seen.has(reference))
+            return undefined;
+        seen.add(reference);
+        let target = root;
+        for (const segment of reference.slice(2).split("/")) {
+            target =
+                schemaObject(target)?.[segment.replaceAll("~1", "/").replaceAll("~0", "~")];
+        }
+        const resolved = schemaObject(target);
+        if (!resolved)
+            return undefined;
+        const { $ref: _reference, ...siblings } = object;
+        object = { ...resolved, ...siblings };
+    }
+    return object;
+}
+export function scalarType(schema, root = schema) {
+    const object = resolvedSchema(schema, root);
+    if (!object || ["anyOf", "oneOf", "allOf"].some((key) => key in object))
+        return undefined;
+    const type = object.type;
+    return type === "string" ||
+        type === "boolean" ||
+        type === "integer" ||
+        type === "number"
+        ? type
+        : undefined;
+}
+export function inputFlags(schema) {
+    const object = resolvedSchema(schema);
+    const properties = schemaObject(object?.properties) ?? {};
+    const candidates = Object.entries(properties).flatMap(([field, property]) => {
+        const type = scalarType(property, schema);
+        if (!type || !/^[a-z][a-z0-9_-]*$/.test(field))
+            return [];
+        const base = field.replaceAll("_", "-");
+        const name = reservedOptions.has(base) ? `input-${base}` : base;
+        const details = resolvedSchema(property, schema);
+        return [
+            {
+                field,
+                name,
+                type,
+                required: Array.isArray(object?.required) && object.required.includes(field),
+                ...(typeof details?.description === "string"
+                    ? { description: details.description }
+                    : {}),
+                ...(Array.isArray(details?.enum) ? { choices: details.enum } : {}),
+            },
+        ];
+    });
+    // Both ambiguous spellings remain available through whole-input JSON.
+    return candidates.filter((flag) => !reservedOptions.has(flag.name) &&
+        candidates.filter((other) => other.name === flag.name).length === 1);
+}
+export function scalarValue(text, type, label) {
+    if (type === "string")
+        return text;
+    if (type === "boolean") {
+        if (text === "true")
+            return true;
+        if (text === "false")
+            return false;
+        throw new CliError(`${label} requires true or false.`);
+    }
+    if (!/^-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?$/.test(text))
+        throw new CliError(`${label} requires a JSON ${type}.`);
+    try {
+        const number = canonicalNumberFromToken(text);
+        if (type === "integer" && !number.isInteger)
+            throw new CliError(`${label} requires an integer.`);
+        return number;
+    }
+    catch (error) {
+        if (error instanceof JsonError)
+            throw new CliError(`${label} requires a supported exact ${type}.`);
+        throw error;
+    }
+}
+export function parseCommandFlags(args) {
+    const values = new Map();
+    let preview = false;
+    let envelope = false;
+    for (let index = 0; index < args.length; index++) {
+        const arg = args[index];
+        if (arg === undefined || !arg.startsWith("--"))
+            throw new CliError("Expected a named option. Run this command with --help.");
+        const equal = arg.indexOf("=");
+        const name = arg.slice(2, equal === -1 ? undefined : equal);
+        if (values.has(name))
+            throw new CliError("Repeated command option.");
+        if (name === "preview" || name === "envelope") {
+            if (equal !== -1)
+                throw new CliError(`--${name} does not take a value.`);
+            if (name === "preview")
+                preview = true;
+            else
+                envelope = true;
+            values.set(name, "");
+            continue;
+        }
+        const value = equal === -1 ? args[++index] : arg.slice(equal + 1);
+        if (value === undefined || (equal === -1 && value.startsWith("--")))
+            throw new CliError("Command option requires a value. Use --name=value for values beginning with --.");
+        values.set(name, value);
+    }
+    return { values, preview, envelope };
+}
+export async function encodeCommandFlags(parsed, contract, workspaceId, stdin, signal) {
+    const fields = inputFlags(contract.input);
+    const properties = schemaObject(resolvedSchema(contract.input)?.properties) ?? {};
+    const input = {};
+    const query = {};
+    let scalarInput = false;
+    for (const [name, text] of parsed.values) {
+        if ([
+            "input",
+            "input-file",
+            "query",
+            "idempotency-key",
+            "version",
+            "preview",
+            "envelope",
+        ].includes(name))
+            continue;
+        if (queryOptions.has(name)) {
+            const querySchema = contract.query === undefined
+                ? undefined
+                : resolvedSchema(contract.query);
+            const schema = schemaObject(querySchema?.properties)?.[name];
+            if (schema === undefined)
+                throw new CliError(`This action does not declare --${name}.`, 2, "invalid_query");
+            const type = scalarType(schema, contract.query);
+            if (type)
+                query[name] = scalarValue(text, type, `--${name}`);
+            else if (name === "filter")
+                query[name] = parseJsonObject(text, "Filter");
+            else
+                throw new CliError(`Use --query JSON for this action's ${name} option.`);
+            continue;
+        }
+        const flag = fields.find((flag) => flag.name === name);
+        if (!flag)
+            throw new CliError("Unknown input option for the selected action version. Inspect zo actions describe or use --input JSON.");
+        scalarInput = true;
+        input[flag.field] = scalarValue(text, flag.type, `--${flag.name}`);
+    }
+    const fullInput = parsed.values.has("input") || parsed.values.has("input-file");
+    if (fullInput && scalarInput)
+        throw new CliError("Use whole-input JSON or generated input flags, never both.");
+    const body = fullInput
+        ? parseJsonObject(await inputJson({
+            input: parsed.values.get("input"),
+            inputFile: parsed.values.get("input-file"),
+            stdin,
+            signal,
+        }))
+        : input;
+    if ("workspace_id" in properties) {
+        if (body.workspace_id !== undefined && body.workspace_id !== workspaceId)
+            throw new CliError("Input workspace_id conflicts with the selected workspace.");
+        body.workspace_id = workspaceId;
+    }
+    if (parsed.values.has("query") && Object.keys(query).length)
+        throw new CliError("Use --query or individual query options, never both.");
+    const queryJson = parsed.values.get("query") ??
+        (Object.keys(query).length ? dumpsJson(query) : undefined);
+    return {
+        input: dumpsJson(body),
+        ...(queryJson !== undefined ? { query: queryJson } : {}),
+        ...(parsed.values.has("idempotency-key")
+            ? { idempotencyKey: parsed.values.get("idempotency-key") }
+            : {}),
+        preview: parsed.preview,
+    };
+}

package/dist/generated/commands.d.ts

@@ -0,0 +1,23 @@
+export declare const commandManifest: {
+    schemaDigest: string;
+    commands: ({
+        action: string;
+        path: string[];
+        versions: {
+            version: number;
+            description: string;
+            inputJson: string;
+            queryJson: string;
+            resultKind: string;
+        }[];
+    } | {
+        action: string;
+        path: string[];
+        versions: {
+            version: number;
+            description: string;
+            inputJson: string;
+            resultKind: string;
+        }[];
+    })[];
+};