@clickraft/cli 0.7.3 → 0.8.0

package/dist/index.js

@@ -144,7 +144,7 @@ var EXIT_CODE_MAP = {
     exitCode: 2,
     category: "usage",
     retryable: false,
-    hint: "Run `node-type list` for the current set of node types."
+    hint: "Run `clickraft nodes list` for the current set of node types."
   },
   CANVAS_REV_MISMATCH: {
     exitCode: 7,
@@ -188,6 +188,12 @@ var EXIT_CODE_MAP = {
     retryable: false,
     hint: "Resource not found."
   },
+  NODE_TYPE_NOT_FOUND: {
+    exitCode: 2,
+    category: "usage",
+    retryable: false,
+    hint: "Run `clickraft nodes list` for the current set of node types."
+  },
   FEATURE_DISABLED: {
     exitCode: 2,
     category: "usage",
@@ -2587,7 +2593,14 @@ var ModelSummarySchema = z8.object({
     output: z8.array(z8.string())
   }).passthrough().nullable(),
   bestFor: z8.array(z8.string()),
-  badges: z8.array(z8.string()),
+  badges: z8.array(
+    z8.object({
+      type: z8.string(),
+      label: z8.string(),
+      color: z8.string(),
+      expires_at: z8.string().nullable().optional()
+    }).strict()
+  ),
   isFeatured: z8.boolean(),
   isDefault: z8.boolean(),
   docsUrl: z8.string().nullable(),
@@ -2633,28 +2646,86 @@ async function listModels(opts) {
   return data;
 }
 
-// src/commands/product/list.ts
+// src/schemas/node-types.ts
 import { z as z9 } from "zod";
-var ProductImageSummarySchema = z9.object({
-  id: z9.string().uuid(),
-  url: z9.string(),
-  altText: z9.string().nullable(),
-  isPrimary: z9.boolean(),
-  sortOrder: z9.number().int()
+var NodeTypeSummarySchema = z9.object({
+  type: z9.string(),
+  portCount: z9.number()
+}).strict();
+var NodeTypePortSchema = z9.object({
+  handleId: z9.string(),
+  direction: z9.enum(["input", "output"]),
+  dataType: z9.string()
+}).strict();
+var NodeTypeDetailSchema = z9.object({
+  type: z9.string(),
+  ports: z9.array(NodeTypePortSchema),
+  agentWritableFields: z9.array(z9.string())
+}).strict();
+var NodeTypesListResponseSchema = z9.object({
+  nodeTypes: z9.array(NodeTypeSummarySchema)
+}).strict();
+
+// src/commands/nodes/internal.ts
+async function buildNodesClient(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/nodes/describe.ts
+async function describeNode(opts) {
+  const client = opts.client ?? await buildNodesClient(opts);
+  return client.request({
+    method: "GET",
+    path: `/node-types/${encodeURIComponent(opts.type)}`,
+    responseSchema: NodeTypeDetailSchema,
+    signal: opts.signal
+  });
+}
+
+// src/commands/nodes/list.ts
+async function listNodes(opts) {
+  const client = opts.client ?? await buildNodesClient(opts);
+  const data = await client.request({
+    method: "GET",
+    path: "/node-types",
+    responseSchema: NodeTypesListResponseSchema,
+    signal: opts.signal
+  });
+  return data;
+}
+
+// src/commands/product/list.ts
+import { z as z10 } from "zod";
+var ProductImageSummarySchema = z10.object({
+  id: z10.string().uuid(),
+  url: z10.string(),
+  altText: z10.string().nullable(),
+  isPrimary: z10.boolean(),
+  sortOrder: z10.number().int()
 });
-var ProductSummarySchema = z9.object({
-  id: z9.string().uuid(),
-  title: z9.string(),
-  sourceType: z9.string(),
-  syncStatus: z9.enum(["synced", "pending", "stale", "error", "deleted_upstream"]).nullable(),
-  vendor: z9.string().nullable(),
-  productType: z9.string().nullable(),
-  tags: z9.array(z9.string()),
-  images: z9.array(ProductImageSummarySchema)
+var ProductSummarySchema = z10.object({
+  id: z10.string().uuid(),
+  title: z10.string(),
+  sourceType: z10.string(),
+  syncStatus: z10.enum(["synced", "pending", "stale", "error", "deleted_upstream"]).nullable(),
+  vendor: z10.string().nullable(),
+  productType: z10.string().nullable(),
+  tags: z10.array(z10.string()),
+  images: z10.array(ProductImageSummarySchema)
 });
-var ProductsListResponseSchema = z9.object({
-  items: z9.array(ProductSummarySchema),
-  nextCursor: z9.string().nullable()
+var ProductsListResponseSchema = z10.object({
+  items: z10.array(ProductSummarySchema),
+  nextCursor: z10.string().nullable()
 });
 var DEFAULT_LIMIT = 50;
 async function listProducts(options) {
@@ -2785,33 +2856,33 @@ async function buildTemplateClient(opts) {
 }
 
 // src/schemas/templates.ts
-import { z as z10 } from "zod";
-var DeclaredParamSchema = z10.object({
-  name: z10.string(),
-  type: z10.string(),
-  required: z10.boolean(),
-  defaultValue: z10.string().nullable().optional(),
-  enumValues: z10.array(z10.string()).nullable().optional(),
-  description: z10.string().nullable().optional()
+import { z as z11 } from "zod";
+var DeclaredParamSchema = z11.object({
+  name: z11.string(),
+  type: z11.string(),
+  required: z11.boolean(),
+  defaultValue: z11.string().nullable().optional(),
+  enumValues: z11.array(z11.string()).nullable().optional(),
+  description: z11.string().nullable().optional()
 }).strict();
-var TemplateSummarySchema = z10.object({
-  id: z10.string().uuid(),
-  source: z10.enum(["own", "system"]),
-  name: z10.string(),
-  description: z10.string().nullable(),
-  category: z10.string().nullable(),
-  thumbnailUrl: z10.string().nullable(),
-  tags: z10.array(z10.string()),
-  createdAt: z10.string()
+var TemplateSummarySchema = z11.object({
+  id: z11.string().uuid(),
+  source: z11.enum(["own", "system"]),
+  name: z11.string(),
+  description: z11.string().nullable(),
+  category: z11.string().nullable(),
+  thumbnailUrl: z11.string().nullable(),
+  tags: z11.array(z11.string()),
+  createdAt: z11.string()
 }).strict();
 var TemplateDetailSchema = TemplateSummarySchema.extend({
-  declaredParams: z10.array(DeclaredParamSchema),
-  timesUsed: z10.number()
+  declaredParams: z11.array(DeclaredParamSchema),
+  timesUsed: z11.number()
 }).strict();
-var TemplatesListResponseSchema = z10.object({
-  templates: z10.array(TemplateSummarySchema),
-  cursor: z10.string().nullable(),
-  hasMore: z10.boolean()
+var TemplatesListResponseSchema = z11.object({
+  templates: z11.array(TemplateSummarySchema),
+  cursor: z11.string().nullable(),
+  hasMore: z11.boolean()
 }).strict();
 
 // src/commands/template/list.ts
@@ -2861,20 +2932,20 @@ async function getTemplate(opts) {
 }
 
 // src/commands/tokens/list.ts
-import { z as z11 } from "zod";
-var TokenRowSchema = z11.object({
-  id: z11.string().uuid(),
-  organizationId: z11.string().uuid(),
-  userId: z11.string().uuid(),
-  clientId: z11.string().nullable(),
-  tokenPrefix: z11.string(),
-  name: z11.string().nullable(),
-  scopes: z11.array(z11.string()),
-  lastUsedAt: z11.string().nullable(),
-  expiresAt: z11.string(),
-  createdAt: z11.string()
+import { z as z12 } from "zod";
+var TokenRowSchema = z12.object({
+  id: z12.string().uuid(),
+  organizationId: z12.string().uuid(),
+  userId: z12.string().uuid(),
+  clientId: z12.string().nullable(),
+  tokenPrefix: z12.string(),
+  name: z12.string().nullable(),
+  scopes: z12.array(z12.string()),
+  lastUsedAt: z12.string().nullable(),
+  expiresAt: z12.string(),
+  createdAt: z12.string()
 }).strict();
-var TokensListResponseSchema = z11.array(TokenRowSchema);
+var TokensListResponseSchema = z12.array(TokenRowSchema);
 async function listTokens(options) {
   const config = await loadConfig({
     flagProfile: options.profile,
@@ -2900,51 +2971,51 @@ async function listTokens(options) {
 }
 
 // src/schemas/workflows.ts
-import { z as z12 } from "zod";
-var WorkflowDeclaredParamSchema = z12.object({
-  name: z12.string(),
-  type: z12.string(),
-  required: z12.boolean().optional(),
-  defaultValue: z12.unknown().optional(),
-  description: z12.unknown().optional()
+import { z as z13 } from "zod";
+var WorkflowDeclaredParamSchema = z13.object({
+  name: z13.string(),
+  type: z13.string(),
+  required: z13.boolean().optional(),
+  defaultValue: z13.unknown().optional(),
+  description: z13.unknown().optional()
 }).passthrough();
-var WorkflowSummarySchema = z12.object({
-  id: z12.string().uuid(),
-  name: z12.string(),
-  tags: z12.array(z12.string()),
-  declared_params: z12.array(WorkflowDeclaredParamSchema).nullable().default([]),
-  canvas_rev: z12.number().int().nonnegative(),
-  updated_at: z12.string()
+var WorkflowSummarySchema = z13.object({
+  id: z13.string().uuid(),
+  name: z13.string(),
+  tags: z13.array(z13.string()),
+  declared_params: z13.array(WorkflowDeclaredParamSchema).nullable().default([]),
+  canvas_rev: z13.number().int().nonnegative(),
+  updated_at: z13.string()
 }).strict();
-var WorkflowsListResponseSchema = z12.object({
-  items: z12.array(WorkflowSummarySchema),
-  nextCursor: z12.string().nullable()
+var WorkflowsListResponseSchema = z13.object({
+  items: z13.array(WorkflowSummarySchema),
+  nextCursor: z13.string().nullable()
 }).strict();
-var WorkflowDetailSchema = z12.object({
-  id: z12.string().uuid(),
-  name: z12.string(),
-  description: z12.string().nullable(),
-  tags: z12.array(z12.string()),
-  declared_params: z12.array(WorkflowDeclaredParamSchema).nullable().default([]),
-  canvas_rev: z12.number().int().nonnegative(),
-  nodes: z12.array(z12.unknown()),
-  edges: z12.array(z12.unknown()),
-  created_at: z12.string(),
-  updated_at: z12.string()
+var WorkflowDetailSchema = z13.object({
+  id: z13.string().uuid(),
+  name: z13.string(),
+  description: z13.string().nullable(),
+  tags: z13.array(z13.string()),
+  declared_params: z13.array(WorkflowDeclaredParamSchema).nullable().default([]),
+  canvas_rev: z13.number().int().nonnegative(),
+  nodes: z13.array(z13.unknown()),
+  edges: z13.array(z13.unknown()),
+  created_at: z13.string(),
+  updated_at: z13.string()
 }).strict();
-var WorkflowCreateResponseSchema = z12.object({
-  id: z12.string().uuid(),
-  name: z12.string(),
-  description: z12.string().nullable(),
-  tags: z12.array(z12.string()),
-  declared_params: z12.array(WorkflowDeclaredParamSchema).nullable().default([]),
-  canvas_rev: z12.number().int().nonnegative(),
-  created_at: z12.string(),
-  updated_at: z12.string()
+var WorkflowCreateResponseSchema = z13.object({
+  id: z13.string().uuid(),
+  name: z13.string(),
+  description: z13.string().nullable(),
+  tags: z13.array(z13.string()),
+  declared_params: z13.array(WorkflowDeclaredParamSchema).nullable().default([]),
+  canvas_rev: z13.number().int().nonnegative(),
+  created_at: z13.string(),
+  updated_at: z13.string()
 }).strict();
-var WorkflowMutateResponseSchema = z12.object({
-  canvas_rev: z12.number().int().nonnegative(),
-  applied: z12.number().int().nonnegative(),
+var WorkflowMutateResponseSchema = z13.object({
+  canvas_rev: z13.number().int().nonnegative(),
+  applied: z13.number().int().nonnegative(),
   workflow: WorkflowDetailSchema
 }).strict();
 
@@ -3439,6 +3510,40 @@ function renderTemplateDetail(detail, out) {
   }
   out.write(lines.join("\n") + "\n");
 }
+function renderNodesList(result, out) {
+  const { nodeTypes } = result;
+  if (nodeTypes.length === 0) {
+    out.write("No node types.\n");
+    return;
+  }
+  const headers = ["TYPE", "PORTS"];
+  const data = nodeTypes.map((n) => [n.type, String(n.portCount)]);
+  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 renderNodeDetail(detail, out) {
+  const lines = [detail.type, "", "Ports:"];
+  if (detail.ports.length === 0) {
+    lines.push("  (none)");
+  } else {
+    for (const p of detail.ports) {
+      lines.push(`  - ${p.handleId}  (${p.direction}, ${p.dataType})`);
+    }
+  }
+  lines.push("", "Agent-writable fields:");
+  if (detail.agentWritableFields.length === 0) {
+    lines.push("  (none)");
+  } else {
+    for (const field of detail.agentWritableFields) {
+      lines.push(`  - ${field}`);
+    }
+  }
+  out.write(lines.join("\n") + "\n");
+}
 var TIER_ORDER = { premium: 0, pro: 1, standard: 2 };
 function renderModelsList(result, out, options) {
   const { models } = result;
@@ -3464,15 +3569,22 @@ function renderModelsList(result, out, options) {
   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 MAX_BADGES = 3;
+  const headers = ["SLUG", "NAME", "CATEGORY", "TIER", "CREDITS", "DEFAULT", "BADGES"];
+  const data = sorted.map((m) => {
+    const labels = m.badges.map((b) => b.label);
+    const shown = labels.slice(0, MAX_BADGES).join(", ");
+    const extra = labels.length > MAX_BADGES ? ` +${labels.length - MAX_BADGES} more` : "";
+    return [
+      m.slug,
+      m.displayName,
+      m.category,
+      m.costTier,
+      String(m.creditCost),
+      m.isDefault ? "\u2713" : "",
+      labels.length > 0 ? shown + extra : "\u2014"
+    ];
+  });
   const widths = headers.map(
     (header, i) => Math.max(header.length, ...data.map((cells) => cells[i].length))
   );
@@ -3808,6 +3920,8 @@ function renderRootHelp(version) {
     "  brand-model list        List available brand models",
     "  product list            List products in your organization",
     "  models list             List available AI models",
+    "  nodes list              List available workflow node types",
+    "  nodes describe          Describe a node type's ports and fields",
     "  telemetry inspect       Show current telemetry state and payload shape",
     "  template list            List available templates",
     "  template get             Fetch a template by ID",
@@ -3949,6 +4063,42 @@ function renderCommandHelp(command) {
         "  clickraft models list --featured --json",
         ""
       ].join("\n");
+    case "nodes":
+      return [
+        "Usage: clickraft nodes <subcommand> [options]",
+        "",
+        "Subcommands:",
+        "  list      List available workflow node types",
+        "  describe  Show a node type's ports and agent-writable fields",
+        ""
+      ].join("\n");
+    case "nodes list":
+      return [
+        "Usage: clickraft nodes list [options]",
+        "",
+        "Lists the workflow node types available to the API, with port counts.",
+        "",
+        "Options:",
+        "  --profile <name>",
+        "  --api-base-url <url>",
+        "  --token <token>",
+        "  --json",
+        ""
+      ].join("\n");
+    case "nodes describe":
+      return [
+        "Usage: clickraft nodes describe <type> [options]",
+        "",
+        "Shows a node type's ports (handleId, direction, dataType) and the fields",
+        "an agent may write. Handle ids are printed verbatim for use in edges.",
+        "",
+        "Options:",
+        "  --profile <name>",
+        "  --api-base-url <url>",
+        "  --token <token>",
+        "  --json",
+        ""
+      ].join("\n");
     case "telemetry inspect":
       return [
         "Usage: clickraft telemetry inspect [options]",
@@ -4236,6 +4386,13 @@ function matchNewCommand(argv) {
     if (sub === void 0 || sub.startsWith("-")) return { kind: "sub-help", verb: "models" };
     return { kind: "unknown-sub", verb: "models", sub };
   }
+  if (verb === "nodes") {
+    const sub = argv[1];
+    if (sub === "list") return { kind: "cmd", path: "nodes.list", verbTokenCount: 2 };
+    if (sub === "describe") return { kind: "cmd", path: "nodes.describe", verbTokenCount: 2 };
+    if (sub === void 0 || sub.startsWith("-")) return { kind: "sub-help", verb: "nodes" };
+    return { kind: "unknown-sub", verb: "nodes", sub };
+  }
   if (verb === "workflow") {
     const sub = argv[1];
     if (sub === "create") return { kind: "cmd", path: "workflow.create", verbTokenCount: 2 };
@@ -4305,6 +4462,10 @@ async function runNewCommand(newCmd, options, stdout, stderr) {
         return await runProductList(argvAfterVerb, ctx, rc);
       case "models.list":
         return await runModelsList(argvAfterVerb, ctx, rc);
+      case "nodes.list":
+        return await runNodesList(argvAfterVerb, ctx, rc);
+      case "nodes.describe":
+        return await runNodesDescribe(argvAfterVerb, ctx, rc);
       case "workflow.create":
         return await runWorkflowCreate(argvAfterVerb, ctx, rc);
       case "workflow.list":
@@ -4691,6 +4852,57 @@ function emitModelsList(result, ctx, rc, parsed) {
     }
   });
 }
+async function runNodesList(argv, ctx, rc) {
+  const parsed = parseArgs(argv, {
+    string: [...COMMON_RICH_STRING_FLAGS],
+    boolean: [...COMMON_RICH_BOOL_FLAGS]
+  });
+  const result = await listNodes({
+    profile: parsed.string.profile,
+    apiBaseUrl: parsed.string["api-base-url"],
+    token: parsed.string.token,
+    signal: rc.signal
+  });
+  emitNodesList(result, ctx, rc);
+  return 0;
+}
+async function runNodesDescribe(argv, ctx, rc) {
+  const parsed = parseArgs(argv, {
+    string: [...COMMON_RICH_STRING_FLAGS],
+    boolean: [...COMMON_RICH_BOOL_FLAGS]
+  });
+  const type = parsed.positional[0];
+  if (!type) throw new ArgError("Missing required <type> argument.");
+  const detail = await describeNode({
+    type,
+    profile: parsed.string.profile,
+    apiBaseUrl: parsed.string["api-base-url"],
+    token: parsed.string.token,
+    signal: rc.signal
+  });
+  emitNodeDetail(detail, ctx, rc);
+  return 0;
+}
+function emitNodesList(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;
+  }
+  renderNodesList(result, rc.stdout);
+}
+function emitNodeDetail(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;
+  }
+  renderNodeDetail(detail, rc.stdout);
+}
 async function runWorkflowCreate(argv, ctx, rc) {
   const parsed = parseArgs(argv, {
     string: [...COMMON_RICH_STRING_FLAGS, "name", "description", "from-file"],