@jsondb-cloud/cli 1.0.0 → 1.0.10

package/dist/commands/schema.js

@@ -0,0 +1,82 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSchemaCommand = getSchemaCommand;
+exports.setSchemaCommand = setSchemaCommand;
+exports.removeSchemaCommand = removeSchemaCommand;
+const fs = __importStar(require("fs"));
+const output_1 = require("../lib/output");
+async function getSchemaCommand(collection, client) {
+    const res = await client.get(`${collection}/_schema`);
+    if (!res.ok) {
+        if (res.status === 404) {
+            console.log(`No schema set for collection '${collection}'`);
+            return;
+        }
+        (0, output_1.error)(`Failed to get schema: ${res.status}`);
+        process.exit(1);
+    }
+    const data = await res.json();
+    (0, output_1.printJson)(data.schema || data);
+}
+async function setSchemaCommand(collection, client, options) {
+    let schema;
+    if (options.file) {
+        const content = fs.readFileSync(options.file, "utf-8");
+        schema = JSON.parse(content);
+    }
+    else {
+        const chunks = [];
+        for await (const chunk of process.stdin) {
+            chunks.push(chunk);
+        }
+        schema = JSON.parse(Buffer.concat(chunks).toString("utf-8"));
+    }
+    const res = await client.put(`${collection}/_schema`, schema);
+    if (!res.ok) {
+        const data = await res.json().catch(() => ({}));
+        (0, output_1.error)(data.error?.message || `Failed to set schema: ${res.status}`);
+        process.exit(1);
+    }
+    (0, output_1.success)(`Schema set for collection '${collection}'`);
+}
+async function removeSchemaCommand(collection, client) {
+    const res = await client.delete(`${collection}/_schema`);
+    if (!res.ok) {
+        (0, output_1.error)(`Failed to remove schema: ${res.status}`);
+        process.exit(1);
+    }
+    (0, output_1.success)(`Schema removed from collection '${collection}'`);
+}

package/dist/commands/versions.d.ts

@@ -0,0 +1,8 @@
+import { ApiClient } from "../lib/client";
+export declare function listVersionsCommand(collection: string, docId: string, client: ApiClient): Promise<void>;
+export declare function getVersionCommand(collection: string, docId: string, version: string, client: ApiClient): Promise<void>;
+export declare function diffVersionsCommand(collection: string, docId: string, client: ApiClient, options: {
+    from: string;
+    to: string;
+}): Promise<void>;
+export declare function restoreVersionCommand(collection: string, docId: string, version: string, client: ApiClient): Promise<void>;

package/dist/commands/versions.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listVersionsCommand = listVersionsCommand;
+exports.getVersionCommand = getVersionCommand;
+exports.diffVersionsCommand = diffVersionsCommand;
+exports.restoreVersionCommand = restoreVersionCommand;
+const output_1 = require("../lib/output");
+async function listVersionsCommand(collection, docId, client) {
+    const res = await client.get(`${collection}/${docId}/versions`);
+    if (!res.ok) {
+        const data = await res.json().catch(() => ({}));
+        (0, output_1.error)(data.error?.message || `Failed to list versions: ${res.status}`);
+        process.exit(1);
+    }
+    const data = await res.json();
+    const versions = data.versions || data.data || data;
+    if (Array.isArray(versions) && versions.length > 0) {
+        (0, output_1.printTable)(["Version", "Action", "Timestamp", "Size"], versions.map((v) => [
+            String(v.version),
+            v.action || "",
+            v.timestamp || "",
+            v.size != null ? String(v.size) : "",
+        ]));
+    }
+    else {
+        console.log("No versions found.");
+    }
+}
+async function getVersionCommand(collection, docId, version, client) {
+    const res = await client.get(`${collection}/${docId}/versions/${version}`);
+    if (!res.ok) {
+        const data = await res.json().catch(() => ({}));
+        (0, output_1.error)(data.error?.message || `Failed to get version: ${res.status}`);
+        process.exit(1);
+    }
+    const doc = await res.json();
+    (0, output_1.printJson)(doc);
+}
+async function diffVersionsCommand(collection, docId, client, options) {
+    if (!options.from || !options.to) {
+        (0, output_1.error)("Both --from and --to version numbers are required");
+        process.exit(1);
+    }
+    const res = await client.get(`${collection}/${docId}/versions/diff?from=${options.from}&to=${options.to}`);
+    if (!res.ok) {
+        const data = await res.json().catch(() => ({}));
+        (0, output_1.error)(data.error?.message || `Failed to diff versions: ${res.status}`);
+        process.exit(1);
+    }
+    const diff = await res.json();
+    (0, output_1.printJson)(diff);
+}
+async function restoreVersionCommand(collection, docId, version, client) {
+    const res = await client.post(`${collection}/${docId}/versions/${version}/restore`);
+    if (!res.ok) {
+        const data = await res.json().catch(() => ({}));
+        (0, output_1.error)(data.error?.message || `Failed to restore version: ${res.status}`);
+        process.exit(1);
+    }
+    const doc = await res.json();
+    (0, output_1.success)(`Restored ${docId} to version ${version}`);
+    (0, output_1.printJson)(doc);
+}

package/dist/commands/webhooks.d.ts

@@ -0,0 +1,17 @@
+import { ApiClient } from "../lib/client";
+export declare function listWebhooksCommand(collection: string, client: ApiClient): Promise<void>;
+export declare function createWebhookCommand(collection: string, client: ApiClient, options: {
+    url: string;
+    events: string;
+    description?: string;
+    secret?: string;
+}): Promise<void>;
+export declare function getWebhookCommand(collection: string, webhookId: string, client: ApiClient): Promise<void>;
+export declare function updateWebhookCommand(collection: string, webhookId: string, client: ApiClient, options: {
+    url?: string;
+    events?: string;
+    description?: string;
+    status?: string;
+}): Promise<void>;
+export declare function deleteWebhookCommand(collection: string, webhookId: string, client: ApiClient): Promise<void>;
+export declare function testWebhookCommand(collection: string, webhookId: string, client: ApiClient): Promise<void>;

package/dist/commands/webhooks.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listWebhooksCommand = listWebhooksCommand;
+exports.createWebhookCommand = createWebhookCommand;
+exports.getWebhookCommand = getWebhookCommand;
+exports.updateWebhookCommand = updateWebhookCommand;
+exports.deleteWebhookCommand = deleteWebhookCommand;
+exports.testWebhookCommand = testWebhookCommand;
+const output_1 = require("../lib/output");
+async function listWebhooksCommand(collection, client) {
+    const res = await client.get(`${collection}/_webhooks`);
+    if (!res.ok) {
+        const data = await res.json().catch(() => ({}));
+        (0, output_1.error)(data.error?.message || `Failed to list webhooks: ${res.status}`);
+        process.exit(1);
+    }
+    const data = await res.json();
+    const webhooks = data.webhooks || data.data || data;
+    if (Array.isArray(webhooks) && webhooks.length > 0) {
+        (0, output_1.printTable)(["ID", "URL", "Events", "Status"], webhooks.map((w) => [
+            w._id || "",
+            w.url || "",
+            Array.isArray(w.events) ? w.events.join(", ") : "",
+            w.status || "",
+        ]));
+    }
+    else {
+        console.log("No webhooks found.");
+    }
+}
+async function createWebhookCommand(collection, client, options) {
+    const events = options.events.split(",").map((e) => e.trim());
+    const body = { url: options.url, events };
+    if (options.description)
+        body.description = options.description;
+    if (options.secret)
+        body.secret = options.secret;
+    const res = await client.post(`${collection}/_webhooks`, body);
+    if (!res.ok) {
+        const data = await res.json().catch(() => ({}));
+        (0, output_1.error)(data.error?.message || `Failed to create webhook: ${res.status}`);
+        process.exit(1);
+    }
+    const webhook = await res.json();
+    (0, output_1.success)(`Created webhook ${webhook._id}`);
+    (0, output_1.printJson)(webhook);
+}
+async function getWebhookCommand(collection, webhookId, client) {
+    const res = await client.get(`${collection}/_webhooks/${webhookId}`);
+    if (!res.ok) {
+        const data = await res.json().catch(() => ({}));
+        (0, output_1.error)(data.error?.message || `Failed to get webhook: ${res.status}`);
+        process.exit(1);
+    }
+    const webhook = await res.json();
+    (0, output_1.printJson)(webhook);
+}
+async function updateWebhookCommand(collection, webhookId, client, options) {
+    const body = {};
+    if (options.url)
+        body.url = options.url;
+    if (options.events)
+        body.events = options.events.split(",").map((e) => e.trim());
+    if (options.description)
+        body.description = options.description;
+    if (options.status)
+        body.status = options.status;
+    if (Object.keys(body).length === 0) {
+        (0, output_1.error)("No update options provided. Use --url, --events, --description, or --status.");
+        process.exit(1);
+    }
+    const res = await client.put(`${collection}/_webhooks/${webhookId}`, body);
+    if (!res.ok) {
+        const data = await res.json().catch(() => ({}));
+        (0, output_1.error)(data.error?.message || `Failed to update webhook: ${res.status}`);
+        process.exit(1);
+    }
+    const webhook = await res.json();
+    (0, output_1.success)(`Updated webhook ${webhookId}`);
+    (0, output_1.printJson)(webhook);
+}
+async function deleteWebhookCommand(collection, webhookId, client) {
+    const res = await client.delete(`${collection}/_webhooks/${webhookId}`);
+    if (!res.ok && res.status !== 204) {
+        const data = await res.json().catch(() => ({}));
+        (0, output_1.error)(data.error?.message || `Failed to delete webhook: ${res.status}`);
+        process.exit(1);
+    }
+    (0, output_1.success)(`Deleted webhook ${webhookId}`);
+}
+async function testWebhookCommand(collection, webhookId, client) {
+    const res = await client.post(`${collection}/_webhooks/${webhookId}/test`);
+    if (!res.ok) {
+        const data = await res.json().catch(() => ({}));
+        (0, output_1.error)(data.error?.message || `Failed to test webhook: ${res.status}`);
+        process.exit(1);
+    }
+    const result = await res.json();
+    (0, output_1.success)(`Test event sent for webhook ${webhookId}`);
+    (0, output_1.printJson)(result);
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,281 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const config_1 = require("./lib/config");
+const client_1 = require("./lib/client");
+const output_1 = require("./lib/output");
+const login_1 = require("./commands/login");
+const documents_1 = require("./commands/documents");
+const push_1 = require("./commands/push");
+const pull_1 = require("./commands/pull");
+const keys_1 = require("./commands/keys");
+const schema_1 = require("./commands/schema");
+const versions_1 = require("./commands/versions");
+const webhooks_1 = require("./commands/webhooks");
+const extras_1 = require("./commands/extras");
+const program = new commander_1.Command();
+program
+    .name("jsondb")
+    .description("The jsondb.cloud CLI — manage your JSON database from the terminal")
+    .version("1.0.0")
+    .option("--api-key <key>", "Use a specific API key")
+    .option("--project <ns>", "Target project (default: \"default\")")
+    .option("--base-url <url>", "API base URL")
+    .option("--format <fmt>", "Output format: json, raw, ndjson, table");
+function getClient() {
+    const opts = program.opts();
+    const config = (0, config_1.loadConfig)();
+    const apiKey = opts.apiKey || config?.apiKey;
+    if (!apiKey) {
+        (0, output_1.error)("Not authenticated", "Run `jsondb login` to authenticate, or pass --api-key");
+        process.exit(1);
+    }
+    return new client_1.ApiClient({
+        apiKey,
+        project: opts.project || config?.project || "default",
+        baseUrl: opts.baseUrl || config?.baseUrl || "https://api.jsondb.cloud",
+    });
+}
+// ─── Auth commands ───
+program
+    .command("login")
+    .description("Authenticate with jsondb.cloud")
+    .option("--api-key <key>", "API key to use")
+    .option("--project <ns>", "Default project")
+    .option("--base-url <url>", "API base URL")
+    .action(async (opts) => {
+    await (0, login_1.loginCommand)(opts);
+});
+program
+    .command("logout")
+    .description("Remove stored credentials")
+    .action(() => {
+    (0, config_1.clearConfig)();
+    (0, output_1.success)("Logged out. Credentials removed.");
+});
+program
+    .command("whoami")
+    .description("Show current configuration")
+    .action(() => {
+    const config = (0, config_1.loadConfig)();
+    if (!config) {
+        (0, output_1.error)("Not authenticated", "Run `jsondb login` to authenticate");
+        process.exit(1);
+    }
+    console.log(`  API Key: ${config.apiKey.slice(0, 16)}...${config.apiKey.slice(-4)}`);
+    console.log(`  Project: ${config.project}`);
+    console.log(`  Base URL: ${config.baseUrl}`);
+});
+// ─── Document commands ───
+program
+    .command("get <path>")
+    .description("Read a document (e.g., users/usr_abc123)")
+    .option("--format <fmt>", "Output format: json, raw")
+    .action(async (path, opts) => {
+    await (0, documents_1.getCommand)(path, getClient(), opts);
+});
+program
+    .command("create <collection>")
+    .description("Create a document from stdin or file")
+    .option("--file <file>", "Read document from file")
+    .option("--id <id>", "Explicit document ID")
+    .action(async (collection, opts) => {
+    await (0, documents_1.createCommand)(collection, getClient(), opts);
+});
+program
+    .command("update <path>")
+    .description("Replace a document (e.g., users/usr_abc123)")
+    .option("--file <file>", "Read document from file")
+    .action(async (path, opts) => {
+    await (0, documents_1.updateCommand)(path, getClient(), opts);
+});
+program
+    .command("patch <path>")
+    .description("Partial update a document")
+    .option("--file <file>", "Read patch from file")
+    .action(async (path, opts) => {
+    await (0, documents_1.patchCommand)(path, getClient(), opts);
+});
+program
+    .command("delete <path>")
+    .description("Delete a document")
+    .action(async (path) => {
+    await (0, documents_1.deleteCommand)(path, getClient());
+});
+// ─── Collection commands ───
+program
+    .command("collections")
+    .description("List collections in the project")
+    .action(async () => {
+    await (0, documents_1.listCollectionsCommand)(getClient());
+});
+program
+    .command("documents <collection>")
+    .description("List documents in a collection")
+    .option("--limit <n>", "Max documents to show")
+    .option("--format <fmt>", "Output format: json, raw")
+    .action(async (collection, opts) => {
+    await (0, documents_1.listDocumentsCommand)(collection, getClient(), opts);
+});
+// ─── Import / Export ───
+program
+    .command("push <file>")
+    .description("Import documents from JSON/CSV/NDJSON file")
+    .requiredOption("--to <collection>", "Target collection")
+    .option("--on-conflict <strategy>", "Conflict strategy: fail, skip, overwrite", "fail")
+    .action(async (file, opts) => {
+    await (0, push_1.pushCommand)(file, getClient(), opts);
+});
+program
+    .command("pull <collection>")
+    .description("Export documents to stdout or file")
+    .option("--out <file>", "Output file path")
+    .option("--format <fmt>", "Format: json, csv, ndjson", "json")
+    .option("--filter <expr>", "Filter expression (field=value)")
+    .action(async (collection, opts) => {
+    await (0, pull_1.pullCommand)(collection, getClient(), opts);
+});
+// ─── Key management ───
+const keys = program.command("keys").description("Manage API keys");
+keys
+    .command("list")
+    .description("List API keys")
+    .action(async () => {
+    await (0, keys_1.listKeysCommand)(getClient());
+});
+keys
+    .command("create")
+    .description("Create a new API key")
+    .option("--name <name>", "Key name")
+    .option("--scope <scope>", "Scope: read-only, read-write", "read-write")
+    .option("--project <ns>", "Target project")
+    .action(async (opts) => {
+    (0, output_1.error)("Key creation requires dashboard authentication. Use the web dashboard at https://jsondb.cloud/dashboard/api-keys");
+    process.exit(1);
+});
+keys
+    .command("revoke <id>")
+    .description("Revoke an API key")
+    .action(async (id) => {
+    (0, output_1.error)("Key revocation requires dashboard authentication. Use the web dashboard at https://jsondb.cloud/dashboard/api-keys");
+    process.exit(1);
+});
+// ─── Schema ───
+const schema = program.command("schema").description("Manage collection schemas");
+schema
+    .command("get <collection>")
+    .description("Get collection schema")
+    .action(async (collection) => {
+    await (0, schema_1.getSchemaCommand)(collection, getClient());
+});
+schema
+    .command("set <collection>")
+    .description("Set collection schema from file or stdin")
+    .option("--file <file>", "Schema JSON file")
+    .action(async (collection, opts) => {
+    await (0, schema_1.setSchemaCommand)(collection, getClient(), opts);
+});
+schema
+    .command("remove <collection>")
+    .description("Remove collection schema")
+    .action(async (collection) => {
+    await (0, schema_1.removeSchemaCommand)(collection, getClient());
+});
+// ─── Versions ───
+const versions = program.command("versions").description("Manage document version history");
+versions
+    .command("list <collection> <id>")
+    .description("List versions of a document")
+    .action(async (collection, id) => {
+    await (0, versions_1.listVersionsCommand)(collection, id, getClient());
+});
+versions
+    .command("get <collection> <id> <version>")
+    .description("Get a document at a specific version")
+    .action(async (collection, id, version) => {
+    await (0, versions_1.getVersionCommand)(collection, id, version, getClient());
+});
+versions
+    .command("diff <collection> <id>")
+    .description("Diff two versions of a document")
+    .requiredOption("--from <version>", "From version number")
+    .requiredOption("--to <version>", "To version number")
+    .action(async (collection, id, opts) => {
+    await (0, versions_1.diffVersionsCommand)(collection, id, getClient(), opts);
+});
+versions
+    .command("restore <collection> <id> <version>")
+    .description("Restore a document to a specific version")
+    .action(async (collection, id, version) => {
+    await (0, versions_1.restoreVersionCommand)(collection, id, version, getClient());
+});
+// ─── Webhooks ───
+const webhooks = program.command("webhooks").description("Manage collection webhooks");
+webhooks
+    .command("list <collection>")
+    .description("List webhooks for a collection")
+    .action(async (collection) => {
+    await (0, webhooks_1.listWebhooksCommand)(collection, getClient());
+});
+webhooks
+    .command("create <collection>")
+    .description("Create a webhook")
+    .requiredOption("--url <url>", "Webhook endpoint URL")
+    .requiredOption("--events <events>", "Comma-separated events (document.created,document.updated,document.deleted)")
+    .option("--description <desc>", "Webhook description")
+    .option("--secret <secret>", "HMAC signing secret")
+    .action(async (collection, opts) => {
+    await (0, webhooks_1.createWebhookCommand)(collection, getClient(), opts);
+});
+webhooks
+    .command("get <collection> <id>")
+    .description("Get webhook details and recent deliveries")
+    .action(async (collection, id) => {
+    await (0, webhooks_1.getWebhookCommand)(collection, id, getClient());
+});
+webhooks
+    .command("update <collection> <id>")
+    .description("Update a webhook")
+    .option("--url <url>", "New endpoint URL")
+    .option("--events <events>", "New comma-separated events")
+    .option("--description <desc>", "New description")
+    .option("--status <status>", "Status: active or disabled")
+    .action(async (collection, id, opts) => {
+    await (0, webhooks_1.updateWebhookCommand)(collection, id, getClient(), opts);
+});
+webhooks
+    .command("delete <collection> <id>")
+    .description("Delete a webhook")
+    .action(async (collection, id) => {
+    await (0, webhooks_1.deleteWebhookCommand)(collection, id, getClient());
+});
+webhooks
+    .command("test <collection> <id>")
+    .description("Send a test event to a webhook")
+    .action(async (collection, id) => {
+    await (0, webhooks_1.testWebhookCommand)(collection, id, getClient());
+});
+// ─── Validate / Count / Bulk ───
+program
+    .command("validate <collection>")
+    .description("Dry-run schema validation against a document")
+    .option("--file <file>", "Read document from file (otherwise reads stdin)")
+    .action(async (collection, opts) => {
+    await (0, extras_1.validateCommand)(collection, getClient(), opts);
+});
+program
+    .command("count <collection>")
+    .description("Count documents in a collection")
+    .option("--filter <expr...>", "Filter expressions (field=value)")
+    .action(async (collection, opts) => {
+    await (0, extras_1.countCommand)(collection, getClient(), opts);
+});
+program
+    .command("bulk <collection>")
+    .description("Execute bulk operations from stdin or file")
+    .option("--file <file>", "Read operations from file (otherwise reads stdin)")
+    .action(async (collection, opts) => {
+    await (0, extras_1.bulkCommand)(collection, getClient(), opts);
+});
+// Parse and execute
+program.parse();

package/dist/lib/client.d.ts

@@ -0,0 +1,15 @@
+import type { CliConfig } from "./config";
+export declare class ApiClient {
+    private config;
+    constructor(config: CliConfig);
+    private url;
+    private headers;
+    get(path: string, accept?: string): Promise<Response>;
+    post(path: string, body?: unknown, extraHeaders?: Record<string, string>): Promise<Response>;
+    postRaw(path: string, body: string, contentType: string): Promise<Response>;
+    put(path: string, body: unknown): Promise<Response>;
+    patch(path: string, body: unknown, contentType?: string): Promise<Response>;
+    delete(path: string): Promise<Response>;
+    /** Raw API call without project prefix */
+    rawGet(fullPath: string): Promise<Response>;
+}

package/dist/lib/client.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiClient = void 0;
+class ApiClient {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    url(path) {
+        const base = this.config.baseUrl.replace(/\/$/, "");
+        return `${base}/${this.config.project}/${path}`;
+    }
+    headers(extra) {
+        return {
+            Authorization: `Bearer ${this.config.apiKey}`,
+            "Content-Type": "application/json",
+            ...extra,
+        };
+    }
+    async get(path, accept) {
+        const headers = this.headers(accept ? { Accept: accept } : undefined);
+        return fetch(this.url(path), { method: "GET", headers });
+    }
+    async post(path, body, extraHeaders) {
+        return fetch(this.url(path), {
+            method: "POST",
+            headers: this.headers(extraHeaders),
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+        });
+    }
+    async postRaw(path, body, contentType) {
+        return fetch(this.url(path), {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${this.config.apiKey}`,
+                "Content-Type": contentType,
+            },
+            body,
+        });
+    }
+    async put(path, body) {
+        return fetch(this.url(path), {
+            method: "PUT",
+            headers: this.headers(),
+            body: JSON.stringify(body),
+        });
+    }
+    async patch(path, body, contentType) {
+        return fetch(this.url(path), {
+            method: "PATCH",
+            headers: this.headers(contentType ? { "Content-Type": contentType } : undefined),
+            body: JSON.stringify(body),
+        });
+    }
+    async delete(path) {
+        return fetch(this.url(path), {
+            method: "DELETE",
+            headers: this.headers(),
+        });
+    }
+    /** Raw API call without project prefix */
+    async rawGet(fullPath) {
+        const base = this.config.baseUrl.replace(/\/$/, "");
+        return fetch(`${base}${fullPath}`, {
+            method: "GET",
+            headers: this.headers(),
+        });
+    }
+}
+exports.ApiClient = ApiClient;

package/dist/lib/config.d.ts

@@ -0,0 +1,9 @@
+export interface CliConfig {
+    apiKey: string;
+    project: string;
+    baseUrl: string;
+}
+export declare function loadConfig(): CliConfig | null;
+export declare function saveConfig(config: CliConfig): void;
+export declare function clearConfig(): void;
+export declare function getConfigPath(): string;