@reasonlayer/sdk 0.0.1

package/dist/cli/index.js

@@ -0,0 +1,721 @@
+import { randomBytes } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { isTerminalRunStatus } from "@reasonlayer/protocol";
+import { hasFlag, numberFlag, parseCliArgs, stringFlag } from "./args.js";
+import { clearLogin, loadConfig, resolvedConvexUrl, resolvedTargetLabel, saveLogin, TOKEN_ONBOARDING_HINT, } from "./config.js";
+import { formatCompileErrors, formatInspect, formatVariableList, jsonText, parseVariableValue, } from "./format.js";
+import { buildProject, createOperationRuntime, operationForSurfaceByName, runOperation, validateWorkflow, } from "./operations.js";
+import { sdkProvenance } from "./sdk-package.js";
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}
+async function parseInputJson(raw) {
+    if (raw === undefined)
+        return {};
+    if (raw === "-")
+        return JSON.parse(await readStdin());
+    if (raw.startsWith("@"))
+        return JSON.parse(await readFile(raw.slice(1), "utf8"));
+    return JSON.parse(raw);
+}
+function output(value, asJson, plain) {
+    process.stdout.write(asJson ? jsonText(value) : (plain ?? jsonText(value)));
+}
+function cliOperation(name) {
+    const operation = operationForSurfaceByName("cli", name);
+    if (!operation)
+        throw new Error(`CLI operation "${name}" is not declared`);
+    return operation;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function requirePositional(positionals, index, label) {
+    const value = positionals[index];
+    if (!value)
+        throw new Error(`missing ${label}`);
+    return value;
+}
+function commaSeparatedFlag(parsed, name) {
+    const raw = stringFlag(parsed, name);
+    if (!raw)
+        return undefined;
+    return raw.split(",").map((value) => value.trim()).filter(Boolean);
+}
+function rejectConvexUrlFlag(parsed) {
+    if (Object.hasOwn(parsed.flags, "convex-url")) {
+        throw new Error("--convex-url is not supported; set RL_CONVEX_URL to target a non-production deployment");
+    }
+}
+async function commandLogin(parsed, asJson) {
+    const convexUrl = resolvedConvexUrl();
+    const target = resolvedTargetLabel();
+    const bootstrap = hasFlag(parsed, "bootstrap");
+    const explicitToken = stringFlag(parsed, "token") ?? process.env["RL_TOKEN"];
+    let token;
+    let account = {};
+    if (bootstrap) {
+        // Dev-only self-provisioning: mint a bootstrap root token, create the org below.
+        token = explicitToken ?? `rl_${randomBytes(24).toString("hex")}`;
+    }
+    else if (explicitToken) {
+        token = explicitToken;
+    }
+    else {
+        throw new Error(`Browser login is not available yet. ${TOKEN_ONBOARDING_HINT}`);
+    }
+    const runtime = createOperationRuntime({ convexUrl, token });
+    if (bootstrap) {
+        await runOperation(cliOperation("bootstrap_dev_org"), { runtime }, {
+            name: stringFlag(parsed, "org") ?? "Reasonlayer Dev",
+        });
+    }
+    const identity = await identifyOrg({ runtime });
+    if (account.orgId === undefined)
+        account = { ...account, orgId: identity.orgId };
+    const saved = await saveLogin(convexUrl, token, account);
+    const result = { ...identity, convexUrl, target, configPath: saved.configPath };
+    output(result, asJson, `Logged in to ${convexUrl} (${target}) as ${identity.name} (${identity.orgId})\nToken stored in the OS keychain\nConfig: ${saved.configPath}\n`);
+}
+async function identifyOrg(ctx) {
+    return await runOperation(cliOperation("whoami"), ctx, {});
+}
+async function commandLogout(asJson) {
+    const cleared = await clearLogin(resolvedConvexUrl());
+    output(cleared, asJson, cleared.convexUrl ? `Logged out of ${cleared.convexUrl}\n` : "No stored login found\n");
+}
+async function commandWhoami(asJson) {
+    const config = await loadConfig();
+    const result = await identifyOrg({ runtime: createOperationRuntime(config) });
+    const provenance = await sdkProvenance();
+    const target = { convexUrl: config.convexUrl, label: resolvedTargetLabel() };
+    output({ ...result, cli: provenance, target }, asJson, `${provenance.label}\nTarget: ${target.convexUrl} (${target.label})\n${result.name} (${result.orgId})\n`);
+}
+async function commandValidate(parsed, asJson) {
+    const result = (await runOperation(cliOperation("validate"), {}, { workflow: requirePositional(parsed.positionals, 0, "workflow path") }));
+    output(result, asJson, result.ok ? `Valid workflow ${result.manifest.workflowId}\n` : `${formatCompileErrors(result)}\n`);
+    return result.ok ? 0 : 1;
+}
+async function commandBuild(parsed, asJson) {
+    const entry = requirePositional(parsed.positionals, 0, "workflow path");
+    const outDir = stringFlag(parsed, "out-dir") ?? "dist";
+    const result = (await runOperation(cliOperation("build"), {}, { workflow: entry, outDir }));
+    if (!result.ok) {
+        if (asJson)
+            output(result, true);
+        else
+            process.stderr.write(`${formatCompileErrors(result)}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    output(result, asJson, `Built ${result.manifest.workflowId} to ${result.outDir}\nCode steps: ${result.manifest.codeStepIds.join(", ") || "(none)"}\nAgent steps: ${result.manifest.agentStepIds.join(", ") || "(none)"}\n`);
+}
+async function commandDeploy(parsed, asJson) {
+    const runtime = createOperationRuntime(await loadConfig());
+    if (parsed.positionals.length > 0) {
+        throw new Error("rl deploy takes no arguments; run it inside a Reasonlayer checkout");
+    }
+    const result = await runOperation(cliOperation("publish_workspace"), { runtime }, {});
+    const published = result;
+    output(result, asJson, `Published ${published.workflowId ?? "workflow"} version ${published.versionNumber ?? "?"}\nVersion: ${published.versionId ?? "?"}\n`);
+}
+async function commandStartWorkspace(parsed, asJson, mode) {
+    const workflowId = requirePositional(parsed.positionals, 0, "workflow name");
+    const result = await runOperation(cliOperation(mode === "init" ? "init_workspace" : "pull_workspace"), { runtime: createOperationRuntime(await loadConfig()) }, {
+        workflowId,
+        ...(stringFlag(parsed, "dir") ? { targetDir: stringFlag(parsed, "dir") } : {}),
+    });
+    const checkout = result;
+    output(result, asJson, `${mode === "init" ? "Initialized" : "Pulled"} ${workflowId}\nCheckout: ${checkout.checkoutPath}\nSession: ${checkout.sessionId}\nWatcher: ${checkout.daemonPid}\n`);
+}
+async function commandDone(asJson) {
+    const result = await runOperation(cliOperation("done_workspace"), { runtime: createOperationRuntime(await loadConfig()) }, {});
+    const done = result;
+    output(result, asJson, `Finished ${done.workflowId ?? "workspace"}\nRemoved: ${done.checkoutPath}\n`);
+}
+async function commandStatus(asJson) {
+    const result = await runOperation(cliOperation("workspace_status"), { runtime: createOperationRuntime(await loadConfig()) }, {});
+    const status = result;
+    output(result, asJson, `${status.workflowId ?? "workspace"}: ${status.state ?? "unknown"}\nCompile: ${status.compile?.ok === true ? "green" : status.compile?.ok === false ? "red" : "pending"}\n`);
+}
+async function commandRun(parsed, asJson) {
+    const workflowId = requirePositional(parsed.positionals, 0, "workflow id");
+    const runtime = createOperationRuntime(await loadConfig());
+    const result = await runOperation(cliOperation("run"), { runtime }, {
+        workflowId,
+        input: await parseInputJson(stringFlag(parsed, "input-json")),
+        ...(stringFlag(parsed, "run-key") ? { runKey: stringFlag(parsed, "run-key") } : {}),
+        wait: !hasFlag(parsed, "no-wait"),
+        pollIntervalMs: numberFlag(parsed, "poll-interval-ms"),
+        timeoutMs: numberFlag(parsed, "timeout-ms"),
+    });
+    const status = result.status;
+    const runId = result.runId;
+    output(result, asJson, `Run ${runId ?? "(created)"}${status ? ` ${status}` : ""}\n${jsonText(result)}`);
+}
+async function commandDev(parsed, asJson) {
+    const workflow = requirePositional(parsed.positionals, 0, "workflow path");
+    const runtime = createOperationRuntime(await loadConfig());
+    const controller = new AbortController();
+    const timeoutMs = numberFlag(parsed, "timeout-ms");
+    const timeout = timeoutMs !== undefined ? setTimeout(() => controller.abort(), timeoutMs) : undefined;
+    let interrupted = false;
+    const onSignal = () => {
+        if (interrupted)
+            process.exit(130);
+        interrupted = true;
+        controller.abort();
+    };
+    process.once("SIGINT", onSignal);
+    process.once("SIGTERM", onSignal);
+    let result;
+    try {
+        result = await runOperation(cliOperation("dev"), { runtime }, {
+            workflow,
+            input: await parseInputJson(stringFlag(parsed, "input-json")),
+            ...(stringFlag(parsed, "run-key") ? { runKey: stringFlag(parsed, "run-key") } : {}),
+            pollIntervalMs: numberFlag(parsed, "poll-interval-ms"),
+            timeoutMs,
+            concurrency: numberFlag(parsed, "concurrency"),
+            signal: controller.signal,
+            onRunCreated: (created) => {
+                // Single-line NDJSON: supervisors parse stderr line by line.
+                process.stderr.write(`${JSON.stringify({ event: "run.created", ...created })}\n`);
+            },
+        });
+    }
+    finally {
+        if (timeout)
+            clearTimeout(timeout);
+        process.off("SIGINT", onSignal);
+        process.off("SIGTERM", onSignal);
+    }
+    if (result.ok === false) {
+        if (asJson)
+            output(result, true);
+        else
+            process.stderr.write(`${formatCompileErrors(result)}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    const status = result.status;
+    const runId = result.runId;
+    output(result, asJson, `Dev run ${runId ?? "(created)"}${status ? ` ${status}` : ""}\n${jsonText(result)}`);
+}
+async function commandInspect(parsed, asJson) {
+    const runtime = createOperationRuntime(await loadConfig());
+    const target = parsed.positionals[0];
+    if (target === "runs") {
+        const value = await runOperation(cliOperation("list_runs"), { runtime }, {
+            limit: numberFlag(parsed, "limit"),
+        });
+        output(value, asJson, jsonText(value));
+        return;
+    }
+    if (target === "deployment") {
+        const deploymentId = requirePositional(parsed.positionals, 1, "deployment id");
+        const value = await runOperation(cliOperation("get_deployment"), { runtime }, { deploymentId });
+        output(value, asJson, jsonText(value));
+        return;
+    }
+    if (target !== "run")
+        throw new Error(`unknown inspect target "${target ?? ""}"`);
+    const runId = requirePositional(parsed.positionals, 1, "run id");
+    if (!hasFlag(parsed, "watch")) {
+        const value = await runOperation(cliOperation("inspect"), { runtime }, {
+            runId,
+            transcriptLimit: numberFlag(parsed, "transcript-limit") ?? 100,
+        });
+        const transcript = value.transcript;
+        const rendered = {
+            ...value,
+            transcriptPage: transcript,
+            transcript: transcript.events ?? [],
+        };
+        output(rendered, asJson, formatInspect(rendered));
+        return;
+    }
+    const pollIntervalMs = numberFlag(parsed, "poll-interval-ms") ?? 1000;
+    let cursor;
+    for (;;) {
+        const value = await runOperation(cliOperation("inspect"), { runtime }, {
+            runId,
+            ...(cursor !== undefined ? { transcriptCursor: cursor } : {}),
+            transcriptLimit: numberFlag(parsed, "transcript-limit") ?? 100,
+        });
+        const transcript = value.transcript;
+        const transcriptPage = transcript;
+        if (transcriptPage.nextCursor)
+            cursor = transcriptPage.nextCursor;
+        const rendered = {
+            ...value,
+            transcriptPage,
+            transcript: transcriptPage.events ?? [],
+        };
+        output(rendered, asJson, formatInspect(rendered));
+        const status = value.run?.status;
+        if (typeof status === "string" && isTerminalRunStatus(status))
+            return;
+        await sleep(pollIntervalMs);
+    }
+}
+async function commandFromTable(group, parsed, asJson, table) {
+    const subcommand = requirePositional(parsed.positionals, 0, `${group} subcommand`);
+    const definition = table[subcommand];
+    if (!definition)
+        throw new Error(`unknown ${group} command "${subcommand}"`);
+    const runtime = createOperationRuntime(await loadConfig());
+    const result = await runOperation(cliOperation(definition.operation), { runtime }, await definition.args(parsed));
+    output(result, asJson, definition.format?.(result) ?? jsonText(result));
+}
+const RUN_SUBCOMMANDS = {
+    list: {
+        usage: "runs list [--limit <n>]",
+        operation: "list_runs",
+        args: (parsed) => ({ limit: numberFlag(parsed, "limit") }),
+    },
+    cancel: {
+        usage: "runs cancel <run-id>",
+        operation: "cancel_run",
+        args: (parsed) => ({ runId: requirePositional(parsed.positionals, 1, "run id") }),
+    },
+    "cancel-step": {
+        usage: "runs cancel-step <run-id> <step-id> [--invocation-key <key>]",
+        operation: "cancel_step",
+        args: (parsed) => {
+            const invocationKey = stringFlag(parsed, "invocation-key");
+            return {
+                runId: requirePositional(parsed.positionals, 1, "run id"),
+                stepId: requirePositional(parsed.positionals, 2, "step id"),
+                ...(invocationKey !== undefined ? { invocationKey } : {}),
+            };
+        },
+    },
+    retry: {
+        usage: "runs retry <run-id>",
+        operation: "retry_run",
+        args: (parsed) => ({ runId: requirePositional(parsed.positionals, 1, "run id") }),
+    },
+};
+const REVIEW_SUBCOMMANDS = {
+    list: {
+        usage: "reviews list [--status <status>] [--limit <n>]",
+        operation: "list_reviews",
+        args: (parsed) => {
+            const status = stringFlag(parsed, "status");
+            const limit = numberFlag(parsed, "limit");
+            return {
+                ...(status !== undefined ? { status } : {}),
+                ...(limit !== undefined ? { limit } : {}),
+            };
+        },
+    },
+    approve: {
+        usage: "reviews approve <approval-id> --decision-json <json|@file|->",
+        operation: "approve_review",
+        args: async (parsed) => {
+            const rawDecision = stringFlag(parsed, "decision-json");
+            if (rawDecision === undefined)
+                throw new Error("reviews approve requires --decision-json");
+            return {
+                approvalId: requirePositional(parsed.positionals, 1, "approval id"),
+                decision: await parseInputJson(rawDecision),
+            };
+        },
+    },
+    reject: {
+        usage: "reviews reject <approval-id> [--reason <reason>]",
+        operation: "reject_review",
+        args: (parsed) => {
+            const reason = stringFlag(parsed, "reason");
+            return {
+                approvalId: requirePositional(parsed.positionals, 1, "approval id"),
+                ...(reason !== undefined ? { reason } : {}),
+            };
+        },
+    },
+};
+const TRIGGER_SUBCOMMANDS = {
+    list: { usage: "triggers list", operation: "list_triggers", args: () => ({}) },
+    enable: {
+        usage: "triggers enable <trigger-id>",
+        operation: "set_trigger_enabled",
+        args: (parsed) => ({
+            triggerId: requirePositional(parsed.positionals, 1, "trigger id"),
+            enabled: true,
+        }),
+    },
+    disable: {
+        usage: "triggers disable <trigger-id>",
+        operation: "set_trigger_enabled",
+        args: (parsed) => ({
+            triggerId: requirePositional(parsed.positionals, 1, "trigger id"),
+            enabled: false,
+        }),
+    },
+};
+const VERSION_SUBCOMMANDS = {
+    list: {
+        usage: "versions list <workflow-id>",
+        operation: "list_workflow_versions",
+        args: (parsed) => ({
+            workflowId: requirePositional(parsed.positionals, 1, "workflow id"),
+        }),
+    },
+    publish: {
+        usage: "versions publish <workflow-id> <version-id>",
+        operation: "publish_workflow_version",
+        args: (parsed) => ({
+            workflowId: requirePositional(parsed.positionals, 1, "workflow id"),
+            versionId: requirePositional(parsed.positionals, 2, "version id"),
+        }),
+    },
+};
+const WORKFLOW_SUBCOMMANDS = {
+    delete: {
+        usage: "workflow delete <workflow-id>",
+        operation: "delete_workflow",
+        args: (parsed) => ({ workflowId: requirePositional(parsed.positionals, 1, "workflow id") }),
+    },
+};
+const TOKEN_SUBCOMMANDS = {
+    list: { usage: "tokens list", operation: "list_tokens", args: () => ({}) },
+    create: {
+        usage: "tokens create --label <label> --scopes <scope,...> [--workflow-ids <id,...>] [--expires-at <ms>]",
+        operation: "create_token",
+        args: (parsed) => {
+            const label = stringFlag(parsed, "label");
+            const scopes = commaSeparatedFlag(parsed, "scopes");
+            if (!label || !scopes?.length)
+                throw new Error("tokens create requires --label and --scopes");
+            const workflowIds = commaSeparatedFlag(parsed, "workflow-ids");
+            const expiresAt = numberFlag(parsed, "expires-at");
+            return {
+                label,
+                scopes,
+                ...(workflowIds !== undefined ? { workflowIds } : {}),
+                ...(expiresAt !== undefined ? { expiresAt } : {}),
+            };
+        },
+    },
+    revoke: {
+        usage: "tokens revoke <token-id>",
+        operation: "revoke_token",
+        args: (parsed) => ({ tokenId: requirePositional(parsed.positionals, 1, "token id") }),
+    },
+};
+const DEVICE_SUBCOMMANDS = {
+    list: { usage: "device list", operation: "list_devices", args: () => ({}) },
+    register: {
+        usage: "device register --name <name> [--settings-json <json|@file|->]",
+        operation: "register_device",
+        args: async (parsed) => {
+            const name = stringFlag(parsed, "name");
+            if (!name)
+                throw new Error("device register requires --name");
+            const rawSettings = stringFlag(parsed, "settings-json");
+            const settings = rawSettings !== undefined
+                ? (await parseInputJson(rawSettings))
+                : undefined;
+            return {
+                name,
+                ...(settings !== undefined ? { settings } : {}),
+            };
+        },
+    },
+    bind: {
+        usage: "device bind <handle> <device-id>",
+        operation: "bind_device_handle",
+        args: (parsed) => ({
+            handle: requirePositional(parsed.positionals, 1, "device handle"),
+            deviceId: requirePositional(parsed.positionals, 2, "device id"),
+        }),
+    },
+    update: {
+        usage: "device update <device-id> [--name <name>] [--settings-json <json|@file|->] [--enable|--disable]",
+        operation: "update_device",
+        args: async (parsed) => {
+            const deviceId = requirePositional(parsed.positionals, 1, "device id");
+            const enabled = hasFlag(parsed, "enable") ? true : hasFlag(parsed, "disable") ? false : undefined;
+            const name = stringFlag(parsed, "name");
+            const rawSettings = stringFlag(parsed, "settings-json");
+            const settings = rawSettings !== undefined
+                ? (await parseInputJson(rawSettings))
+                : undefined;
+            return {
+                deviceId,
+                ...(name !== undefined ? { name } : {}),
+                ...(enabled !== undefined ? { enabled } : {}),
+                ...(settings !== undefined ? { settings } : {}),
+            };
+        },
+    },
+    "rotate-secret": {
+        usage: "device rotate-secret <device-id>",
+        operation: "rotate_device_secret",
+        args: (parsed) => ({ deviceId: requirePositional(parsed.positionals, 1, "device id") }),
+    },
+    profiles: {
+        usage: "device profiles [device-id]",
+        operation: "list_device_profiles",
+        args: (parsed) => parsed.positionals[1] !== undefined ? { deviceId: parsed.positionals[1] } : {},
+    },
+    "profile-create": {
+        usage: "device profile-create <device-id> --profile <key> [--label <label>]",
+        operation: "create_device_profile",
+        args: (parsed) => {
+            const deviceId = requirePositional(parsed.positionals, 1, "device id");
+            const profileKey = stringFlag(parsed, "profile");
+            if (!profileKey)
+                throw new Error("device profile-create requires --profile");
+            const label = stringFlag(parsed, "label");
+            return {
+                deviceId,
+                profileKey,
+                ...(label !== undefined ? { label } : {}),
+            };
+        },
+    },
+    login: {
+        usage: "device login <profile-id> [--message <message>]",
+        operation: "request_device_profile_login",
+        args: (parsed) => {
+            const profileId = requirePositional(parsed.positionals, 1, "profile id");
+            const message = stringFlag(parsed, "message");
+            return {
+                profileId,
+                ...(message !== undefined ? { message } : {}),
+            };
+        },
+    },
+};
+const SECRET_SUBCOMMANDS = {
+    set: {
+        usage: "secrets set <name> --value <value|->",
+        operation: "set_secret",
+        args: async (parsed) => {
+            const name = requirePositional(parsed.positionals, 1, "secret name");
+            const rawValue = stringFlag(parsed, "value");
+            const value = hasFlag(parsed, "value-stdin") || rawValue === "-"
+                ? await readStdin()
+                : rawValue;
+            if (value === undefined)
+                throw new Error("secrets set requires --value or --value-stdin");
+            return { name, value };
+        },
+    },
+    list: { usage: "secrets list", operation: "list_secrets", args: () => ({}) },
+    remove: {
+        usage: "secrets remove <name>",
+        operation: "remove_secret",
+        args: (parsed) => ({ name: requirePositional(parsed.positionals, 1, "secret name") }),
+    },
+};
+const VARIABLE_SUBCOMMANDS = {
+    list: {
+        usage: "variables list <workflow>",
+        operation: "list_variables",
+        args: (parsed) => ({
+            workflowId: requirePositional(parsed.positionals, 1, "workflow id"),
+        }),
+        format: formatVariableList,
+    },
+    set: {
+        usage: "variables set <workflow> <name> <json-value>",
+        operation: "set_variable",
+        args: (parsed) => ({
+            workflowId: requirePositional(parsed.positionals, 1, "workflow id"),
+            name: requirePositional(parsed.positionals, 2, "variable name"),
+            value: parseVariableValue(requirePositional(parsed.positionals, 3, "variable value")),
+        }),
+        format: (result) => {
+            const value = result;
+            return `Set ${value.name} for ${value.workflowId}.\n`;
+        },
+    },
+    remove: {
+        usage: "variables remove <workflow> <name>",
+        operation: "remove_variable",
+        args: (parsed) => ({
+            workflowId: requirePositional(parsed.positionals, 1, "workflow id"),
+            name: requirePositional(parsed.positionals, 2, "variable name"),
+        }),
+        format: (result) => {
+            const value = result;
+            return `Removed ${value.name} override for ${value.workflowId}; the default now applies.\n`;
+        },
+    },
+};
+/** Help text for an operation-backed command comes from the operation table. */
+function helpFor(usage, operation) {
+    return { usage, summary: cliOperation(operation).title };
+}
+function group(name, table) {
+    return {
+        help: Object.values(table).map((entry) => helpFor(entry.usage, entry.operation)),
+        run: async (parsed, asJson) => {
+            await commandFromTable(name, parsed, asJson, table);
+            return 0;
+        },
+    };
+}
+const COMMANDS = {
+    login: {
+        help: [
+            { usage: "login --token <token>", summary: "Store an org token in the OS keychain" },
+            { usage: "login --bootstrap [--org <name>]", summary: cliOperation("bootstrap_dev_org").title },
+        ],
+        run: async (parsed, asJson) => {
+            await commandLogin(parsed, asJson);
+            return process.exitCode === 1 ? 1 : 0;
+        },
+    },
+    logout: {
+        help: [{ usage: "logout", summary: "Forget the stored login for this deployment" }],
+        run: async (_parsed, asJson) => {
+            await commandLogout(asJson);
+            return 0;
+        },
+    },
+    whoami: {
+        help: [helpFor("whoami", "whoami")],
+        run: async (_parsed, asJson) => {
+            await commandWhoami(asJson);
+            return 0;
+        },
+    },
+    init: {
+        help: [helpFor("init <name> [--dir <checkout>]", "init_workspace")],
+        run: async (parsed, asJson) => {
+            await commandStartWorkspace(parsed, asJson, "init");
+            return 0;
+        },
+    },
+    pull: {
+        help: [helpFor("pull <name> [--dir <checkout>]", "pull_workspace")],
+        run: async (parsed, asJson) => {
+            await commandStartWorkspace(parsed, asJson, "pull");
+            return 0;
+        },
+    },
+    done: {
+        help: [helpFor("done", "done_workspace")],
+        run: async (_parsed, asJson) => {
+            await commandDone(asJson);
+            return 0;
+        },
+    },
+    status: {
+        help: [helpFor("status", "workspace_status")],
+        run: async (_parsed, asJson) => {
+            await commandStatus(asJson);
+            return 0;
+        },
+    },
+    validate: {
+        help: [helpFor("validate <workflow.ts>", "validate")],
+        run: commandValidate,
+    },
+    build: {
+        help: [helpFor("build <workflow.ts> [--out-dir <dist>]", "build")],
+        run: async (parsed, asJson) => {
+            await commandBuild(parsed, asJson);
+            return process.exitCode === 1 ? 1 : 0;
+        },
+    },
+    deploy: {
+        help: [helpFor("deploy", "publish_workspace")],
+        run: async (parsed, asJson) => {
+            await commandDeploy(parsed, asJson);
+            return 0;
+        },
+    },
+    run: {
+        help: [helpFor("run <workflow> [--input-json <json|@file|->] [--run-key <key>] [--no-wait]", "run")],
+        run: async (parsed, asJson) => {
+            await commandRun(parsed, asJson);
+            return 0;
+        },
+    },
+    dev: {
+        help: [helpFor("dev <workflow.ts> [--input-json <json|@file|->] [--run-key <key>] [--concurrency <n>]", "dev")],
+        run: async (parsed, asJson) => {
+            await commandDev(parsed, asJson);
+            return process.exitCode === 1 ? 1 : 0;
+        },
+    },
+    inspect: {
+        help: [
+            helpFor("inspect run <run-id> [--watch] [--transcript-limit <n>]", "inspect"),
+            helpFor("inspect runs [--limit <n>]", "list_runs"),
+            helpFor("inspect deployment <deployment-id>", "get_deployment"),
+        ],
+        run: async (parsed, asJson) => {
+            await commandInspect(parsed, asJson);
+            return 0;
+        },
+    },
+    runs: group("runs", RUN_SUBCOMMANDS),
+    reviews: group("reviews", REVIEW_SUBCOMMANDS),
+    triggers: group("triggers", TRIGGER_SUBCOMMANDS),
+    versions: group("versions", VERSION_SUBCOMMANDS),
+    workflow: group("workflow", WORKFLOW_SUBCOMMANDS),
+    tokens: group("tokens", TOKEN_SUBCOMMANDS),
+    secrets: group("secrets", SECRET_SUBCOMMANDS),
+    variables: group("variables", VARIABLE_SUBCOMMANDS),
+    device: group("device", DEVICE_SUBCOMMANDS),
+};
+const SUMMARY_COLUMN = 60;
+function helpLine({ usage, summary }) {
+    if (usage.length > SUMMARY_COLUMN)
+        return `  ${usage}\n  ${" ".repeat(SUMMARY_COLUMN)} ${summary}`;
+    return `  ${usage.padEnd(SUMMARY_COLUMN)} ${summary}`;
+}
+function helpText() {
+    const lines = Object.values(COMMANDS).flatMap((command) => command.help);
+    return `rl
+
+Commands:
+${lines.map(helpLine).join("\n")}
+
+Global:
+  --json
+  --version
+
+Authentication:
+  Browser onboarding is not available yet.
+  ${TOKEN_ONBOARDING_HINT.replaceAll("\n", "\n  ")}
+`;
+}
+export async function main(argv) {
+    const parsed = parseCliArgs(argv);
+    const asJson = hasFlag(parsed, "json");
+    try {
+        rejectConvexUrlFlag(parsed);
+        if (hasFlag(parsed, "version") || parsed.command === "version") {
+            const provenance = await sdkProvenance();
+            output(provenance, asJson, `${provenance.label}\n`);
+            return 0;
+        }
+        if (!parsed.command || parsed.command === "help" || hasFlag(parsed, "help")) {
+            process.stdout.write(helpText());
+            return 0;
+        }
+        const command = COMMANDS[parsed.command];
+        if (!command)
+            throw new Error(`unknown command "${parsed.command}"`);
+        return await command.run(parsed, asJson);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (asJson)
+            process.stderr.write(jsonText({ error: message }));
+        else
+            process.stderr.write(`${message}\n`);
+        return 1;
+    }
+}