@clickraft/cli 0.1.8 → 0.3.0

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",
@@ -715,6 +721,10 @@ function buildUrl(baseUrl, path, query) {
   if (query) {
     for (const [key, value] of Object.entries(query)) {
       if (value === void 0) continue;
+      if (Array.isArray(value)) {
+        for (const item of value) url.searchParams.append(key, item);
+        continue;
+      }
       url.searchParams.append(key, String(value));
     }
   }
@@ -848,65 +858,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 +903,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 +938,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 +1190,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
@@ -2218,21 +2309,112 @@ function inspectTelemetry(options = {}) {
   };
 }
 
+// src/commands/template/internal.ts
+async function buildTemplateClient(opts) {
+  const cfg = await loadConfig({
+    flagProfile: opts.profile,
+    flagApiBaseUrl: opts.apiBaseUrl,
+    flagToken: opts.token
+  });
+  return new ApiClient({
+    apiBaseUrl: cfg.apiBaseUrl,
+    accessToken: cfg.accessToken,
+    signal: opts.signal,
+    cloudflareAccess: cfg.cloudflareAccess
+  });
+}
+
+// src/schemas/templates.ts
+import { z as z8 } from "zod";
+var DeclaredParamSchema = z8.object({
+  name: z8.string(),
+  type: z8.string(),
+  required: z8.boolean(),
+  defaultValue: z8.string().nullable().optional(),
+  enumValues: z8.array(z8.string()).nullable().optional(),
+  description: z8.string().nullable().optional()
+}).strict();
+var TemplateSummarySchema = z8.object({
+  id: z8.string().uuid(),
+  source: z8.enum(["own", "system"]),
+  name: z8.string(),
+  description: z8.string().nullable(),
+  category: z8.string().nullable(),
+  thumbnailUrl: z8.string().nullable(),
+  tags: z8.array(z8.string()),
+  createdAt: z8.string()
+}).strict();
+var TemplateDetailSchema = TemplateSummarySchema.extend({
+  declaredParams: z8.array(DeclaredParamSchema),
+  timesUsed: z8.number()
+}).strict();
+var TemplatesListResponseSchema = z8.object({
+  templates: z8.array(TemplateSummarySchema),
+  cursor: z8.string().nullable(),
+  hasMore: z8.boolean()
+}).strict();
+
+// src/commands/template/list.ts
+async function listTemplates(opts) {
+  const client = opts.client ?? await buildTemplateClient(opts);
+  const data = await client.request({
+    method: "GET",
+    path: "/templates",
+    query: {
+      q: opts.q,
+      tags: opts.tags,
+      scope: opts.scope,
+      cursor: opts.cursor,
+      limit: opts.limit
+    },
+    responseSchema: TemplatesListResponseSchema,
+    signal: opts.signal
+  });
+  return data;
+}
+
+// src/commands/template/find.ts
+async function findTemplates(opts) {
+  return listTemplates({
+    q: opts.query,
+    tags: opts.tags,
+    scope: opts.scope,
+    limit: opts.limit,
+    cursor: opts.cursor,
+    profile: opts.profile,
+    apiBaseUrl: opts.apiBaseUrl,
+    token: opts.token,
+    signal: opts.signal,
+    client: opts.client
+  });
+}
+
+// src/commands/template/get.ts
+async function getTemplate(opts) {
+  const client = opts.client ?? await buildTemplateClient(opts);
+  return client.request({
+    method: "GET",
+    path: `/templates/${encodeURIComponent(opts.id)}`,
+    responseSchema: TemplateDetailSchema,
+    signal: opts.signal
+  });
+}
+
 // 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().nullable(),
-  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 z9 } from "zod";
+var TokenRowSchema = z9.object({
+  id: z9.string().uuid(),
+  organizationId: z9.string().uuid(),
+  userId: z9.string().uuid(),
+  clientId: z9.string().nullable(),
+  tokenPrefix: z9.string(),
+  name: z9.string().nullable(),
+  scopes: z9.array(z9.string()),
+  lastUsedAt: z9.string().nullable(),
+  expiresAt: z9.string(),
+  createdAt: z9.string()
 }).strict();
-var TokensListResponseSchema = z6.array(TokenRowSchema);
+var TokensListResponseSchema = z9.array(TokenRowSchema);
 async function listTokens(options) {
   const config = await loadConfig({
     flagProfile: options.profile,
@@ -2592,6 +2774,99 @@ 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 renderTemplatesList(result, out) {
+  const { templates } = result;
+  if (templates.length === 0) {
+    out.write("No templates.\n");
+    return;
+  }
+  const MAX_TAGS = 3;
+  const headers = ["SOURCE", "NAME", "CATEGORY", "TAGS", "CREATED"];
+  const data = templates.map((t) => {
+    const shown = t.tags.slice(0, MAX_TAGS).join(", ");
+    const extra = t.tags.length > MAX_TAGS ? ` +${t.tags.length - MAX_TAGS} more` : "";
+    return [
+      t.source,
+      t.name,
+      t.category ?? "\u2014",
+      t.tags.length > 0 ? shown + extra : "\u2014",
+      t.createdAt.slice(0, 10)
+    ];
+  });
+  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");
+  if (result.hasMore) {
+    out.write("\nMore results available. Use --cursor to fetch the next page.\n");
+  }
+}
+function renderTemplateDetail(detail, out) {
+  const pad = 17;
+  const lines = [
+    detail.name,
+    `${"ID:".padEnd(pad)}${detail.id}`,
+    `${"Source:".padEnd(pad)}${detail.source}`,
+    `${"Category:".padEnd(pad)}${detail.category ?? "\u2014"}`,
+    `${"Tags:".padEnd(pad)}${detail.tags.length > 0 ? detail.tags.join(", ") : "\u2014"}`,
+    `${"Created:".padEnd(pad)}${detail.createdAt.slice(0, 10)}`,
+    `${"Times used:".padEnd(pad)}${detail.timesUsed}`
+  ];
+  if (detail.description) {
+    lines.push("", detail.description);
+  }
+  lines.push("", "Declared parameters:");
+  if (detail.declaredParams.length === 0) {
+    lines.push("  (none)");
+  } else {
+    for (const p of detail.declaredParams) {
+      const req = p.required ? "required" : "optional";
+      const desc = p.description ? `: ${p.description}` : "";
+      lines.push(`  - ${p.name} (${p.type}, ${req})${desc}`);
+    }
+  }
+  out.write(lines.join("\n") + "\n");
+}
 function formatExpiresAt(iso) {
   const ms = Date.parse(iso);
   if (Number.isNaN(ms)) return iso;
@@ -2685,6 +2960,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 +3048,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,7 +3091,12 @@ 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",
+    "  template list            List available templates",
+    "  template get             Fetch a template by ID",
+    "  template find            Search templates by keyword",
     "  generate create         Submit a generation job and wait for completion",
     "  generate wait           Wait for an existing job to reach a terminal state",
     "  generate get            Fetch the current state of a job",
@@ -2848,6 +3146,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]",
@@ -2856,6 +3180,62 @@ function renderCommandHelp(command) {
         "  --json             Emit JSON envelope instead of human output",
         ""
       ].join("\n");
+    case "template":
+      return [
+        "Usage: clickraft template <subcommand> [options]",
+        "",
+        "Subcommands:",
+        "  list   List available templates",
+        "  get    Fetch a template by ID",
+        "  find   Search templates by keyword",
+        ""
+      ].join("\n");
+    case "template list":
+      return [
+        "Usage: clickraft template list [options]",
+        "",
+        "Options:",
+        "  --scope <scope>       Filter by scope: own, system, or all (default: all)",
+        "  --q <query>           Free-text search query",
+        "  --tags <tag>          Filter by tag (repeatable)",
+        "  --cursor <token>      Pagination cursor from a previous response",
+        "  --limit <n>           Max results per page (1-50, default: 20)",
+        "  --profile <name>",
+        "  --api-base-url <url>",
+        "  --token <token>",
+        "  --json",
+        ""
+      ].join("\n");
+    case "template get":
+      return [
+        "Usage: clickraft template get <id> [options]",
+        "",
+        "Fetches a single template by its ID, including declared parameters.",
+        "",
+        "Options:",
+        "  --profile <name>",
+        "  --api-base-url <url>",
+        "  --token <token>",
+        "  --json",
+        ""
+      ].join("\n");
+    case "template find":
+      return [
+        "Usage: clickraft template find <query> [options]",
+        "",
+        "Searches templates by keyword. Shorthand for `template list --q <query>`.",
+        "",
+        "Options:",
+        "  --tags <tag>          Filter by tag (repeatable)",
+        "  --scope <scope>       Filter by scope: own, system, or all (default: all)",
+        "  --limit <n>           Max results per page (1-50, default: 20)",
+        "  --cursor <token>      Pagination cursor from a previous response",
+        "  --profile <name>",
+        "  --api-base-url <url>",
+        "  --token <token>",
+        "  --json",
+        ""
+      ].join("\n");
     case "generate":
       return [
         "Usage: clickraft generate <subcommand> [options]",
@@ -2977,6 +3357,14 @@ function matchNewCommand(argv) {
     if (sub === void 0 || sub.startsWith("-")) return { kind: "sub-help", verb: "jobs" };
     return { kind: "unknown-sub", verb: "jobs", sub };
   }
+  if (verb === "template") {
+    const sub = argv[1];
+    if (sub === "list") return { kind: "cmd", path: "template.list", verbTokenCount: 2 };
+    if (sub === "get") return { kind: "cmd", path: "template.get", verbTokenCount: 2 };
+    if (sub === "find") return { kind: "cmd", path: "template.find", verbTokenCount: 2 };
+    if (sub === void 0 || sub.startsWith("-")) return { kind: "sub-help", verb: "template" };
+    return { kind: "unknown-sub", verb: "template", sub };
+  }
   return null;
 }
 async function runNewCommand(newCmd, options, stdout, stderr) {
@@ -3027,6 +3415,12 @@ async function runNewCommand(newCmd, options, stdout, stderr) {
         return await runJobsWait(argvAfterVerb, ctx, rc);
       case "upload":
         return await runUploadCmd(argvAfterVerb, ctx, rc);
+      case "template.list":
+        return await runTemplateList(argvAfterVerb, ctx, rc);
+      case "template.get":
+        return await runTemplateGet(argvAfterVerb, ctx, rc);
+      case "template.find":
+        return await runTemplateFind(argvAfterVerb, ctx, rc);
     }
   } catch (err) {
     if (isAbortedError(err, options.signal)) {
@@ -3221,6 +3615,87 @@ function exitCodeForResult(result) {
   }
   return 0;
 }
+async function runTemplateList(argv, ctx, rc) {
+  const parsed = parseArgs(argv, {
+    string: [...COMMON_RICH_STRING_FLAGS, "scope", "q", "cursor", "limit"],
+    boolean: [...COMMON_RICH_BOOL_FLAGS],
+    array: ["tags"]
+  });
+  const result = await listTemplates({
+    q: parsed.string.q,
+    tags: parsed.array.tags,
+    scope: parsed.string.scope,
+    cursor: parsed.string.cursor,
+    limit: optionalInt(parsed.string.limit, "limit"),
+    profile: parsed.string.profile,
+    apiBaseUrl: parsed.string["api-base-url"],
+    token: parsed.string.token,
+    signal: rc.signal
+  });
+  ctx.nextCursor = result.cursor ?? void 0;
+  emitTemplateList(result, ctx, rc);
+  return 0;
+}
+async function runTemplateGet(argv, ctx, rc) {
+  const parsed = parseArgs(argv, {
+    string: [...COMMON_RICH_STRING_FLAGS],
+    boolean: [...COMMON_RICH_BOOL_FLAGS]
+  });
+  const id = parsed.positional[0];
+  if (!id) throw new ArgError("Missing required <id> argument.");
+  const detail = await getTemplate({
+    id,
+    profile: parsed.string.profile,
+    apiBaseUrl: parsed.string["api-base-url"],
+    token: parsed.string.token,
+    signal: rc.signal
+  });
+  emitTemplateDetail(detail, ctx, rc);
+  return 0;
+}
+async function runTemplateFind(argv, ctx, rc) {
+  const parsed = parseArgs(argv, {
+    string: [...COMMON_RICH_STRING_FLAGS, "scope", "cursor", "limit"],
+    boolean: [...COMMON_RICH_BOOL_FLAGS],
+    array: ["tags"]
+  });
+  const query = parsed.positional[0];
+  if (!query) throw new ArgError("Missing required <query> argument.");
+  const result = await findTemplates({
+    query,
+    tags: parsed.array.tags,
+    scope: parsed.string.scope,
+    cursor: parsed.string.cursor,
+    limit: optionalInt(parsed.string.limit, "limit"),
+    profile: parsed.string.profile,
+    apiBaseUrl: parsed.string["api-base-url"],
+    token: parsed.string.token,
+    signal: rc.signal
+  });
+  ctx.nextCursor = result.cursor ?? void 0;
+  emitTemplateList(result, ctx, rc);
+  return 0;
+}
+function emitTemplateList(result, ctx, rc) {
+  if (rc.signal?.aborted) {
+    throw new AuthError("AUTH_FLOW_CANCELLED", "Cancelled.");
+  }
+  if (rc.jsonMode) {
+    rc.stdout.write(JSON.stringify(wrapSuccess(result, ctx)) + "\n");
+    return;
+  }
+  renderTemplatesList(result, rc.stdout);
+}
+function emitTemplateDetail(detail, ctx, rc) {
+  if (rc.signal?.aborted) {
+    throw new AuthError("AUTH_FLOW_CANCELLED", "Cancelled.");
+  }
+  if (rc.jsonMode) {
+    rc.stdout.write(JSON.stringify(wrapSuccess(detail, ctx)) + "\n");
+    return;
+  }
+  renderTemplateDetail(detail, rc.stdout);
+}
 
 // src/index.ts
 var __filename2 = fileURLToPath(import.meta.url);