@clickraft/cli 0.8.2 → 0.8.4

package/dist/cli.js

@@ -5,11 +5,11 @@ import { readFileSync } from "fs";
 import { dirname as dirname2, join as join2 } from "path";
 import { fileURLToPath } from "url";
 
-// src/api/client.ts
-import { request as undiciRequest } from "undici";
+// ../sdk/dist/index.js
+import { z } from "zod";
 import { z as z2 } from "zod";
-
-// src/auth/redact.ts
+import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 var TOKEN_FIELD_PATTERN = /"(access_token|refresh_token|device_code|user_code|code_verifier|client_secret)"\s*:\s*"[^"]*"/gi;
 var BARE_TOKEN_PATTERN = /\bck_(?:live|dev|test)_[A-Za-z0-9_-]+/gi;
 function redactTokenLikeFields(input) {
@@ -20,6 +20,192 @@ function redactTokenLikeValue(token) {
   if (token.length <= 12) return "[REDACTED]";
   return `${token.slice(0, 8)}...[REDACTED]`;
 }
+var BalanceResponseSchema = z.object({
+  totalCredits: z.number(),
+  subscriptionCredits: z.number(),
+  purchasedCredits: z.number(),
+  promotionalCredits: z.number(),
+  rateLimit: z.object({
+    apiBurstPerMinute: z.number()
+  }).strict()
+}).strict();
+var BrandModelSummarySchema = z2.object({
+  id: z2.string().uuid(),
+  source: z2.enum(["system", "user"]),
+  slug: z2.string().nullable(),
+  name: z2.string(),
+  description: z2.string().nullable(),
+  thumbnailUrl: z2.string().nullable(),
+  tags: z2.array(z2.string()),
+  category: z2.string().nullable(),
+  isPremium: z2.boolean().nullable(),
+  isFeatured: z2.boolean().nullable(),
+  badgeText: z2.string().nullable(),
+  usageCount: z2.number().nullable(),
+  createdAt: z2.string()
+}).strict();
+var BrandModelsListResponseSchema = z2.object({
+  brandModels: z2.array(BrandModelSummarySchema)
+}).strict();
+var ProductImageSummarySchema = z3.object({
+  id: z3.string().uuid(),
+  url: z3.string(),
+  altText: z3.string().nullable(),
+  isPrimary: z3.boolean(),
+  sortOrder: z3.number().int()
+});
+var ProductSummarySchema = z3.object({
+  id: z3.string().uuid(),
+  title: z3.string(),
+  sourceType: z3.string(),
+  syncStatus: z3.enum(["synced", "pending", "stale", "error", "deleted_upstream"]).nullable(),
+  vendor: z3.string().nullable(),
+  productType: z3.string().nullable(),
+  tags: z3.array(z3.string()),
+  images: z3.array(ProductImageSummarySchema)
+});
+var ProductsListResponseSchema = z3.object({
+  items: z3.array(ProductSummarySchema),
+  nextCursor: z3.string().nullable()
+});
+var TokenRowSchema = z4.object({
+  id: z4.string().uuid(),
+  organizationId: z4.string().uuid(),
+  userId: z4.string().uuid(),
+  clientId: z4.string().nullable(),
+  tokenPrefix: z4.string(),
+  name: z4.string().nullable(),
+  scopes: z4.array(z4.string()),
+  lastUsedAt: z4.string().nullable(),
+  expiresAt: z4.string(),
+  createdAt: z4.string()
+}).strict();
+var TokensListResponseSchema = z4.array(TokenRowSchema);
+var SERVER_ERROR_CODES = [
+  "AUTH_TOKEN_MISSING",
+  "AUTH_TOKEN_INVALID",
+  "AUTH_TOKEN_EXPIRED",
+  "AUTH_TOKEN_REVOKED",
+  "AUTH_TOKEN_SCOPE_INSUFFICIENT",
+  "AUTH_ORG_MISMATCH",
+  "AUTH_DEVICE_CODE_PENDING",
+  "AUTH_DEVICE_CODE_EXPIRED",
+  "AUTH_DEVICE_CODE_SLOW_DOWN",
+  "IDEMPOTENCY_KEY_MISSING",
+  "IDEMPOTENCY_KEY_CONFLICT",
+  "PLAN_FEATURE_LOCKED",
+  "PLAN_QUOTA_EXCEEDED",
+  "INSUFFICIENT_CREDITS",
+  "CREDIT_DEDUCTION_FAILED",
+  "RATE_LIMITED",
+  "INPUT_INVALID_FORMAT",
+  "INPUT_TOO_LONG",
+  "WORKFLOW_VALIDATION_FAILED",
+  "WORKFLOW_NODE_TYPE_UNKNOWN",
+  "CANVAS_REV_MISMATCH",
+  "CANVAS_REV_REQUIRED",
+  "WORKER_UNREACHABLE",
+  "IDEMPOTENCY_IN_PROGRESS",
+  "TOKEN_NAME_INVALID",
+  "WORKFLOW_NOT_FOUND",
+  "NOT_FOUND",
+  "NODE_TYPE_NOT_FOUND",
+  "FEATURE_DISABLED",
+  "FORBIDDEN",
+  "MODEL_NOT_FOUND",
+  "PROVIDER_UNAVAILABLE",
+  "STORAGE_UPLOAD_FAILED",
+  "STORAGE_QUOTA_EXCEEDED",
+  "GEN_CONTENT_REFUSAL",
+  "GEN_OUTPUT_SCHEMA_MISMATCH",
+  "GEN_EMPTY_OUTPUT",
+  "GEN_ITEM_COUNT_MISMATCH",
+  "AGENT_FINGERPRINT_REJECTED",
+  "INTERNAL_ERROR",
+  "BRAND_MODEL_NOT_FOUND",
+  "BRAND_MODEL_NOT_A_MODEL",
+  "BRAND_MODEL_NOT_ACTIVE",
+  "BRAND_MODEL_NO_REFERENCES",
+  "BRAND_MODEL_POSE_NOT_FOUND",
+  "BRAND_MODEL_DUPLICATE_ID",
+  "MODEL_DOES_NOT_SUPPORT_REFERENCES",
+  "REFERENCE_LIMIT_EXCEEDED",
+  "PRODUCT_NOT_FOUND",
+  "PRODUCT_DUPLICATE_REFERENCE",
+  "PRODUCT_IMAGE_NOT_FOUND",
+  "PRODUCT_IMAGE_MISMATCH",
+  "PRODUCT_SYNC_ERROR",
+  "PRODUCT_DELETED_UPSTREAM",
+  "PRODUCT_NO_PRIMARY_IMAGE",
+  "PRODUCT_SOURCE_MANAGED"
+];
+var KNOWN_SERVER_CODES = new Set(SERVER_ERROR_CODES);
+var ApiError = class extends Error {
+  code;
+  meta;
+  cause;
+  constructor(code, message, meta, cause) {
+    super(message);
+    this.name = "ApiError";
+    this.code = code;
+    this.meta = meta;
+    this.cause = cause;
+  }
+};
+async function longPoll(opts) {
+  const now = opts.now ?? Date.now;
+  const started = now();
+  for (; ; ) {
+    if (opts.signal?.aborted) {
+      throw new ApiError("TIMEOUT", "Wait was aborted.", { retryable: true });
+    }
+    const elapsedBefore = now() - started;
+    if (elapsedBefore >= opts.timeoutMs) {
+      throw new ApiError(
+        "TIMEOUT",
+        `Wait exceeded ${opts.timeoutMs}ms without reaching a terminal state.`,
+        { retryable: true }
+      );
+    }
+    const remainingMs = opts.timeoutMs - elapsedBefore;
+    const iterationSignal = composeIterationSignal(opts.signal, remainingMs);
+    let result;
+    try {
+      result = await opts.fetcher({ signal: iterationSignal });
+    } catch (err) {
+      if (opts.signal?.aborted || now() - started >= opts.timeoutMs) {
+        throw new ApiError(
+          "TIMEOUT",
+          `Wait exceeded ${opts.timeoutMs}ms without reaching a terminal state.`,
+          { retryable: true }
+        );
+      }
+      throw err;
+    }
+    if (opts.signal?.aborted) {
+      throw new ApiError("TIMEOUT", "Wait was aborted.", { retryable: true });
+    }
+    const elapsedAfter = now() - started;
+    if (elapsedAfter >= opts.timeoutMs) {
+      throw new ApiError(
+        "TIMEOUT",
+        `Wait exceeded ${opts.timeoutMs}ms without reaching a terminal state.`,
+        { retryable: true }
+      );
+    }
+    if (opts.isTerminal(result)) {
+      return result;
+    }
+  }
+}
+function composeIterationSignal(userSignal, remainingMs) {
+  const deadlineSignal = AbortSignal.timeout(Math.max(remainingMs, 0));
+  return userSignal ? AbortSignal.any([userSignal, deadlineSignal]) : deadlineSignal;
+}
+
+// src/api/client.ts
+import { request as undiciRequest } from "undici";
+import { z as z6 } from "zod";
 
 // src/errors/codes.ts
 var LOGIN_HINT = "Run `clickraft login` to authenticate.";
@@ -433,15 +619,6 @@ var EXIT_CODE_MAP = {
     hint: "Server response did not match the expected schema. Update the CLI."
   }
 };
-var CLI_ONLY_CODES = /* @__PURE__ */ new Set([
-  "NETWORK_ERROR",
-  "TIMEOUT",
-  "PARSE_ERROR",
-  "SCHEMA_MISMATCH"
-]);
-var KNOWN_SERVER_CODES = new Set(
-  Object.keys(EXIT_CODE_MAP).filter((k) => !CLI_ONLY_CODES.has(k))
-);
 function getExitCode(code) {
   return EXIT_CODE_MAP[code]?.exitCode ?? 1;
 }
@@ -554,31 +731,19 @@ function signalToAbortError(signal) {
 }
 
 // src/api/types.ts
-import { z } from "zod";
-var ServerSuccessSchema = (payload) => z.object({ data: payload }).strict();
-var ServerErrorBodySchema = z.object({
-  error: z.object({
-    code: z.string().min(1),
-    message: z.string(),
-    correlationId: z.string().optional(),
-    retryAfter: z.number().int().nonnegative().optional(),
-    details: z.unknown().optional()
+import { z as z5 } from "zod";
+var ServerSuccessSchema = (payload) => z5.object({ data: payload }).strict();
+var ServerErrorBodySchema = z5.object({
+  error: z5.object({
+    code: z5.string().min(1),
+    message: z5.string(),
+    correlationId: z5.string().optional(),
+    retryAfter: z5.number().int().nonnegative().optional(),
+    details: z5.unknown().optional()
   }).strict()
 }).strict();
 
 // src/api/client.ts
-var ApiError = class extends Error {
-  code;
-  meta;
-  cause;
-  constructor(code, message, meta, cause) {
-    super(message);
-    this.name = "ApiError";
-    this.code = code;
-    this.meta = meta;
-    this.cause = cause;
-  }
-};
 var REDACT_BODY_LIMIT = 1024;
 var REDACT_INPUT_CAP = 100 * 1024;
 var DEFAULT_USER_AGENT = "clickraft-cli";
@@ -744,7 +909,7 @@ function parseSuccessBody(args) {
       err
     );
   }
-  const envelope = ServerSuccessSchema(args.responseSchema ?? z2.unknown()).safeParse(parsed);
+  const envelope = ServerSuccessSchema(args.responseSchema ?? z6.unknown()).safeParse(parsed);
   if (!envelope.success) {
     const issues = formatSchemaIssues(envelope.error);
     throw new ApiError(
@@ -985,9 +1150,6 @@ function buildPayload(args) {
   return payload;
 }
 
-// src/commands/balance.ts
-import { z as z4 } from "zod";
-
 // src/auth/credentials.ts
 import {
   access,
@@ -1030,31 +1192,31 @@ function getCredentialsPath(ctx = {}) {
 }
 
 // src/auth/types.ts
-import { z as z3 } from "zod";
-var DeviceAuthorizationRequestSchema = z3.object({
-  client_id: z3.string(),
-  scope: z3.string()
+import { z as z7 } from "zod";
+var DeviceAuthorizationRequestSchema = z7.object({
+  client_id: z7.string(),
+  scope: z7.string()
 });
-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 DeviceAuthorizationResponseSchema = z7.object({
+  device_code: z7.string(),
+  user_code: z7.string().min(1),
+  verification_uri: z7.string().url(),
+  verification_uri_complete: z7.string().url().optional(),
+  expires_in: z7.number().int().positive(),
+  interval: z7.number().int().positive().default(5)
 });
-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 DeviceTokenPollRequestSchema = z7.object({
+  client_id: z7.string(),
+  device_code: z7.string(),
+  grant_type: z7.literal("urn:ietf:params:oauth:grant-type:device_code")
 });
-var TokenResponseSchema = z3.object({
-  access_token: z3.string(),
-  token_type: z3.literal("Bearer"),
-  expires_in: z3.number().int().positive(),
-  scope: z3.string()
+var TokenResponseSchema = z7.object({
+  access_token: z7.string(),
+  token_type: z7.literal("Bearer"),
+  expires_in: z7.number().int().positive(),
+  scope: z7.string()
 });
-var DeviceTokenPollErrorCodeSchema = z3.enum([
+var DeviceTokenPollErrorCodeSchema = z7.enum([
   "authorization_pending",
   "slow_down",
   "access_denied",
@@ -1065,27 +1227,27 @@ var DeviceTokenPollErrorCodeSchema = z3.enum([
   "unsupported_grant_type",
   "invalid_scope"
 ]);
-var DeviceTokenPollErrorSchema = z3.object({
+var DeviceTokenPollErrorSchema = z7.object({
   error: DeviceTokenPollErrorCodeSchema,
-  error_description: z3.string().optional()
+  error_description: z7.string().optional()
 });
-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()
+var CredentialsProfileSchema = z7.object({
+  apiBaseUrl: z7.string().url(),
+  accessToken: z7.string(),
+  tokenType: z7.literal("Bearer"),
+  tokenPrefix: z7.string(),
+  organizationId: z7.string().uuid(),
+  organizationSlug: z7.string(),
+  userId: z7.string().uuid(),
+  scopes: z7.array(z7.string()),
+  expiresAt: z7.string().datetime(),
+  issuedAt: z7.string().datetime(),
+  clientId: z7.string()
 }).strict();
-var CredentialsFileSchema = z3.object({
-  version: z3.literal(1),
-  defaultProfile: z3.string(),
-  profiles: z3.record(z3.string(), CredentialsProfileSchema)
+var CredentialsFileSchema = z7.object({
+  version: z7.literal(1),
+  defaultProfile: z7.string(),
+  profiles: z7.record(z7.string(), CredentialsProfileSchema)
 }).strict();
 
 // src/auth/credentials.ts
@@ -1318,15 +1480,6 @@ function trim(value) {
 }
 
 // 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,
@@ -1352,25 +1505,7 @@ async function getBalance(options) {
 }
 
 // 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();
+import "zod";
 async function listBrandModels(options) {
   const config = await loadConfig({
     flagProfile: options.profile,
@@ -1396,35 +1531,35 @@ async function listBrandModels(options) {
 }
 
 // src/schemas/jobs.ts
-import { z as z6 } from "zod";
-var ProductReferenceSchema = z6.object({
-  id: z6.string().uuid(),
-  imageId: z6.string().uuid().optional()
+import { z as z9 } from "zod";
+var ProductReferenceSchema = z9.object({
+  id: z9.string().uuid(),
+  imageId: z9.string().uuid().optional()
 }).strict();
-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()
+var GenerateCreateRequestSchema = z9.object({
+  modelSlug: z9.string().min(1).max(100),
+  input: z9.object({
+    prompt: z9.string().max(1e4).optional(),
+    referenceImageUrl: z9.string().url().optional(),
+    referenceImages: z9.array(z9.string().url()).max(8).optional(),
+    aspectRatio: z9.string().regex(/^\d+:\d+$/).optional(),
+    resolution: z9.string().regex(/^\d+x\d+$/).optional(),
+    durationSeconds: z9.number().int().min(1).max(60).optional(),
+    providerParams: z9.record(z9.string(), z9.unknown()).optional()
   }).strict(),
-  options: z6.object({
-    workflowId: z6.string().uuid().optional(),
-    nodeId: z6.string().optional()
+  options: z9.object({
+    workflowId: z9.string().uuid().optional(),
+    nodeId: z9.string().optional()
   }).strict().optional(),
-  products: z6.array(ProductReferenceSchema).min(1).max(10).optional()
+  products: z9.array(ProductReferenceSchema).min(1).max(10).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()
+var GenerateCreateResponseSchema = z9.object({
+  jobId: z9.string().uuid(),
+  status: z9.enum(["queued", "processing", "completed", "failed"]),
+  estimatedSeconds: z9.number().int().nonnegative().nullable(),
+  creditsCharged: z9.number().int().nonnegative()
 }).strict();
-var GenerationStatusSchema = z6.enum([
+var GenerationStatusSchema = z9.enum([
   "queued",
   "processing",
   "uploading",
@@ -1440,18 +1575,18 @@ var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
 function isTerminalStatus(status) {
   return TERMINAL_STATUSES.has(status);
 }
-var GenerationResultSchema = z6.object({
-  jobId: z6.string().uuid(),
+var GenerationResultSchema = z9.object({
+  jobId: z9.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()
+  modelSlug: z9.string(),
+  resultUrl: z9.string().url().nullable(),
+  thumbnailUrl: z9.string().url().nullable(),
+  errorCode: z9.string().nullable(),
+  errorMessage: z9.string().nullable(),
+  creditsCharged: z9.number().int().nonnegative(),
+  creditsRefunded: z9.boolean(),
+  startedAt: z9.string().nullable(),
+  completedAt: z9.string().nullable()
 }).strict();
 
 // src/commands/upload.ts
@@ -1461,19 +1596,19 @@ import { basename } from "path";
 import { request as undiciRequest2 } from "undici";
 
 // src/schemas/assets.ts
-import { z as z7 } from "zod";
+import { z as z10 } from "zod";
 var MAX_UPLOAD_SIZE_BYTES = 15 * 1024 * 1024;
-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}$/)
+var UploadRequestSchema = z10.object({
+  filename: z10.string().min(1).max(255),
+  contentType: z10.string().regex(/^[\w-]+\/[\w+.-]+$/),
+  sizeBytes: z10.number().int().positive().max(MAX_UPLOAD_SIZE_BYTES),
+  contentHash: z10.string().regex(/^sha256:[0-9a-f]{64}$/)
 }).strict();
-var UploadResponseSchema = z7.object({
-  assetId: z7.string().uuid(),
-  uploadUrl: z7.string().url(),
-  publicUrl: z7.string().url(),
-  deduplicated: z7.boolean()
+var UploadResponseSchema = z10.object({
+  assetId: z10.string().uuid(),
+  uploadUrl: z10.string().url(),
+  publicUrl: z10.string().url(),
+  deduplicated: z10.boolean()
 }).strict();
 
 // src/commands/upload.ts
@@ -1722,58 +1857,6 @@ function isUrlLike(value) {
   return value.startsWith("http://") || value.startsWith("https://");
 }
 
-// src/cli/long-poll.ts
-async function longPoll(opts) {
-  const now = opts.now ?? Date.now;
-  const started = now();
-  for (; ; ) {
-    if (opts.signal?.aborted) {
-      throw new ApiError("TIMEOUT", "Wait was aborted.", { retryable: true });
-    }
-    const elapsedBefore = now() - started;
-    if (elapsedBefore >= opts.timeoutMs) {
-      throw new ApiError(
-        "TIMEOUT",
-        `Wait exceeded ${opts.timeoutMs}ms without reaching a terminal state.`,
-        { retryable: true }
-      );
-    }
-    const remainingMs = opts.timeoutMs - elapsedBefore;
-    const iterationSignal = composeIterationSignal(opts.signal, remainingMs);
-    let result;
-    try {
-      result = await opts.fetcher({ signal: iterationSignal });
-    } catch (err) {
-      if (opts.signal?.aborted || now() - started >= opts.timeoutMs) {
-        throw new ApiError(
-          "TIMEOUT",
-          `Wait exceeded ${opts.timeoutMs}ms without reaching a terminal state.`,
-          { retryable: true }
-        );
-      }
-      throw err;
-    }
-    if (opts.signal?.aborted) {
-      throw new ApiError("TIMEOUT", "Wait was aborted.", { retryable: true });
-    }
-    const elapsedAfter = now() - started;
-    if (elapsedAfter >= opts.timeoutMs) {
-      throw new ApiError(
-        "TIMEOUT",
-        `Wait exceeded ${opts.timeoutMs}ms without reaching a terminal state.`,
-        { retryable: true }
-      );
-    }
-    if (opts.isTerminal(result)) {
-      return result;
-    }
-  }
-}
-function composeIterationSignal(userSignal, remainingMs) {
-  const deadlineSignal = AbortSignal.timeout(Math.max(remainingMs, 0));
-  return userSignal ? AbortSignal.any([userSignal, deadlineSignal]) : deadlineSignal;
-}
-
 // src/commands/generate/get.ts
 async function generateGet(opts) {
   const client = opts.client ?? await buildGenerateClient(opts);
@@ -2569,48 +2652,48 @@ function formatRevokeFailure(err, token) {
 }
 
 // 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())
+import { z as z11 } from "zod";
+var ModelSummarySchema = z11.object({
+  id: z11.string().uuid(),
+  slug: z11.string(),
+  displayName: z11.string(),
+  description: z11.string().nullable(),
+  shortDescription: z11.string().nullable(),
+  providerSlug: z11.string(),
+  providerName: z11.string(),
+  modelType: z11.string(),
+  category: z11.string(),
+  costTier: z11.string(),
+  creditCost: z11.number(),
+  pricingStrategy: z11.string(),
+  estimatedSeconds: z11.object({
+    typical: z11.number(),
+    range: z11.array(z11.number())
   }).passthrough().nullable(),
-  status: z8.string(),
-  modalities: z8.object({
-    input: z8.array(z8.string()),
-    output: z8.array(z8.string())
+  status: z11.string(),
+  modalities: z11.object({
+    input: z11.array(z11.string()),
+    output: z11.array(z11.string())
   }).passthrough().nullable(),
-  bestFor: z8.array(z8.string()),
-  badges: z8.array(
-    z8.object({
-      type: z8.string(),
-      label: z8.string(),
-      color: z8.string(),
-      expires_at: z8.string().nullable().optional()
+  bestFor: z11.array(z11.string()),
+  badges: z11.array(
+    z11.object({
+      type: z11.string(),
+      label: z11.string(),
+      color: z11.string(),
+      expires_at: z11.string().nullable().optional()
     }).strict()
   ),
-  isFeatured: z8.boolean(),
-  isDefault: z8.boolean(),
-  docsUrl: z8.string().nullable(),
-  llmContext: z8.string().nullable(),
-  constraints: z8.record(z8.string(), z8.unknown()).nullable(),
-  modelFamily: z8.string().nullable(),
-  isFamilyPrimary: z8.boolean().nullable()
+  isFeatured: z11.boolean(),
+  isDefault: z11.boolean(),
+  docsUrl: z11.string().nullable(),
+  llmContext: z11.string().nullable(),
+  constraints: z11.record(z11.string(), z11.unknown()).nullable(),
+  modelFamily: z11.string().nullable(),
+  isFamilyPrimary: z11.boolean().nullable()
 }).strict();
-var ModelsListResponseSchema = z8.object({
-  models: z8.array(ModelSummarySchema)
+var ModelsListResponseSchema = z11.object({
+  models: z11.array(ModelSummarySchema)
 }).strict();
 
 // src/commands/models/internal.ts
@@ -2647,23 +2730,23 @@ async function listModels(opts) {
 }
 
 // src/schemas/node-types.ts
-import { z as z9 } from "zod";
-var NodeTypeSummarySchema = z9.object({
-  type: z9.string(),
-  portCount: z9.number()
+import { z as z12 } from "zod";
+var NodeTypeSummarySchema = z12.object({
+  type: z12.string(),
+  portCount: z12.number()
 }).strict();
-var NodeTypePortSchema = z9.object({
-  handleId: z9.string(),
-  direction: z9.enum(["input", "output"]),
-  dataType: z9.string()
+var NodeTypePortSchema = z12.object({
+  handleId: z12.string(),
+  direction: z12.enum(["input", "output"]),
+  dataType: z12.string()
 }).strict();
-var NodeTypeDetailSchema = z9.object({
-  type: z9.string(),
-  ports: z9.array(NodeTypePortSchema),
-  agentWritableFields: z9.array(z9.string())
+var NodeTypeDetailSchema = z12.object({
+  type: z12.string(),
+  ports: z12.array(NodeTypePortSchema),
+  agentWritableFields: z12.array(z12.string())
 }).strict();
-var NodeTypesListResponseSchema = z9.object({
-  nodeTypes: z9.array(NodeTypeSummarySchema)
+var NodeTypesListResponseSchema = z12.object({
+  nodeTypes: z12.array(NodeTypeSummarySchema)
 }).strict();
 
 // src/commands/nodes/internal.ts
@@ -2705,28 +2788,7 @@ async function listNodes(opts) {
 }
 
 // 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 = 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 = z10.object({
-  items: z10.array(ProductSummarySchema),
-  nextCursor: z10.string().nullable()
-});
+import "zod";
 var DEFAULT_LIMIT = 50;
 async function listProducts(options) {
   const config = await loadConfig({
@@ -2856,33 +2918,33 @@ async function buildTemplateClient(opts) {
 }
 
 // src/schemas/templates.ts
-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()
+import { z as z14 } from "zod";
+var DeclaredParamSchema = z14.object({
+  name: z14.string(),
+  type: z14.string(),
+  required: z14.boolean(),
+  defaultValue: z14.string().nullable().optional(),
+  enumValues: z14.array(z14.string()).nullable().optional(),
+  description: z14.string().nullable().optional()
 }).strict();
-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()
+var TemplateSummarySchema = z14.object({
+  id: z14.string().uuid(),
+  source: z14.enum(["own", "system"]),
+  name: z14.string(),
+  description: z14.string().nullable(),
+  category: z14.string().nullable(),
+  thumbnailUrl: z14.string().nullable(),
+  tags: z14.array(z14.string()),
+  createdAt: z14.string()
 }).strict();
 var TemplateDetailSchema = TemplateSummarySchema.extend({
-  declaredParams: z11.array(DeclaredParamSchema),
-  timesUsed: z11.number()
+  declaredParams: z14.array(DeclaredParamSchema),
+  timesUsed: z14.number()
 }).strict();
-var TemplatesListResponseSchema = z11.object({
-  templates: z11.array(TemplateSummarySchema),
-  cursor: z11.string().nullable(),
-  hasMore: z11.boolean()
+var TemplatesListResponseSchema = z14.object({
+  templates: z14.array(TemplateSummarySchema),
+  cursor: z14.string().nullable(),
+  hasMore: z14.boolean()
 }).strict();
 
 // src/commands/template/list.ts
@@ -2932,20 +2994,7 @@ async function getTemplate(opts) {
 }
 
 // src/commands/tokens/list.ts
-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 = z12.array(TokenRowSchema);
+import "zod";
 async function listTokens(options) {
   const config = await loadConfig({
     flagProfile: options.profile,
@@ -2971,51 +3020,51 @@ async function listTokens(options) {
 }
 
 // src/schemas/workflows.ts
-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()
+import { z as z16 } from "zod";
+var WorkflowDeclaredParamSchema = z16.object({
+  name: z16.string(),
+  type: z16.string(),
+  required: z16.boolean().optional(),
+  defaultValue: z16.unknown().optional(),
+  description: z16.unknown().optional()
 }).passthrough();
-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()
+var WorkflowSummarySchema = z16.object({
+  id: z16.string().uuid(),
+  name: z16.string(),
+  tags: z16.array(z16.string()),
+  declared_params: z16.array(WorkflowDeclaredParamSchema).nullable().default([]),
+  canvas_rev: z16.number().int().nonnegative(),
+  updated_at: z16.string()
 }).strict();
-var WorkflowsListResponseSchema = z13.object({
-  items: z13.array(WorkflowSummarySchema),
-  nextCursor: z13.string().nullable()
+var WorkflowsListResponseSchema = z16.object({
+  items: z16.array(WorkflowSummarySchema),
+  nextCursor: z16.string().nullable()
 }).strict();
-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()
+var WorkflowDetailSchema = z16.object({
+  id: z16.string().uuid(),
+  name: z16.string(),
+  description: z16.string().nullable(),
+  tags: z16.array(z16.string()),
+  declared_params: z16.array(WorkflowDeclaredParamSchema).nullable().default([]),
+  canvas_rev: z16.number().int().nonnegative(),
+  nodes: z16.array(z16.unknown()),
+  edges: z16.array(z16.unknown()),
+  created_at: z16.string(),
+  updated_at: z16.string()
 }).strict();
-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()
+var WorkflowCreateResponseSchema = z16.object({
+  id: z16.string().uuid(),
+  name: z16.string(),
+  description: z16.string().nullable(),
+  tags: z16.array(z16.string()),
+  declared_params: z16.array(WorkflowDeclaredParamSchema).nullable().default([]),
+  canvas_rev: z16.number().int().nonnegative(),
+  created_at: z16.string(),
+  updated_at: z16.string()
 }).strict();
-var WorkflowMutateResponseSchema = z13.object({
-  canvas_rev: z13.number().int().nonnegative(),
-  applied: z13.number().int().nonnegative(),
+var WorkflowMutateResponseSchema = z16.object({
+  canvas_rev: z16.number().int().nonnegative(),
+  applied: z16.number().int().nonnegative(),
   workflow: WorkflowDetailSchema
 }).strict();