@clickraft/cli 0.1.7 → 0.2.0

package/CHANGELOG.md

@@ -1,8 +1,8 @@
-## [0.1.7](https://github.com/clickraft/cli/compare/v0.1.6...v0.1.7) (2026-05-23)
+## [0.2.0](https://github.com/clickraft/cli/compare/v0.1.8...v0.2.0) (2026-05-24)
 
-### Bug Fixes
+### Features
 
-* **auth:** include Cloudflare Access headers in OAuth device flow requests ([e2cb7e9](https://github.com/clickraft/cli/commit/e2cb7e966f8935b43142a3d3d87a440e3478db10))
+* **commands:** add balance and brand-model list commands ([19e27a2](https://github.com/clickraft/cli/commit/19e27a2c5cebe3f19954a80c64139f9e5d6bbd22))
 
 # Changelog
 

package/README.md

@@ -17,6 +17,8 @@ Requires Node.js 20 or later.
 ```bash
 clickraft login
 clickraft generate create --prompt "a serene mountain landscape at dawn"
+clickraft balance
+clickraft brand-model list
 ```
 
 Full documentation: [docs.clickraft.ai/cli](https://docs.clickraft.ai/cli) _(coming soon)_
@@ -30,6 +32,8 @@ export CLOUDFLARE_ACCESS_CLIENT_ID="<client-id>.access"
 export CLOUDFLARE_ACCESS_CLIENT_SECRET="<client-secret>"
 
 clickraft tokens list --profile staging
+clickraft balance --profile staging
+clickraft brand-model list --profile staging
 ```
 
 Both env vars must be set together — if only one is set the CLI exits with a configuration error. Production usage (the default) does not require these env vars.

package/dist/cli.js

@@ -170,6 +170,12 @@ var EXIT_CODE_MAP = {
     retryable: false,
     hint: "Resource not found."
   },
+  FEATURE_DISABLED: {
+    exitCode: 2,
+    category: "usage",
+    retryable: false,
+    hint: "This endpoint is not enabled. Contact support if you believe this is in error."
+  },
   FORBIDDEN: {
     exitCode: 4,
     category: "permission",
@@ -848,65 +854,8 @@ function buildPayload(args) {
   return payload;
 }
 
-// src/schemas/jobs.ts
-import { z as z3 } from "zod";
-var GenerateCreateRequestSchema = z3.object({
-  modelSlug: z3.string().min(1).max(100),
-  input: z3.object({
-    prompt: z3.string().max(1e4).optional(),
-    referenceImageUrl: z3.string().url().optional(),
-    referenceImages: z3.array(z3.string().url()).max(8).optional(),
-    aspectRatio: z3.string().regex(/^\d+:\d+$/).optional(),
-    resolution: z3.string().regex(/^\d+x\d+$/).optional(),
-    durationSeconds: z3.number().int().min(1).max(60).optional(),
-    providerParams: z3.record(z3.string(), z3.unknown()).optional()
-  }).strict(),
-  options: z3.object({
-    workflowId: z3.string().uuid().optional(),
-    nodeId: z3.string().optional()
-  }).strict().optional()
-}).strict();
-var GenerateCreateResponseSchema = z3.object({
-  jobId: z3.string().uuid(),
-  status: z3.enum(["queued", "processing", "completed", "failed"]),
-  estimatedSeconds: z3.number().int().nonnegative().nullable(),
-  creditsCharged: z3.number().int().nonnegative()
-}).strict();
-var GenerationStatusSchema = z3.enum([
-  "queued",
-  "processing",
-  "uploading",
-  "completed",
-  "failed",
-  "cancelled"
-]);
-var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
-  "completed",
-  "failed",
-  "cancelled"
-]);
-function isTerminalStatus(status) {
-  return TERMINAL_STATUSES.has(status);
-}
-var GenerationResultSchema = z3.object({
-  jobId: z3.string().uuid(),
-  status: GenerationStatusSchema,
-  modelSlug: z3.string(),
-  resultUrl: z3.string().url().nullable(),
-  thumbnailUrl: z3.string().url().nullable(),
-  errorCode: z3.string().nullable(),
-  errorMessage: z3.string().nullable(),
-  creditsCharged: z3.number().int().nonnegative(),
-  creditsRefunded: z3.boolean(),
-  startedAt: z3.string().nullable(),
-  completedAt: z3.string().nullable()
-}).strict();
-
-// src/commands/upload.ts
-import { createHash as createHash2 } from "crypto";
-import { readFile as readFile2, stat as stat2 } from "fs/promises";
-import { basename } from "path";
-import { request as undiciRequest2 } from "undici";
+// src/commands/balance.ts
+import { z as z4 } from "zod";
 
 // src/auth/credentials.ts
 import {
@@ -950,31 +899,31 @@ function getCredentialsPath(ctx = {}) {
 }
 
 // src/auth/types.ts
-import { z as z4 } from "zod";
-var DeviceAuthorizationRequestSchema = z4.object({
-  client_id: z4.string(),
-  scope: z4.string()
+import { z as z3 } from "zod";
+var DeviceAuthorizationRequestSchema = z3.object({
+  client_id: z3.string(),
+  scope: z3.string()
 });
-var DeviceAuthorizationResponseSchema = z4.object({
-  device_code: z4.string(),
-  user_code: z4.string().min(1),
-  verification_uri: z4.string().url(),
-  verification_uri_complete: z4.string().url().optional(),
-  expires_in: z4.number().int().positive(),
-  interval: z4.number().int().positive().default(5)
+var DeviceAuthorizationResponseSchema = z3.object({
+  device_code: z3.string(),
+  user_code: z3.string().min(1),
+  verification_uri: z3.string().url(),
+  verification_uri_complete: z3.string().url().optional(),
+  expires_in: z3.number().int().positive(),
+  interval: z3.number().int().positive().default(5)
 });
-var DeviceTokenPollRequestSchema = z4.object({
-  client_id: z4.string(),
-  device_code: z4.string(),
-  grant_type: z4.literal("urn:ietf:params:oauth:grant-type:device_code")
+var DeviceTokenPollRequestSchema = z3.object({
+  client_id: z3.string(),
+  device_code: z3.string(),
+  grant_type: z3.literal("urn:ietf:params:oauth:grant-type:device_code")
 });
-var TokenResponseSchema = z4.object({
-  access_token: z4.string(),
-  token_type: z4.literal("Bearer"),
-  expires_in: z4.number().int().positive(),
-  scope: z4.string()
+var TokenResponseSchema = z3.object({
+  access_token: z3.string(),
+  token_type: z3.literal("Bearer"),
+  expires_in: z3.number().int().positive(),
+  scope: z3.string()
 });
-var DeviceTokenPollErrorCodeSchema = z4.enum([
+var DeviceTokenPollErrorCodeSchema = z3.enum([
   "authorization_pending",
   "slow_down",
   "access_denied",
@@ -985,27 +934,27 @@ var DeviceTokenPollErrorCodeSchema = z4.enum([
   "unsupported_grant_type",
   "invalid_scope"
 ]);
-var DeviceTokenPollErrorSchema = z4.object({
+var DeviceTokenPollErrorSchema = z3.object({
   error: DeviceTokenPollErrorCodeSchema,
-  error_description: z4.string().optional()
+  error_description: z3.string().optional()
 });
-var CredentialsProfileSchema = z4.object({
-  apiBaseUrl: z4.string().url(),
-  accessToken: z4.string(),
-  tokenType: z4.literal("Bearer"),
-  tokenPrefix: z4.string(),
-  organizationId: z4.string().uuid(),
-  organizationSlug: z4.string(),
-  userId: z4.string().uuid(),
-  scopes: z4.array(z4.string()),
-  expiresAt: z4.string().datetime(),
-  issuedAt: z4.string().datetime(),
-  clientId: z4.string()
+var CredentialsProfileSchema = z3.object({
+  apiBaseUrl: z3.string().url(),
+  accessToken: z3.string(),
+  tokenType: z3.literal("Bearer"),
+  tokenPrefix: z3.string(),
+  organizationId: z3.string().uuid(),
+  organizationSlug: z3.string(),
+  userId: z3.string().uuid(),
+  scopes: z3.array(z3.string()),
+  expiresAt: z3.string().datetime(),
+  issuedAt: z3.string().datetime(),
+  clientId: z3.string()
 }).strict();
-var CredentialsFileSchema = z4.object({
-  version: z4.literal(1),
-  defaultProfile: z4.string(),
-  profiles: z4.record(z4.string(), CredentialsProfileSchema)
+var CredentialsFileSchema = z3.object({
+  version: z3.literal(1),
+  defaultProfile: z3.string(),
+  profiles: z3.record(z3.string(), CredentialsProfileSchema)
 }).strict();
 
 // src/auth/credentials.ts
@@ -1237,20 +1186,158 @@ function trim(value) {
   return t.length === 0 ? void 0 : t;
 }
 
-// src/schemas/assets.ts
+// src/commands/balance.ts
+var BalanceResponseSchema = z4.object({
+  totalCredits: z4.number(),
+  subscriptionCredits: z4.number(),
+  purchasedCredits: z4.number(),
+  promotionalCredits: z4.number(),
+  rateLimit: z4.object({
+    apiBurstPerMinute: z4.number()
+  }).strict()
+}).strict();
+async function getBalance(options) {
+  const config = await loadConfig({
+    flagProfile: options.profile,
+    credentialsPath: options.credentialsPath
+  });
+  if (!config.accessToken) {
+    throw new AuthError("AUTH_TOKEN_MISSING", `Not authenticated. Run \`clickraft login\` first.`);
+  }
+  const factory = options.apiClientFactory ?? ((apiBaseUrl, accessToken) => new ApiClient({
+    apiBaseUrl,
+    accessToken,
+    signal: options.signal,
+    cloudflareAccess: config.cloudflareAccess
+  }));
+  const client = factory(config.apiBaseUrl, config.accessToken);
+  const data = await client.request({
+    method: "GET",
+    path: "/balance",
+    responseSchema: BalanceResponseSchema,
+    signal: options.signal
+  });
+  return data;
+}
+
+// src/commands/brand-model/list.ts
 import { z as z5 } from "zod";
+var BrandModelSummarySchema = z5.object({
+  id: z5.string().uuid(),
+  source: z5.enum(["system", "user"]),
+  slug: z5.string().nullable(),
+  name: z5.string(),
+  description: z5.string().nullable(),
+  thumbnailUrl: z5.string().nullable(),
+  tags: z5.array(z5.string()),
+  category: z5.string().nullable(),
+  isPremium: z5.boolean().nullable(),
+  isFeatured: z5.boolean().nullable(),
+  badgeText: z5.string().nullable(),
+  usageCount: z5.number().nullable(),
+  createdAt: z5.string()
+}).strict();
+var BrandModelsListResponseSchema = z5.object({
+  brandModels: z5.array(BrandModelSummarySchema)
+}).strict();
+async function listBrandModels(options) {
+  const config = await loadConfig({
+    flagProfile: options.profile,
+    credentialsPath: options.credentialsPath
+  });
+  if (!config.accessToken) {
+    throw new AuthError("AUTH_TOKEN_MISSING", `Not authenticated. Run \`clickraft login\` first.`);
+  }
+  const factory = options.apiClientFactory ?? ((apiBaseUrl, accessToken) => new ApiClient({
+    apiBaseUrl,
+    accessToken,
+    signal: options.signal,
+    cloudflareAccess: config.cloudflareAccess
+  }));
+  const client = factory(config.apiBaseUrl, config.accessToken);
+  const data = await client.request({
+    method: "GET",
+    path: "/brand-models",
+    responseSchema: BrandModelsListResponseSchema,
+    signal: options.signal
+  });
+  return data.brandModels;
+}
+
+// src/schemas/jobs.ts
+import { z as z6 } from "zod";
+var GenerateCreateRequestSchema = z6.object({
+  modelSlug: z6.string().min(1).max(100),
+  input: z6.object({
+    prompt: z6.string().max(1e4).optional(),
+    referenceImageUrl: z6.string().url().optional(),
+    referenceImages: z6.array(z6.string().url()).max(8).optional(),
+    aspectRatio: z6.string().regex(/^\d+:\d+$/).optional(),
+    resolution: z6.string().regex(/^\d+x\d+$/).optional(),
+    durationSeconds: z6.number().int().min(1).max(60).optional(),
+    providerParams: z6.record(z6.string(), z6.unknown()).optional()
+  }).strict(),
+  options: z6.object({
+    workflowId: z6.string().uuid().optional(),
+    nodeId: z6.string().optional()
+  }).strict().optional()
+}).strict();
+var GenerateCreateResponseSchema = z6.object({
+  jobId: z6.string().uuid(),
+  status: z6.enum(["queued", "processing", "completed", "failed"]),
+  estimatedSeconds: z6.number().int().nonnegative().nullable(),
+  creditsCharged: z6.number().int().nonnegative()
+}).strict();
+var GenerationStatusSchema = z6.enum([
+  "queued",
+  "processing",
+  "uploading",
+  "completed",
+  "failed",
+  "cancelled"
+]);
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+  "completed",
+  "failed",
+  "cancelled"
+]);
+function isTerminalStatus(status) {
+  return TERMINAL_STATUSES.has(status);
+}
+var GenerationResultSchema = z6.object({
+  jobId: z6.string().uuid(),
+  status: GenerationStatusSchema,
+  modelSlug: z6.string(),
+  resultUrl: z6.string().url().nullable(),
+  thumbnailUrl: z6.string().url().nullable(),
+  errorCode: z6.string().nullable(),
+  errorMessage: z6.string().nullable(),
+  creditsCharged: z6.number().int().nonnegative(),
+  creditsRefunded: z6.boolean(),
+  startedAt: z6.string().nullable(),
+  completedAt: z6.string().nullable()
+}).strict();
+
+// src/commands/upload.ts
+import { createHash as createHash2 } from "crypto";
+import { readFile as readFile2, stat as stat2 } from "fs/promises";
+import { basename } from "path";
+import { request as undiciRequest2 } from "undici";
+
+// src/schemas/assets.ts
+import { z as z7 } from "zod";
 var MAX_UPLOAD_SIZE_BYTES = 15 * 1024 * 1024;
-var UploadRequestSchema = z5.object({
-  filename: z5.string().min(1).max(255),
-  contentType: z5.string().regex(/^[\w-]+\/[\w+.-]+$/),
-  sizeBytes: z5.number().int().positive().max(MAX_UPLOAD_SIZE_BYTES),
-  contentHash: z5.string().regex(/^sha256:[0-9a-f]{64}$/)
+var UploadRequestSchema = z7.object({
+  filename: z7.string().min(1).max(255),
+  contentType: z7.string().regex(/^[\w-]+\/[\w+.-]+$/),
+  sizeBytes: z7.number().int().positive().max(MAX_UPLOAD_SIZE_BYTES),
+  contentHash: z7.string().regex(/^sha256:[0-9a-f]{64}$/)
 }).strict();
-var UploadResponseSchema = z5.object({
-  assetId: z5.string().uuid(),
-  uploadUrl: z5.string().url(),
-  publicUrl: z5.string().url(),
-  deduplicated: z5.boolean()
+var UploadResponseSchema = z7.object({
+  assetId: z7.string().uuid(),
+  uploadUrl: z7.string().url(),
+  publicUrl: z7.string().url(),
+  deduplicated: z7.boolean()
 }).strict();
 
 // src/commands/upload.ts
@@ -2219,20 +2306,20 @@ function inspectTelemetry(options = {}) {
 }
 
 // src/commands/tokens/list.ts
-import { z as z6 } from "zod";
-var TokenRowSchema = z6.object({
-  id: z6.string().uuid(),
-  organizationId: z6.string().uuid(),
-  userId: z6.string().uuid(),
-  clientId: z6.string(),
-  tokenPrefix: z6.string(),
-  name: z6.string().nullable(),
-  scopes: z6.array(z6.string()),
-  lastUsedAt: z6.string().nullable(),
-  expiresAt: z6.string(),
-  createdAt: z6.string()
+import { z as z8 } from "zod";
+var TokenRowSchema = z8.object({
+  id: z8.string().uuid(),
+  organizationId: z8.string().uuid(),
+  userId: z8.string().uuid(),
+  clientId: z8.string().nullable(),
+  tokenPrefix: z8.string(),
+  name: z8.string().nullable(),
+  scopes: z8.array(z8.string()),
+  lastUsedAt: z8.string().nullable(),
+  expiresAt: z8.string(),
+  createdAt: z8.string()
 }).strict();
-var TokensListResponseSchema = z6.array(TokenRowSchema);
+var TokensListResponseSchema = z8.array(TokenRowSchema);
 async function listTokens(options) {
   const config = await loadConfig({
     flagProfile: options.profile,
@@ -2592,6 +2679,44 @@ function renderTelemetryState(state, out) {
   ];
   out.write(lines.join("\n") + "\n");
 }
+var fmtNum = new Intl.NumberFormat("en-US");
+function renderBalance(data, out) {
+  const pad = 22;
+  const lines = [
+    `${"Total credits:".padEnd(pad)}${fmtNum.format(data.totalCredits).padStart(12)}`,
+    `${"\u251C\u2500 Subscription:".padEnd(pad)}${fmtNum.format(data.subscriptionCredits).padStart(12)}`,
+    `${"\u251C\u2500 Purchased:".padEnd(pad)}${fmtNum.format(data.purchasedCredits).padStart(12)}`,
+    `${"\u2514\u2500 Promotional:".padEnd(pad)}${fmtNum.format(data.promotionalCredits).padStart(12)}`,
+    "",
+    `${"Rate limit:".padEnd(pad)}${fmtNum.format(data.rateLimit.apiBurstPerMinute).padStart(12)} req/min`
+  ];
+  out.write(lines.join("\n") + "\n");
+}
+function renderBrandModelsList(models, out) {
+  if (models.length === 0) {
+    out.write("No brand models.\n");
+    return;
+  }
+  const MAX_TAGS = 3;
+  const headers = ["SOURCE", "NAME", "SLUG", "CATEGORY", "TAGS"];
+  const data = models.map((m) => {
+    const shown = m.tags.slice(0, MAX_TAGS).join(", ");
+    const extra = m.tags.length > MAX_TAGS ? ` +${m.tags.length - MAX_TAGS} more` : "";
+    return [
+      m.source,
+      m.name,
+      m.slug ?? "\u2014",
+      m.category ?? "\u2014",
+      m.tags.length > 0 ? shown + extra : "\u2014"
+    ];
+  });
+  const widths = headers.map(
+    (header, i) => Math.max(header.length, ...data.map((cells) => cells[i].length))
+  );
+  const padRow = (cells) => cells.map((cell, i) => cell.padEnd(widths[i])).join("  ").trimEnd();
+  out.write(padRow(headers) + "\n");
+  for (const cells of data) out.write(padRow(cells) + "\n");
+}
 function formatExpiresAt(iso) {
   const ms = Date.parse(iso);
   if (Number.isNaN(ms)) return iso;
@@ -2685,6 +2810,22 @@ async function runCommand(parsed, ctx, rc) {
       emit(state, renderTelemetryState, ctx, rc);
       return 0;
     }
+    case "balance": {
+      const data = await getBalance({
+        profile: stringFlag(parsed.flags.profile),
+        signal: rc.signal
+      });
+      emit(data, renderBalance, ctx, rc);
+      return 0;
+    }
+    case "brand-model.list": {
+      const models = await listBrandModels({
+        profile: stringFlag(parsed.flags.profile),
+        signal: rc.signal
+      });
+      emit(models, renderBrandModelsList, ctx, rc);
+      return 0;
+    }
     default:
       throw new ApiError(
         "INPUT_INVALID_FORMAT",
@@ -2757,7 +2898,9 @@ var COMMAND_FLAGS = {
   },
   logout: { profile: "string", all: "boolean", revoke: "boolean", json: "boolean" },
   "tokens.list": { profile: "string", json: "boolean" },
-  "telemetry.inspect": { json: "boolean" }
+  "telemetry.inspect": { json: "boolean" },
+  balance: { profile: "string", json: "boolean" },
+  "brand-model.list": { profile: "string", json: "boolean" }
 };
 function validateFlags(parsed) {
   const allowed = COMMAND_FLAGS[parsed.command.join(".")];
@@ -2798,6 +2941,8 @@ function renderRootHelp(version) {
     "  login                   Authenticate via OAuth device flow",
     "  logout                  Remove credentials (optional server-side revoke)",
     "  tokens list             List the caller's API tokens",
+    "  balance                 Show credit balance and rate limits",
+    "  brand-model list        List available brand models",
     "  telemetry inspect       Show current telemetry state and payload shape",
     "  generate create         Submit a generation job and wait for completion",
     "  generate wait           Wait for an existing job to reach a terminal state",
@@ -2848,6 +2993,32 @@ function renderCommandHelp(command) {
         "  --json             Emit JSON envelope instead of human output",
         ""
       ].join("\n");
+    case "balance":
+      return [
+        "Usage: clickraft balance [options]",
+        "",
+        "Options:",
+        "  --profile <name>   Read credentials from a specific profile",
+        "  --json             Emit JSON envelope instead of human output",
+        ""
+      ].join("\n");
+    case "brand-model":
+      return [
+        "Usage: clickraft brand-model <subcommand> [options]",
+        "",
+        "Subcommands:",
+        "  list  List available brand models",
+        ""
+      ].join("\n");
+    case "brand-model list":
+      return [
+        "Usage: clickraft brand-model list [options]",
+        "",
+        "Options:",
+        "  --profile <name>   Read credentials from a specific profile",
+        "  --json             Emit JSON envelope instead of human output",
+        ""
+      ].join("\n");
     case "telemetry inspect":
       return [
         "Usage: clickraft telemetry inspect [options]",