@sendly/cli 3.18.0 → 3.18.3

package/dist/commands/enterprise/keys/list.js

@@ -0,0 +1,69 @@
+import { Args } from "@oclif/core";
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient } from "../../../lib/api-client.js";
+import { table, json, info, colors, isJsonMode, formatRelativeTime, } from "../../../lib/output.js";
+export default class EnterpriseKeysList extends AuthenticatedCommand {
+    static description = "List API keys for an enterprise workspace";
+    static examples = [
+        "<%= config.bin %> enterprise keys list org_abc123",
+        "<%= config.bin %> enterprise keys list org_abc123 --json",
+    ];
+    static args = {
+        workspaceId: Args.string({
+            description: "Workspace ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(EnterpriseKeysList);
+        const response = await apiClient.get(`/api/v1/enterprise/workspaces/${args.workspaceId}/keys`);
+        if (isJsonMode()) {
+            json(response.keys);
+            return;
+        }
+        if (response.keys.length === 0) {
+            info("No API keys found for this workspace");
+            console.log();
+            console.log(`  Create one with ${colors.code(`sendly enterprise keys create ${args.workspaceId}`)}`);
+            return;
+        }
+        console.log();
+        table(response.keys, [
+            { header: "Name", key: "name", width: 20 },
+            {
+                header: "Key ID",
+                key: "id",
+                width: 18,
+                formatter: (v) => colors.dim(String(v).slice(0, 16)),
+            },
+            {
+                header: "Prefix",
+                key: "prefix",
+                width: 16,
+                formatter: (v) => colors.code(String(v)),
+            },
+            {
+                header: "Type",
+                key: "type",
+                width: 8,
+                formatter: (v) => v === "test" ? colors.warning("test") : colors.success("live"),
+            },
+            {
+                header: "Status",
+                key: "isActive",
+                width: 10,
+                formatter: (v) => v ? colors.success("active") : colors.error("revoked"),
+            },
+            {
+                header: "Last Used",
+                key: "lastUsedAt",
+                width: 12,
+                formatter: (v) => v ? formatRelativeTime(String(v)) : colors.dim("never"),
+            },
+        ]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/enterprise/keys/revoke.d.ts

@@ -0,0 +1,15 @@
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+export default class EnterpriseKeysRevoke extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        workspaceId: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+        keyId: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        yes: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/enterprise/keys/revoke.js

@@ -0,0 +1,57 @@
+import { Args, Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient } from "../../../lib/api-client.js";
+import { success, error, json, isJsonMode } from "../../../lib/output.js";
+import inquirer from "inquirer";
+export default class EnterpriseKeysRevoke extends AuthenticatedCommand {
+    static description = "Revoke an API key for an enterprise workspace";
+    static examples = [
+        "<%= config.bin %> enterprise keys revoke org_abc123 key_xyz",
+        "<%= config.bin %> enterprise keys revoke org_abc123 key_xyz --yes",
+    ];
+    static args = {
+        workspaceId: Args.string({
+            description: "Workspace ID",
+            required: true,
+        }),
+        keyId: Args.string({
+            description: "API key ID to revoke",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        yes: Flags.boolean({
+            char: "y",
+            description: "Skip confirmation prompt",
+            default: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(EnterpriseKeysRevoke);
+        if (!flags.yes && !isJsonMode()) {
+            const { confirm } = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "confirm",
+                    message: `Revoke API key ${args.keyId}? This cannot be undone.`,
+                    default: false,
+                },
+            ]);
+            if (!confirm) {
+                error("Revocation cancelled");
+                return;
+            }
+        }
+        await apiClient.delete(`/api/v1/enterprise/workspaces/${args.workspaceId}/keys/${args.keyId}`);
+        if (isJsonMode()) {
+            json({ success: true, keyId: args.keyId });
+            return;
+        }
+        success("API key revoked", {
+            "Key ID": args.keyId,
+            Workspace: args.workspaceId,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/enterprise/provision.d.ts

@@ -0,0 +1,17 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class EnterpriseProvision extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        name: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        credits: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "inherit-from": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "webhook-url": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "create-key": import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        bulk: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private bulkProvision;
+}

package/dist/commands/enterprise/provision.js

@@ -0,0 +1,143 @@
+import { Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, json, table, colors, isJsonMode, spinner, } from "../../lib/output.js";
+import * as fs from "node:fs";
+export default class EnterpriseProvision extends AuthenticatedCommand {
+    static description = "Provision a new workspace with full setup, or bulk provision from a JSON file";
+    static examples = [
+        '<%= config.bin %> enterprise provision --name "Acme Corp" --credits 1000',
+        '<%= config.bin %> enterprise provision --name "Acme Corp" --credits 500 --inherit-from org_abc123 --webhook-url https://example.com/hook',
+        "<%= config.bin %> enterprise provision --bulk workspaces.json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        name: Flags.string({
+            char: "n",
+            description: "Workspace name (single provision)",
+        }),
+        credits: Flags.integer({
+            char: "c",
+            description: "Initial credits to allocate",
+        }),
+        "inherit-from": Flags.string({
+            description: "Workspace ID to inherit verification from",
+        }),
+        "webhook-url": Flags.string({
+            description: "Webhook URL for the workspace",
+        }),
+        "create-key": Flags.boolean({
+            description: "Create an API key for the workspace",
+            default: false,
+        }),
+        bulk: Flags.string({
+            char: "b",
+            description: "Path to JSON file for bulk provisioning (up to 50 workspaces)",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(EnterpriseProvision);
+        if (flags.bulk) {
+            await this.bulkProvision(flags.bulk);
+            return;
+        }
+        if (!flags.name) {
+            this.error("--name is required for single provisioning. Use --bulk for batch provisioning.");
+        }
+        const spin = spinner("Provisioning workspace...");
+        spin.start();
+        const body = { name: flags.name };
+        if (flags.credits)
+            body.credits = flags.credits;
+        if (flags["inherit-from"])
+            body.inheritVerificationFrom = flags["inherit-from"];
+        if (flags["webhook-url"])
+            body.webhookUrl = flags["webhook-url"];
+        if (flags["create-key"])
+            body.createApiKey = true;
+        const response = await apiClient.post("/api/v1/enterprise/workspaces/provision", body);
+        spin.succeed("Workspace provisioned");
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        const details = {
+            ID: response.organization.id,
+            Name: response.organization.name,
+            Slug: response.organization.slug,
+        };
+        if (response.verification) {
+            details["Verification"] = response.verification.status === "approved"
+                ? colors.success("inherited")
+                : colors.warning(response.verification.status);
+        }
+        if (response.credits) {
+            details["Credits"] = `${response.credits.balance.toLocaleString()} credits`;
+        }
+        if (response.apiKey) {
+            details["API Key"] = response.apiKey.key;
+        }
+        if (response.webhook) {
+            details["Webhook"] = response.webhook.url;
+        }
+        success("Workspace provisioned", details);
+        if (response.apiKey) {
+            console.log();
+            console.log(colors.warning("  Save the API key now — it won't be shown again."));
+        }
+    }
+    async bulkProvision(filePath) {
+        if (!fs.existsSync(filePath)) {
+            this.error(`File not found: ${filePath}`);
+        }
+        const content = fs.readFileSync(filePath, "utf-8");
+        let workspaces;
+        try {
+            workspaces = JSON.parse(content);
+        }
+        catch {
+            this.error("Invalid JSON file. Expected an array of workspace objects.");
+        }
+        if (!Array.isArray(workspaces)) {
+            this.error("JSON file must contain an array of workspace objects.");
+        }
+        if (workspaces.length > 50) {
+            this.error("Bulk provisioning supports up to 50 workspaces at a time.");
+        }
+        const spin = spinner(`Provisioning ${workspaces.length} workspaces...`);
+        spin.start();
+        const response = await apiClient.post("/api/v1/enterprise/workspaces/provision/bulk", { workspaces });
+        spin.succeed(`Provisioned ${response.totalCreated}/${response.totalRequested} workspaces`);
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        console.log();
+        table(response.results, [
+            { header: "Name", key: "name", width: 24 },
+            {
+                header: "Status",
+                key: "success",
+                width: 10,
+                formatter: (v) => v ? colors.success("created") : colors.error("failed"),
+            },
+            {
+                header: "Workspace ID",
+                key: "workspaceId",
+                width: 20,
+                formatter: (v) => (v ? colors.dim(String(v)) : colors.dim("—")),
+            },
+            {
+                header: "Error",
+                key: "error",
+                width: 30,
+                formatter: (v) => (v ? colors.error(String(v)) : ""),
+            },
+        ]);
+        if (response.totalFailed > 0) {
+            console.log();
+            console.log(colors.warning(`  ${response.totalFailed} workspace(s) failed to provision.`));
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"provision.js","sourceRoot":"","sources":["../../../src/commands/enterprise/provision.ts"],"names":[],"mappings":"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","sourcesContent":["import { Flags } from \"@oclif/core\";\nimport { AuthenticatedCommand } from \"../../lib/base-command.js\";\nimport { apiClient } from \"../../lib/api-client.js\";\nimport {\n  success,\n  json,\n  table,\n  colors,\n  isJsonMode,\n  spinner,\n} from \"../../lib/output.js\";\nimport * as fs from \"node:fs\";\n\ninterface ProvisionResponse {\n  organization: { id: string; name: string; slug: string };\n  verification?: { status: string };\n  credits?: { balance: number };\n  apiKey?: { id: string; key: string; prefix: string };\n  webhook?: { url: string };\n  optInPage?: { id: string; slug: string };\n}\n\ninterface BulkProvisionItem {\n  name: string;\n  credits?: number;\n  inheritVerificationFrom?: string;\n  webhookUrl?: string;\n  createApiKey?: boolean;\n}\n\ninterface BulkResultItem {\n  name: string;\n  success: boolean;\n  workspaceId?: string;\n  error?: string;\n}\n\ninterface BulkProvisionResponse {\n  results: BulkResultItem[];\n  totalRequested: number;\n  totalCreated: number;\n  totalFailed: number;\n}\n\nexport default class EnterpriseProvision extends AuthenticatedCommand {\n  static description = \"Provision a new workspace with full setup, or bulk provision from a JSON file\";\n\n  static examples = [\n    '<%= config.bin %> enterprise provision --name \"Acme Corp\" --credits 1000',\n    '<%= config.bin %> enterprise provision --name \"Acme Corp\" --credits 500 --inherit-from org_abc123 --webhook-url https://example.com/hook',\n    \"<%= config.bin %> enterprise provision --bulk workspaces.json\",\n  ];\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n    name: Flags.string({\n      char: \"n\",\n      description: \"Workspace name (single provision)\",\n    }),\n    credits: Flags.integer({\n      char: \"c\",\n      description: \"Initial credits to allocate\",\n    }),\n    \"inherit-from\": Flags.string({\n      description: \"Workspace ID to inherit verification from\",\n    }),\n    \"webhook-url\": Flags.string({\n      description: \"Webhook URL for the workspace\",\n    }),\n    \"create-key\": Flags.boolean({\n      description: \"Create an API key for the workspace\",\n      default: false,\n    }),\n    bulk: Flags.string({\n      char: \"b\",\n      description: \"Path to JSON file for bulk provisioning (up to 50 workspaces)\",\n    }),\n  };\n\n  async run(): Promise<void> {\n    const { flags } = await this.parse(EnterpriseProvision);\n\n    if (flags.bulk) {\n      await this.bulkProvision(flags.bulk);\n      return;\n    }\n\n    if (!flags.name) {\n      this.error(\"--name is required for single provisioning. Use --bulk for batch provisioning.\");\n    }\n\n    const spin = spinner(\"Provisioning workspace...\");\n    spin.start();\n\n    const body: Record<string, unknown> = { name: flags.name };\n    if (flags.credits) body.credits = flags.credits;\n    if (flags[\"inherit-from\"]) body.inheritVerificationFrom = flags[\"inherit-from\"];\n    if (flags[\"webhook-url\"]) body.webhookUrl = flags[\"webhook-url\"];\n    if (flags[\"create-key\"]) body.createApiKey = true;\n\n    const response = await apiClient.post<ProvisionResponse>(\n      \"/api/v1/enterprise/workspaces/provision\",\n      body,\n    );\n\n    spin.succeed(\"Workspace provisioned\");\n\n    if (isJsonMode()) {\n      json(response);\n      return;\n    }\n\n    const details: Record<string, string> = {\n      ID: response.organization.id,\n      Name: response.organization.name,\n      Slug: response.organization.slug,\n    };\n\n    if (response.verification) {\n      details[\"Verification\"] = response.verification.status === \"approved\"\n        ? colors.success(\"inherited\")\n        : colors.warning(response.verification.status);\n    }\n    if (response.credits) {\n      details[\"Credits\"] = `${response.credits.balance.toLocaleString()} credits`;\n    }\n    if (response.apiKey) {\n      details[\"API Key\"] = response.apiKey.key;\n    }\n    if (response.webhook) {\n      details[\"Webhook\"] = response.webhook.url;\n    }\n\n    success(\"Workspace provisioned\", details);\n\n    if (response.apiKey) {\n      console.log();\n      console.log(\n        colors.warning(\"  Save the API key now — it won't be shown again.\"),\n      );\n    }\n  }\n\n  private async bulkProvision(filePath: string): Promise<void> {\n    if (!fs.existsSync(filePath)) {\n      this.error(`File not found: ${filePath}`);\n    }\n\n    const content = fs.readFileSync(filePath, \"utf-8\");\n    let workspaces: BulkProvisionItem[];\n\n    try {\n      workspaces = JSON.parse(content);\n    } catch {\n      this.error(\"Invalid JSON file. Expected an array of workspace objects.\");\n    }\n\n    if (!Array.isArray(workspaces)) {\n      this.error(\"JSON file must contain an array of workspace objects.\");\n    }\n\n    if (workspaces.length > 50) {\n      this.error(\"Bulk provisioning supports up to 50 workspaces at a time.\");\n    }\n\n    const spin = spinner(`Provisioning ${workspaces.length} workspaces...`);\n    spin.start();\n\n    const response = await apiClient.post<BulkProvisionResponse>(\n      \"/api/v1/enterprise/workspaces/provision/bulk\",\n      { workspaces },\n    );\n\n    spin.succeed(\n      `Provisioned ${response.totalCreated}/${response.totalRequested} workspaces`,\n    );\n\n    if (isJsonMode()) {\n      json(response);\n      return;\n    }\n\n    console.log();\n    table(response.results, [\n      { header: \"Name\", key: \"name\", width: 24 },\n      {\n        header: \"Status\",\n        key: \"success\",\n        width: 10,\n        formatter: (v) =>\n          v ? colors.success(\"created\") : colors.error(\"failed\"),\n      },\n      {\n        header: \"Workspace ID\",\n        key: \"workspaceId\",\n        width: 20,\n        formatter: (v) => (v ? colors.dim(String(v)) : colors.dim(\"—\")),\n      },\n      {\n        header: \"Error\",\n        key: \"error\",\n        width: 30,\n        formatter: (v) => (v ? colors.error(String(v)) : \"\"),\n      },\n    ]);\n\n    if (response.totalFailed > 0) {\n      console.log();\n      console.log(\n        colors.warning(\n          `  ${response.totalFailed} workspace(s) failed to provision.`,\n        ),\n      );\n    }\n  }\n}\n"]}

package/dist/commands/enterprise/quota/get.d.ts

@@ -0,0 +1,13 @@
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+export default class QuotaGet extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        workspaceId: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/enterprise/quota/get.js

@@ -0,0 +1,40 @@
+import { Args } from "@oclif/core";
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient } from "../../../lib/api-client.js";
+import { json, keyValue, colors, header, isJsonMode, } from "../../../lib/output.js";
+export default class QuotaGet extends AuthenticatedCommand {
+    static description = "Get message quota for an enterprise workspace";
+    static examples = [
+        "<%= config.bin %> enterprise quota get org_abc123",
+        "<%= config.bin %> enterprise quota get org_abc123 --json",
+    ];
+    static args = {
+        workspaceId: Args.string({
+            description: "Workspace ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(QuotaGet);
+        const quota = await apiClient.get(`/api/v1/enterprise/workspaces/${args.workspaceId}/quota`);
+        if (isJsonMode()) {
+            json(quota);
+            return;
+        }
+        header("Workspace Quota");
+        keyValue({
+            "Daily Limit": quota.dailyLimit !== null
+                ? quota.dailyLimit.toLocaleString()
+                : colors.dim("unlimited"),
+            "Daily Used": `${quota.dailyUsed.toLocaleString()}${quota.dailyLimit ? ` / ${quota.dailyLimit.toLocaleString()}` : ""}`,
+            "Monthly Limit": quota.monthlyLimit !== null
+                ? quota.monthlyLimit.toLocaleString()
+                : colors.dim("unlimited"),
+            "Monthly Used": `${quota.monthlyUsed.toLocaleString()}${quota.monthlyLimit ? ` / ${quota.monthlyLimit.toLocaleString()}` : ""}`,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/enterprise/quota/set.d.ts

@@ -0,0 +1,15 @@
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+export default class QuotaSet extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        workspaceId: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        daily: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        monthly: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/enterprise/quota/set.js

@@ -0,0 +1,69 @@
+import { Args, Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient } from "../../../lib/api-client.js";
+import { success, json, colors, isJsonMode } from "../../../lib/output.js";
+export default class QuotaSet extends AuthenticatedCommand {
+    static description = "Set message quota for an enterprise workspace";
+    static examples = [
+        "<%= config.bin %> enterprise quota set org_abc123 --daily 1000",
+        "<%= config.bin %> enterprise quota set org_abc123 --monthly 25000",
+        "<%= config.bin %> enterprise quota set org_abc123 --daily 1000 --monthly 25000",
+        "<%= config.bin %> enterprise quota set org_abc123 --daily unlimited",
+    ];
+    static args = {
+        workspaceId: Args.string({
+            description: "Workspace ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        daily: Flags.string({
+            description: 'Daily message limit (number or "unlimited")',
+        }),
+        monthly: Flags.string({
+            description: 'Monthly message limit (number or "unlimited")',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(QuotaSet);
+        if (!flags.daily && !flags.monthly) {
+            this.error("Specify at least one of --daily or --monthly.");
+        }
+        const body = {};
+        if (flags.daily !== undefined) {
+            body.dailyLimit =
+                flags.daily === "unlimited" ? null : parseInt(flags.daily, 10);
+            if (flags.daily !== "unlimited" && isNaN(body.dailyLimit)) {
+                this.error('--daily must be a number or "unlimited".');
+            }
+        }
+        if (flags.monthly !== undefined) {
+            body.monthlyLimit =
+                flags.monthly === "unlimited" ? null : parseInt(flags.monthly, 10);
+            if (flags.monthly !== "unlimited" && isNaN(body.monthlyLimit)) {
+                this.error('--monthly must be a number or "unlimited".');
+            }
+        }
+        const quota = await apiClient.put(`/api/v1/enterprise/workspaces/${args.workspaceId}/quota`, body);
+        if (isJsonMode()) {
+            json(quota);
+            return;
+        }
+        const details = {};
+        if (flags.daily !== undefined) {
+            details["Daily Limit"] =
+                quota.dailyLimit !== null
+                    ? quota.dailyLimit.toLocaleString()
+                    : colors.dim("unlimited");
+        }
+        if (flags.monthly !== undefined) {
+            details["Monthly Limit"] =
+                quota.monthlyLimit !== null
+                    ? quota.monthlyLimit.toLocaleString()
+                    : colors.dim("unlimited");
+        }
+        success("Quota updated", details);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/enterprise/status.d.ts

@@ -0,0 +1,10 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class EnterpriseStatus extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/enterprise/status.js

@@ -0,0 +1,45 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { json, keyValue, colors, header, isJsonMode, formatDate, formatCredits, } from "../../lib/output.js";
+export default class EnterpriseStatus extends AuthenticatedCommand {
+    static description = "Show enterprise account status";
+    static examples = [
+        "<%= config.bin %> enterprise status",
+        "<%= config.bin %> enterprise status --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const response = await apiClient.get("/api/v1/enterprise/account");
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        const { account, workspaceCount } = response;
+        header("Enterprise Account");
+        const statusColor = account.status === "active"
+            ? colors.success
+            : account.status === "pending"
+                ? colors.warning
+                : colors.error;
+        keyValue({
+            Company: colors.primary(account.companyName),
+            Status: statusColor(account.status),
+            Workspaces: `${workspaceCount} / ${account.maxWorkspaces}`,
+            "Credits Allocated": formatCredits(account.totalCreditsAllocated),
+            "Platform Fee": account.monthlyPlatformFee
+                ? `$${account.monthlyPlatformFee}/mo`
+                : colors.dim("not set"),
+            "Per-Workspace Fee": account.perWorkspaceFee
+                ? `$${account.perWorkspaceFee}/mo`
+                : colors.dim("not set"),
+            "Enterprise Webhook": account.webhookUrl || colors.dim("not configured"),
+            "Activated At": account.activatedAt
+                ? formatDate(account.activatedAt)
+                : colors.dim("pending"),
+            "Created At": formatDate(account.createdAt),
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/enterprise/transfer-credits.d.ts

@@ -0,0 +1,14 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class EnterpriseTransferCredits extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        from: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        to: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        amount: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        yes: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}