uptimer-cli 0.0.0-stage → 0.2.1

package/CHANGELOG.md

@@ -0,0 +1,18 @@
+# uptimer-cli
+
+## 0.2.1
+
+### Patch Changes
+
+- bc089e6: Publish through the CI trusted publisher with npm provenance attestations, so the released tarball is verifiably built from this repository by the tagged workflow run.
+
+## 0.2.0
+
+### Minor Changes
+
+- Add `uptimer skill install`, which copies the bundled agent skill into a local directory (`./skills` by default, `--dir` to override, `--force` to replace) without requiring an instance URL or token.
+
+### Patch Changes
+
+- d44b001: Package the Uptimer CLI as a standalone JavaScript executable and automate npm publishing and GitHub Releases with Changesets.
+- Fix configuration output safety and input handling: redact `http_headers_json` and notification `config_json` payloads and reflected token keys, stop echoing payload fragments and transport messages in errors, bound timeout cleanup, accept a null `group_name` from group unassignment, and reject repeated options. Help payload examples now match the Admin API fields.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vrian Cao
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,63 @@
-# Temporary Holding Version
+# Uptimer CLI
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Manage monitors, notification channels, status pages, and global settings through the Uptimer Admin API. Requires Node.js >=22.14.0.
+
+## Install
+
+After the first npm release:
+
+```sh
+npm install --global uptimer-cli
+uptimer --help
+```
+
+To run a pinned version without a global install:
+
+```sh
+npx --yes uptimer-cli@<version> --help
+```
+
+## Connect
+
+Set `UPTIMER_URL` to the instance origin, such as `https://your-worker.workers.dev`, without `/api/v1`. Supply `UPTIMER_ADMIN_TOKEN` through the invoking process environment or your agent credential configuration. No credential file is created and `.env` is not loaded automatically. HTTPS is required except for explicit loopback HTTP development origins.
+
+```sh
+uptimer settings get
+uptimer monitors list --limit 20
+uptimer status-pages list
+```
+
+Write commands accept a UTF-8 JSON object using `--file path.json` or `--file -` for stdin. Payloads use the existing Admin API fields. For example:
+
+```sh
+printf '%s\n' '{"name":"API","type":"http","target":"https://api.example.com/health","interval_sec":60}' | uptimer monitors create --file -
+```
+
+Successful commands write JSON to stdout. Errors write JSON to stderr and exit with 1 for request failures or 2 for local input/configuration failures. Help exits with 0. Monitor and notification-channel lists are bounded to 50 items by default, or 1–200 with `--limit`; they are not complete exports.
+
+The Admin Token has full management permissions. Treat all returned configuration as administrative data and keep it out of shared logs. A failed or timed-out write may already have reached the server; query before retrying.
+
+## Use from a coding agent
+
+This package ships an agent skill covering install checks, connection setup, payload field references, and a write-then-verify sequence. Install it locally without leaving the CLI:
+
+```sh
+uptimer skill install                 # ./skills/uptimer-cli/
+uptimer skill install --dir ~/.claude # ~/.claude/uptimer-cli/
+uptimer skill install --force         # replace an existing copy
+```
+
+The command needs no instance URL or token and prints the installed path and file list as JSON. Alternatively, `npx skills add nexttylabs/Uptimer --skill uptimer-cli` auto-detects installed agents (`-g` for global, `-a <agent>` for one target). The skill source lives in [`skills/uptimer-cli/`](../../skills/uptimer-cli/SKILL.md); its [command reference](../../skills/uptimer-cli/references/commands.md) adds field detail beyond the inline `--help` examples.
+
+## Develop and release
+
+From the repository root:
+
+```sh
+pnpm --filter uptimer-cli start --help
+pnpm --filter uptimer-cli test
+pnpm --filter uptimer-cli test:package
+pnpm changeset
+```
+
+See [CLI release maintenance](https://github.com/nexttylabs/Uptimer/blob/master/docs/cli-releases.md) for the version PR, npm publishing, and GitHub Release workflow.

package/dist/commands.js

@@ -0,0 +1,441 @@
+import { z } from 'zod';
+import { CliError } from "./errors.js";
+import { readJsonPayload } from "./input.js";
+import { installSkill } from "./skill.js";
+import { executeApiRequest } from "./transport.js";
+const monitorsListEnvelope = z.object({
+    monitors: z.array(z.record(z.unknown())),
+});
+const monitorEnvelope = z.object({
+    monitor: z.record(z.unknown()),
+});
+const deletedEnvelope = z.object({
+    deleted: z.boolean(),
+});
+const monitorGroupsReorderEnvelope = z.object({
+    updated_groups: z.number(),
+    affected_monitors: z.number(),
+});
+const monitorGroupsAssignEnvelope = z.object({
+    // The server returns null when monitors are removed from a group.
+    group_name: z.string().nullable(),
+    group_sort_order: z.number(),
+    updated_monitors: z.number(),
+});
+const notificationChannelsListEnvelope = z.object({
+    notification_channels: z.array(z.record(z.unknown())),
+});
+const notificationChannelEnvelope = z.object({
+    notification_channel: z.record(z.unknown()),
+});
+const statusPagesListEnvelope = z.object({
+    status_pages: z.array(z.record(z.unknown())),
+});
+const statusPageEnvelope = z.object({
+    status_page: z.record(z.unknown()),
+});
+const settingsEnvelope = z.object({
+    settings: z.record(z.unknown()),
+});
+const uptimeRatingEnvelope = z.object({
+    uptime_rating_level: z.number(),
+});
+// A repeated option silently changes the request (last value wins), so reject it.
+function assertUnset(value, option) {
+    if (value !== undefined) {
+        throw new CliError(2, 'INVALID_ARGUMENT', `Option ${option} may only be given once`);
+    }
+}
+export function parseArgs(argv) {
+    const positionals = [];
+    const options = { force: false };
+    let isHelp = false;
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === '--help' || arg === '-h') {
+            isHelp = true;
+            continue;
+        }
+        if (arg === '--force') {
+            options.force = true;
+            continue;
+        }
+        if (arg.startsWith('--dir=')) {
+            assertUnset(options.dir, '--dir');
+            options.dir = arg.slice(6);
+            continue;
+        }
+        if (arg === '--dir') {
+            assertUnset(options.dir, '--dir');
+            i++;
+            if (i >= argv.length) {
+                throw new CliError(2, 'INVALID_ARGUMENT', 'Option --dir requires a value');
+            }
+            options.dir = argv[i];
+            continue;
+        }
+        if (arg.startsWith('--limit=')) {
+            assertUnset(options.limit, '--limit');
+            options.limit = arg.slice(8);
+            continue;
+        }
+        if (arg === '--limit') {
+            assertUnset(options.limit, '--limit');
+            i++;
+            if (i >= argv.length || argv[i].startsWith('--')) {
+                throw new CliError(2, 'INVALID_ARGUMENT', 'Option --limit requires a value');
+            }
+            options.limit = argv[i];
+            continue;
+        }
+        if (arg.startsWith('--file=')) {
+            assertUnset(options.file, '--file');
+            options.file = arg.slice(7);
+            continue;
+        }
+        if (arg === '--file') {
+            assertUnset(options.file, '--file');
+            i++;
+            if (i >= argv.length) {
+                throw new CliError(2, 'INVALID_ARGUMENT', 'Option --file requires a value');
+            }
+            options.file = argv[i];
+            continue;
+        }
+        if (arg.startsWith('--') || /^-[a-zA-Z]/.test(arg)) {
+            throw new CliError(2, 'INVALID_ARGUMENT', `Unknown option: "${arg}"`);
+        }
+        positionals.push(arg);
+    }
+    return { positionals, options, isHelp };
+}
+function parseId(raw) {
+    if (!raw) {
+        throw new CliError(2, 'INVALID_ARGUMENT', 'Resource ID is required');
+    }
+    if (!/^[1-9]\d*$/.test(raw)) {
+        throw new CliError(2, 'INVALID_ARGUMENT', `Invalid ID: "${raw}". ID must be a positive integer.`);
+    }
+    const n = Number(raw);
+    if (!Number.isSafeInteger(n) || n <= 0) {
+        throw new CliError(2, 'INVALID_ARGUMENT', `Invalid ID: "${raw}". ID must be a positive safe integer.`);
+    }
+    return n;
+}
+function parseLimit(raw) {
+    if (raw === undefined) {
+        return 50;
+    }
+    if (!/^\d+$/.test(raw)) {
+        throw new CliError(2, 'INVALID_ARGUMENT', `Invalid limit: "${raw}". Limit must be an integer between 1 and 200.`);
+    }
+    const n = Number(raw);
+    if (n < 1 || n > 200 || !Number.isSafeInteger(n)) {
+        throw new CliError(2, 'INVALID_ARGUMENT', `Invalid limit: "${raw}". Limit must be between 1 and 200.`);
+    }
+    return n;
+}
+export async function executeCommand(parsed, transportOptions, stdin) {
+    const { positionals, options } = parsed;
+    if (positionals.length === 0) {
+        throw new CliError(2, 'INVALID_ARGUMENT', 'No command provided. Run with --help for usage.');
+    }
+    const family = positionals[0];
+    if (family === 'skill') {
+        if (positionals[1] !== 'install') {
+            throw new CliError(2, 'INVALID_ARGUMENT', 'Use "skill install" to install the agent skill locally');
+        }
+        if (positionals.length > 2) {
+            throw new CliError(2, 'INVALID_ARGUMENT', `Unexpected positional argument: "${positionals[2]}"`);
+        }
+        if (options.file !== undefined || options.limit !== undefined) {
+            throw new CliError(2, 'INVALID_ARGUMENT', 'Options --file and --limit are not supported for skill install');
+        }
+        return await installSkill({ dir: options.dir ?? 'skills', force: options.force });
+    }
+    if (family === 'monitors') {
+        const action = positionals[1];
+        if (!action) {
+            throw new CliError(2, 'INVALID_ARGUMENT', 'Missing subcommand for monitors. Run with --help for usage.');
+        }
+        if (action === 'groups') {
+            const subAction = positionals[2];
+            if (!subAction) {
+                throw new CliError(2, 'INVALID_ARGUMENT', 'Missing subcommand for monitors groups. Use "reorder" or "assign".');
+            }
+            if (positionals.length > 3) {
+                throw new CliError(2, 'INVALID_ARGUMENT', `Unexpected positional argument: "${positionals[3]}"`);
+            }
+            if (options.limit !== undefined) {
+                throw new CliError(2, 'INVALID_ARGUMENT', 'Option --limit is not supported for monitors groups');
+            }
+            if (!options.file) {
+                throw new CliError(2, 'INVALID_ARGUMENT', 'Option --file is required for monitors groups operations');
+            }
+            if (subAction === 'reorder') {
+                const payload = await readJsonPayload(options.file, stdin);
+                return await executeApiRequest('POST', '/monitors/groups/reorder', payload, monitorGroupsReorderEnvelope, transportOptions);
+            }
+            if (subAction === 'assign') {
+                const payload = await readJsonPayload(options.file, stdin);
+                return await executeApiRequest('POST', '/monitors/groups/assign', payload, monitorGroupsAssignEnvelope, transportOptions);
+            }
+            throw new CliError(2, 'INVALID_ARGUMENT', `Unknown subcommand for monitors groups: "${subAction}"`);
+        }
+        if (action === 'list') {
+            if (positionals.length > 2) {
+                throw new CliError(2, 'INVALID_ARGUMENT', `Unexpected positional argument: "${positionals[2]}"`);
+            }
+            if (options.file !== undefined) {
+                throw new CliError(2, 'INVALID_ARGUMENT', 'Option --file is not supported for monitors list');
+            }
+            const limit = parseLimit(options.limit);
+            return await executeApiRequest('GET', `/monitors?limit=${limit}`, undefined, monitorsListEnvelope, transportOptions);
+        }
+        if (action === 'create') {
+            if (positionals.length > 2) {
+                throw new CliError(2, 'INVALID_ARGUMENT', `Unexpected positional argument: "${positionals[2]}"`);
+            }
+            if (options.limit !== undefined) {
+                throw new CliError(2, 'INVALID_ARGUMENT', 'Option --limit is not supported for monitors create');
+            }
+            if (!options.file) {
+                throw new CliError(2, 'INVALID_ARGUMENT', 'Option --file is required for monitors create');
+            }
+            const payload = await readJsonPayload(options.file, stdin);
+            return await executeApiRequest('POST', '/monitors', payload, monitorEnvelope, transportOptions);
+        }
+        if (action === 'update') {
+            if (positionals.length < 3) {
+                throw new CliError(2, 'INVALID_ARGUMENT', 'Missing monitor ID for update');
+            }
+            if (positionals.length > 3) {
+                throw new CliError(2, 'INVALID_ARGUMENT', `Unexpected positional argument: "${positionals[3]}"`);
+            }
+            const id = parseId(positionals[2]);
+            if (options.limit !== undefined) {
+                throw new CliError(2, 'INVALID_ARGUMENT', 'Option --limit is not supported for monitors update');
+            }
+            if (!options.file) {
+                throw new CliError(2, 'INVALID_ARGUMENT', 'Option --file is required for monitors update');
+            }
+            const payload = await readJsonPayload(options.file, stdin);
+            return await executeApiRequest('PATCH', `/monitors/${id}`, payload, monitorEnvelope, transportOptions);
+        }
+        if (action === 'delete') {
+            if (positionals.length < 3) {
+                throw new CliError(2, 'INVALID_ARGUMENT', 'Missing monitor ID for delete');
+            }
+            if (positionals.length > 3) {
+                throw new CliError(2, 'INVALID_ARGUMENT', `Unexpected positional argument: "${positionals[3]}"`);
+            }
+            const id = parseId(positionals[2]);
+            if (options.limit !== undefined || options.file !== undefined) {
+                throw new CliError(2, 'INVALID_ARGUMENT', 'Options are not supported for monitors delete');
+            }
+            return await executeApiRequest('DELETE', `/monitors/${id}`, undefined, deletedEnvelope, transportOptions);
+        }
+        if (action === 'pause') {
+            if (positionals.length < 3) {
+                throw new CliError(2, 'INVALID_ARGUMENT', 'Missing monitor ID for pause');
+            }
+            if (positionals.length > 3) {
+                throw new CliError(2, 'INVALID_ARGUMENT', `Unexpected positional argument: "${positionals[3]}"`);
+            }
+            const id = parseId(positionals[2]);
+            if (options.limit !== undefined || options.file !== undefined) {
+                throw new CliError(2, 'INVALID_ARGUMENT', 'Options are not supported for monitors pause');
+            }
+            return await executeApiRequest('POST', `/monitors/${id}/pause`, undefined, monitorEnvelope, transportOptions);
+        }
+        if (action === 'resume') {
+            if (positionals.length < 3) {
+                throw new CliError(2, 'INVALID_ARGUMENT', 'Missing monitor ID for resume');
+            }
+            if (positionals.length > 3) {
+                throw new CliError(2, 'INVALID_ARGUMENT', `Unexpected positional argument: "${positionals[3]}"`);
+            }
+            const id = parseId(positionals[2]);
+            if (options.limit !== undefined || options.file !== undefined) {
+                throw new CliError(2, 'INVALID_ARGUMENT', 'Options are not supported for monitors resume');
+            }
+            return await executeApiRequest('POST', `/monitors/${id}/resume`, undefined, monitorEnvelope, transportOptions);
+        }
+        throw new CliError(2, 'INVALID_ARGUMENT', `Unknown action for monitors: "${action}"`);
+    }
+    if (family === 'notification-channels') {
+        const action = positionals[1];
+        if (!action) {
+            throw new CliError(2, 'INVALID_ARGUMENT', 'Missing subcommand for notification-channels');
+        }
+        if (action === 'list') {
+            if (positionals.length > 2) {
+                throw new CliError(2, 'INVALID_ARGUMENT', `Unexpected positional argument: "${positionals[2]}"`);
+            }
+            if (options.file !== undefined) {
+                throw new CliError(2, 'INVALID_ARGUMENT', 'Option --file is not supported for notification-channels list');
+            }
+            const limit = parseLimit(options.limit);
+            return await executeApiRequest('GET', `/notification-channels?limit=${limit}`, undefined, notificationChannelsListEnvelope, transportOptions);
+        }
+        if (action === 'create') {
+            if (positionals.length > 2) {
+                throw new CliError(2, 'INVALID_ARGUMENT', `Unexpected positional argument: "${positionals[2]}"`);
+            }
+            if (options.limit !== undefined) {
+                throw new CliError(2, 'INVALID_ARGUMENT', 'Option --limit is not supported for notification-channels create');
+            }
+            if (!options.file) {
+                throw new CliError(2, 'INVALID_ARGUMENT', 'Option --file is required for notification-channels create');
+            }
+            const payload = await readJsonPayload(options.file, stdin);
+            return await executeApiRequest('POST', '/notification-channels', payload, notificationChannelEnvelope, transportOptions);
+        }
+        if (action === 'update') {
+            if (positionals.length < 3) {
+                throw new CliError(2, 'INVALID_ARGUMENT', 'Missing notification-channel ID for update');
+            }
+            if (positionals.length > 3) {
+                throw new CliError(2, 'INVALID_ARGUMENT', `Unexpected positional argument: "${positionals[3]}"`);
+            }
+            const id = parseId(positionals[2]);
+            if (options.limit !== undefined) {
+                throw new CliError(2, 'INVALID_ARGUMENT', 'Option --limit is not supported for notification-channels update');
+            }
+            if (!options.file) {
+                throw new CliError(2, 'INVALID_ARGUMENT', 'Option --file is required for notification-channels update');
+            }
+            const payload = await readJsonPayload(options.file, stdin);
+            return await executeApiRequest('PATCH', `/notification-channels/${id}`, payload, notificationChannelEnvelope, transportOptions);
+        }
+        if (action === 'delete') {
+            if (positionals.length < 3) {
+                throw new CliError(2, 'INVALID_ARGUMENT', 'Missing notification-channel ID for delete');
+            }
+            if (positionals.length > 3) {
+                throw new CliError(2, 'INVALID_ARGUMENT', `Unexpected positional argument: "${positionals[3]}"`);
+            }
+            const id = parseId(positionals[2]);
+            if (options.limit !== undefined || options.file !== undefined) {
+                throw new CliError(2, 'INVALID_ARGUMENT', 'Options are not supported for notification-channels delete');
+            }
+            return await executeApiRequest('DELETE', `/notification-channels/${id}`, undefined, deletedEnvelope, transportOptions);
+        }
+        throw new CliError(2, 'INVALID_ARGUMENT', `Unknown action for notification-channels: "${action}"`);
+    }
+    if (family === 'status-pages') {
+        const action = positionals[1];
+        if (!action) {
+            throw new CliError(2, 'INVALID_ARGUMENT', 'Missing subcommand for status-pages');
+        }
+        if (action === 'list') {
+            if (positionals.length > 2) {
+                throw new CliError(2, 'INVALID_ARGUMENT', `Unexpected positional argument: "${positionals[2]}"`);
+            }
+            if (options.limit !== undefined || options.file !== undefined) {
+                throw new CliError(2, 'INVALID_ARGUMENT', 'Options are not supported for status-pages list');
+            }
+            return await executeApiRequest('GET', '/status-pages', undefined, statusPagesListEnvelope, transportOptions);
+        }
+        if (action === 'create') {
+            if (positionals.length > 2) {
+                throw new CliError(2, 'INVALID_ARGUMENT', `Unexpected positional argument: "${positionals[2]}"`);
+            }
+            if (options.limit !== undefined) {
+                throw new CliError(2, 'INVALID_ARGUMENT', 'Option --limit is not supported for status-pages create');
+            }
+            if (!options.file) {
+                throw new CliError(2, 'INVALID_ARGUMENT', 'Option --file is required for status-pages create');
+            }
+            const payload = await readJsonPayload(options.file, stdin);
+            return await executeApiRequest('POST', '/status-pages', payload, statusPageEnvelope, transportOptions);
+        }
+        if (action === 'update') {
+            if (positionals.length < 3) {
+                throw new CliError(2, 'INVALID_ARGUMENT', 'Missing status-page ID for update');
+            }
+            if (positionals.length > 3) {
+                throw new CliError(2, 'INVALID_ARGUMENT', `Unexpected positional argument: "${positionals[3]}"`);
+            }
+            const id = parseId(positionals[2]);
+            if (options.limit !== undefined) {
+                throw new CliError(2, 'INVALID_ARGUMENT', 'Option --limit is not supported for status-pages update');
+            }
+            if (!options.file) {
+                throw new CliError(2, 'INVALID_ARGUMENT', 'Option --file is required for status-pages update');
+            }
+            const payload = await readJsonPayload(options.file, stdin);
+            return await executeApiRequest('PATCH', `/status-pages/${id}`, payload, statusPageEnvelope, transportOptions);
+        }
+        if (action === 'delete') {
+            if (positionals.length < 3) {
+                throw new CliError(2, 'INVALID_ARGUMENT', 'Missing status-page ID for delete');
+            }
+            if (positionals.length > 3) {
+                throw new CliError(2, 'INVALID_ARGUMENT', `Unexpected positional argument: "${positionals[3]}"`);
+            }
+            const id = parseId(positionals[2]);
+            if (options.limit !== undefined || options.file !== undefined) {
+                throw new CliError(2, 'INVALID_ARGUMENT', 'Options are not supported for status-pages delete');
+            }
+            return await executeApiRequest('DELETE', `/status-pages/${id}`, undefined, deletedEnvelope, transportOptions);
+        }
+        throw new CliError(2, 'INVALID_ARGUMENT', `Unknown action for status-pages: "${action}"`);
+    }
+    if (family === 'settings') {
+        const action = positionals[1];
+        if (!action) {
+            throw new CliError(2, 'INVALID_ARGUMENT', 'Missing subcommand for settings');
+        }
+        if (action === 'uptime-rating') {
+            const subAction = positionals[2];
+            if (!subAction) {
+                throw new CliError(2, 'INVALID_ARGUMENT', 'Missing subcommand for settings uptime-rating. Use "get" or "update".');
+            }
+            if (positionals.length > 3) {
+                throw new CliError(2, 'INVALID_ARGUMENT', `Unexpected positional argument: "${positionals[3]}"`);
+            }
+            if (subAction === 'get') {
+                if (options.limit !== undefined || options.file !== undefined) {
+                    throw new CliError(2, 'INVALID_ARGUMENT', 'Options are not supported for settings uptime-rating get');
+                }
+                return await executeApiRequest('GET', '/settings/uptime-rating', undefined, uptimeRatingEnvelope, transportOptions);
+            }
+            if (subAction === 'update') {
+                if (options.limit !== undefined) {
+                    throw new CliError(2, 'INVALID_ARGUMENT', 'Option --limit is not supported for settings uptime-rating update');
+                }
+                if (!options.file) {
+                    throw new CliError(2, 'INVALID_ARGUMENT', 'Option --file is required for settings uptime-rating update');
+                }
+                const payload = await readJsonPayload(options.file, stdin);
+                return await executeApiRequest('PUT', '/settings/uptime-rating', payload, uptimeRatingEnvelope, transportOptions);
+            }
+            throw new CliError(2, 'INVALID_ARGUMENT', `Unknown subcommand for settings uptime-rating: "${subAction}"`);
+        }
+        if (action === 'get') {
+            if (positionals.length > 2) {
+                throw new CliError(2, 'INVALID_ARGUMENT', `Unexpected positional argument: "${positionals[2]}"`);
+            }
+            if (options.limit !== undefined || options.file !== undefined) {
+                throw new CliError(2, 'INVALID_ARGUMENT', 'Options are not supported for settings get');
+            }
+            return await executeApiRequest('GET', '/settings', undefined, settingsEnvelope, transportOptions);
+        }
+        if (action === 'update') {
+            if (positionals.length > 2) {
+                throw new CliError(2, 'INVALID_ARGUMENT', `Unexpected positional argument: "${positionals[2]}"`);
+            }
+            if (options.limit !== undefined) {
+                throw new CliError(2, 'INVALID_ARGUMENT', 'Option --limit is not supported for settings update');
+            }
+            if (!options.file) {
+                throw new CliError(2, 'INVALID_ARGUMENT', 'Option --file is required for settings update');
+            }
+            const payload = await readJsonPayload(options.file, stdin);
+            return await executeApiRequest('PATCH', '/settings', payload, settingsEnvelope, transportOptions);
+        }
+        throw new CliError(2, 'INVALID_ARGUMENT', `Unknown action for settings: "${action}"`);
+    }
+    throw new CliError(2, 'INVALID_ARGUMENT', `Unknown command family: "${family}"`);
+}

package/dist/errors.js

@@ -0,0 +1,33 @@
+import { redactCredentials } from "./redact.js";
+export class CliError extends Error {
+    exitCode;
+    code;
+    status;
+    constructor(exitCode, code, message, status) {
+        super(message);
+        this.name = 'CliError';
+        this.exitCode = exitCode;
+        this.code = code;
+        this.status = status;
+    }
+}
+export function formatErrorEnvelope(error, adminToken) {
+    if (error instanceof CliError) {
+        const envelope = {
+            error: {
+                code: error.code,
+                message: error.message,
+                ...(error.status !== undefined ? { status: error.status } : {}),
+            },
+        };
+        return redactCredentials(envelope, adminToken);
+    }
+    const rawMessage = error instanceof Error ? error.message : String(error);
+    const envelope = {
+        error: {
+            code: 'INTERNAL_ERROR',
+            message: rawMessage,
+        },
+    };
+    return redactCredentials(envelope, adminToken);
+}