@clickraft/cli 0.4.0 → 0.5.0

package/CHANGELOG.md

@@ -1,9 +1,8 @@
-## [0.4.0](https://github.com/clickraft/cli/compare/v0.3.0...v0.4.0) (2026-05-24)
+## [0.5.0](https://github.com/clickraft/cli/compare/v0.4.0...v0.5.0) (2026-05-24)
 
 ### Features
 
-* **errors:** add brand model error codes and surface error details ([98ee9f4](https://github.com/clickraft/cli/commit/98ee9f415a85cf31e38152092655accbe9acef1c))
-* **generate:** make --brand-model repeatable with pose support ([872209c](https://github.com/clickraft/cli/commit/872209cfab22f7cd31e2a7655fa072c437a78351))
+* **models:** add models list command consuming agents/v1/models ([83761d1](https://github.com/clickraft/cli/commit/83761d11d136758e23c40cf80cd87c8f08dbaad6))
 
 # Changelog
 

package/README.md

@@ -19,6 +19,8 @@ clickraft login
 clickraft generate create --prompt "a serene mountain landscape at dawn"
 clickraft balance
 clickraft brand-model list
+clickraft models list
+clickraft models list --category image --tier pro
 clickraft template list
 clickraft template get <template-id>
 clickraft template find "coffee brand"
@@ -56,6 +58,7 @@ export CLOUDFLARE_ACCESS_CLIENT_SECRET="<client-secret>"
 clickraft tokens list --profile staging
 clickraft balance --profile staging
 clickraft brand-model list --profile staging
+clickraft models 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

@@ -2441,6 +2441,77 @@ function formatRevokeFailure(err, token) {
   return `warning: server-side revoke failed (${reason}). Local profile removed; token ${redactTokenLikeValue(token)} remains server-valid until expiry.`;
 }
 
+// src/schemas/models.ts
+import { z as z8 } from "zod";
+var ModelSummarySchema = z8.object({
+  id: z8.string().uuid(),
+  slug: z8.string(),
+  displayName: z8.string(),
+  description: z8.string().nullable(),
+  shortDescription: z8.string().nullable(),
+  providerSlug: z8.string(),
+  providerName: z8.string(),
+  modelType: z8.string(),
+  category: z8.string(),
+  costTier: z8.string(),
+  creditCost: z8.number(),
+  pricingStrategy: z8.string(),
+  estimatedSeconds: z8.object({
+    typical: z8.number(),
+    range: z8.array(z8.number())
+  }).passthrough().nullable(),
+  status: z8.string(),
+  modalities: z8.object({
+    input: z8.array(z8.string()),
+    output: z8.array(z8.string())
+  }).passthrough().nullable(),
+  bestFor: z8.array(z8.string()),
+  badges: z8.array(z8.string()),
+  isFeatured: z8.boolean(),
+  isDefault: z8.boolean(),
+  docsUrl: z8.string().nullable(),
+  llmContext: z8.string().nullable(),
+  constraints: z8.record(z8.unknown()).nullable(),
+  modelFamily: z8.string().nullable(),
+  isFamilyPrimary: z8.boolean().nullable()
+}).strict();
+var ModelsListResponseSchema = z8.object({
+  models: z8.array(ModelSummarySchema)
+}).strict();
+
+// src/commands/models/internal.ts
+async function buildModelClient(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/commands/models/list.ts
+async function listModels(opts) {
+  const client = opts.client ?? await buildModelClient(opts);
+  const data = await client.request({
+    method: "GET",
+    path: "/models",
+    query: {
+      category: opts.category,
+      tier: opts.tier,
+      type: opts.type,
+      featured: opts.featured !== void 0 ? String(opts.featured) : void 0
+    },
+    responseSchema: ModelsListResponseSchema,
+    signal: opts.signal
+  });
+  return data;
+}
+
 // src/telemetry/detect.ts
 var AGENT_SIGNALS = [
   { envVar: "CLAUDE_CODE_SESSION_ID", agent: "claude-code" },
@@ -2531,33 +2602,33 @@ async function buildTemplateClient(opts) {
 }
 
 // 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()
+import { z as z9 } from "zod";
+var DeclaredParamSchema = z9.object({
+  name: z9.string(),
+  type: z9.string(),
+  required: z9.boolean(),
+  defaultValue: z9.string().nullable().optional(),
+  enumValues: z9.array(z9.string()).nullable().optional(),
+  description: z9.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()
+var TemplateSummarySchema = z9.object({
+  id: z9.string().uuid(),
+  source: z9.enum(["own", "system"]),
+  name: z9.string(),
+  description: z9.string().nullable(),
+  category: z9.string().nullable(),
+  thumbnailUrl: z9.string().nullable(),
+  tags: z9.array(z9.string()),
+  createdAt: z9.string()
 }).strict();
 var TemplateDetailSchema = TemplateSummarySchema.extend({
-  declaredParams: z8.array(DeclaredParamSchema),
-  timesUsed: z8.number()
+  declaredParams: z9.array(DeclaredParamSchema),
+  timesUsed: z9.number()
 }).strict();
-var TemplatesListResponseSchema = z8.object({
-  templates: z8.array(TemplateSummarySchema),
-  cursor: z8.string().nullable(),
-  hasMore: z8.boolean()
+var TemplatesListResponseSchema = z9.object({
+  templates: z9.array(TemplateSummarySchema),
+  cursor: z9.string().nullable(),
+  hasMore: z9.boolean()
 }).strict();
 
 // src/commands/template/list.ts
@@ -2607,20 +2678,20 @@ async function getTemplate(opts) {
 }
 
 // src/commands/tokens/list.ts
-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()
+import { z as z10 } from "zod";
+var TokenRowSchema = z10.object({
+  id: z10.string().uuid(),
+  organizationId: z10.string().uuid(),
+  userId: z10.string().uuid(),
+  clientId: z10.string().nullable(),
+  tokenPrefix: z10.string(),
+  name: z10.string().nullable(),
+  scopes: z10.array(z10.string()),
+  lastUsedAt: z10.string().nullable(),
+  expiresAt: z10.string(),
+  createdAt: z10.string()
 }).strict();
-var TokensListResponseSchema = z9.array(TokenRowSchema);
+var TokensListResponseSchema = z10.array(TokenRowSchema);
 async function listTokens(options) {
   const config = await loadConfig({
     flagProfile: options.profile,
@@ -2988,6 +3059,72 @@ function renderTemplateDetail(detail, out) {
   }
   out.write(lines.join("\n") + "\n");
 }
+var TIER_ORDER = { premium: 0, pro: 1, standard: 2 };
+function renderModelsList(result, out, options) {
+  const { models } = result;
+  if (models.length === 0) {
+    out.write("No models match your filters.\n");
+    return;
+  }
+  const sorted = [...models].sort((a, b) => {
+    const catCmp = a.category.localeCompare(b.category);
+    if (catCmp !== 0) return catCmp;
+    const tierA = TIER_ORDER[a.costTier] ?? 99;
+    const tierB = TIER_ORDER[b.costTier] ?? 99;
+    if (tierA !== tierB) return tierA - tierB;
+    return a.slug.localeCompare(b.slug);
+  });
+  const filterParts = [];
+  if (options?.filters) {
+    for (const [k, v] of Object.entries(options.filters)) {
+      if (v) filterParts.push(`${k}=${v}`);
+    }
+  }
+  const filterSuffix = filterParts.length > 0 ? ` (filters: ${filterParts.join(", ")})` : "";
+  out.write(`${sorted.length} models${filterSuffix}
+
+`);
+  const headers = ["SLUG", "NAME", "CATEGORY", "TIER", "CREDITS", "DEFAULT"];
+  const data = sorted.map((m) => [
+    m.slug,
+    m.displayName,
+    m.category,
+    m.costTier,
+    String(m.creditCost),
+    m.isDefault ? "\u2713" : ""
+  ]);
+  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");
+  out.write(
+    `
+Showing all ${sorted.length} models. Use --json for full details including constraints.
+`
+  );
+  if (options?.verbose) {
+    out.write("\n");
+    for (const m of sorted) {
+      const pad = 16;
+      out.write(`${m.slug} (${m.displayName})
+`);
+      out.write(`${"  Provider:".padEnd(pad)}${m.providerName}
+`);
+      out.write(`${"  Category:".padEnd(pad)}${m.category} / ${m.modelType}
+`);
+      out.write(`${"  Tier:".padEnd(pad)}${m.costTier} (${m.creditCost} credits)
+`);
+      if (m.llmContext) {
+        const ctx = m.llmContext.length > 100 ? m.llmContext.slice(0, 100) + "..." : m.llmContext;
+        out.write(`${"  Context:".padEnd(pad)}${ctx}
+`);
+      }
+      out.write("\n");
+    }
+  }
+}
 function formatExpiresAt(iso) {
   const ms = Date.parse(iso);
   if (Number.isNaN(ms)) return iso;
@@ -3214,6 +3351,7 @@ function renderRootHelp(version) {
     "  tokens list             List the caller's API tokens",
     "  balance                 Show credit balance and rate limits",
     "  brand-model list        List available brand models",
+    "  models list             List available AI models",
     "  telemetry inspect       Show current telemetry state and payload shape",
     "  template list            List available templates",
     "  template get             Fetch a template by ID",
@@ -3293,6 +3431,38 @@ function renderCommandHelp(command) {
         "  --json             Emit JSON envelope instead of human output",
         ""
       ].join("\n");
+    case "models":
+      return [
+        "Usage: clickraft models <subcommand> [options]",
+        "",
+        "Subcommands:",
+        "  list  List available AI models",
+        ""
+      ].join("\n");
+    case "models list":
+      return [
+        "Usage: clickraft models list [options]",
+        "",
+        "List AI models available for generation. By default shows a summary table;",
+        "use --json for full details including constraints and llmContext.",
+        "",
+        "Options:",
+        "  --category <name>     Filter by category (image, video, audio, chat, edit)",
+        "  --tier <name>         Filter by cost tier (standard, pro, premium)",
+        "  --type <name>         Filter by model type (e.g. text-to-image)",
+        "  --featured            Show only featured models",
+        "  --verbose             Show expanded per-model details after the table",
+        "  --profile <name>",
+        "  --api-base-url <url>",
+        "  --token <token>",
+        "  --json",
+        "",
+        "Examples:",
+        "  clickraft models list",
+        "  clickraft models list --category image --tier pro",
+        "  clickraft models list --featured --json",
+        ""
+      ].join("\n");
     case "telemetry inspect":
       return [
         "Usage: clickraft telemetry inspect [options]",
@@ -3488,6 +3658,12 @@ function matchNewCommand(argv) {
     if (sub === void 0 || sub.startsWith("-")) return { kind: "sub-help", verb: "template" };
     return { kind: "unknown-sub", verb: "template", sub };
   }
+  if (verb === "models") {
+    const sub = argv[1];
+    if (sub === "list") return { kind: "cmd", path: "models.list", verbTokenCount: 2 };
+    if (sub === void 0 || sub.startsWith("-")) return { kind: "sub-help", verb: "models" };
+    return { kind: "unknown-sub", verb: "models", sub };
+  }
   return null;
 }
 async function runNewCommand(newCmd, options, stdout, stderr) {
@@ -3544,6 +3720,8 @@ async function runNewCommand(newCmd, options, stdout, stderr) {
         return await runTemplateGet(argvAfterVerb, ctx, rc);
       case "template.find":
         return await runTemplateFind(argvAfterVerb, ctx, rc);
+      case "models.list":
+        return await runModelsList(argvAfterVerb, ctx, rc);
     }
   } catch (err) {
     if (isAbortedError(err, options.signal)) {
@@ -3821,6 +3999,42 @@ function emitTemplateDetail(detail, ctx, rc) {
   }
   renderTemplateDetail(detail, rc.stdout);
 }
+async function runModelsList(argv, ctx, rc) {
+  const parsed = parseArgs(argv, {
+    string: [...COMMON_RICH_STRING_FLAGS, "category", "tier", "type"],
+    boolean: [...COMMON_RICH_BOOL_FLAGS, "featured", "verbose"]
+  });
+  const result = await listModels({
+    category: parsed.string.category,
+    tier: parsed.string.tier,
+    type: parsed.string.type,
+    featured: parsed.boolean.featured,
+    profile: parsed.string.profile,
+    apiBaseUrl: parsed.string["api-base-url"],
+    token: parsed.string.token,
+    signal: rc.signal
+  });
+  emitModelsList(result, ctx, rc, parsed);
+  return 0;
+}
+function emitModelsList(result, ctx, rc, parsed) {
+  if (rc.signal?.aborted) {
+    throw new AuthError("AUTH_FLOW_CANCELLED", "Cancelled.");
+  }
+  if (rc.jsonMode) {
+    rc.stdout.write(JSON.stringify(wrapSuccess(result, ctx)) + "\n");
+    return;
+  }
+  renderModelsList(result, rc.stdout, {
+    verbose: parsed.boolean.verbose === true,
+    filters: {
+      category: parsed.string.category ?? "",
+      tier: parsed.string.tier ?? "",
+      type: parsed.string.type ?? "",
+      featured: parsed.boolean.featured !== void 0 ? String(parsed.boolean.featured) : ""
+    }
+  });
+}
 
 // src/index.ts
 var __filename2 = fileURLToPath(import.meta.url);