@clickraft/cli 0.8.5 → 0.8.7

package/dist/index.js

@@ -14,6 +14,8 @@ import { request as undiciRequest } from "undici";
 import { z as z6 } from "zod";
 import { createHash, randomUUID } from "crypto";
 import { z as z5 } from "zod";
+import { createHash as createHash2 } from "crypto";
+import { request as undiciRequest2 } from "undici";
 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) {
@@ -636,6 +638,181 @@ function errorMessage(err) {
   if (err instanceof Error) return err.message;
   return String(err);
 }
+async function applyWorkflowWithRetry(params) {
+  try {
+    return await patch(params);
+  } catch (err) {
+    if (!(err instanceof ApiError)) throw err;
+    const isRevConflict = err.code === "CANVAS_REV_MISMATCH" || err.meta.status === 409 && err.meta.details != null;
+    if (!isRevConflict || !params.autoRev) throw err;
+    const snapshot = await params.client.request({
+      method: "GET",
+      path: `/workflows/${encodeURIComponent(params.id)}`,
+      responseSchema: params.schemas.detail,
+      signal: params.signal
+    });
+    const retryResult = await patch({
+      ...params,
+      canvasRev: snapshot.canvas_rev,
+      // Fresh key — the body changed (different canvas_rev), so reusing the
+      // caller's key would trigger IDEMPOTENCY_KEY_CONFLICT.
+      idempotencyKey: void 0
+    });
+    return { ...retryResult, retriedWithRev: snapshot.canvas_rev };
+  }
+}
+async function patch(params) {
+  const data = await params.client.request({
+    method: "PATCH",
+    path: `/workflows/${encodeURIComponent(params.id)}`,
+    body: {
+      canvas_rev: params.canvasRev,
+      operations: params.operations
+    },
+    idempotencyKey: params.idempotencyKey,
+    responseSchema: params.schemas.mutate,
+    signal: params.signal
+  });
+  return {
+    canvasRev: data.canvas_rev,
+    applied: data.applied,
+    workflow: data.workflow
+  };
+}
+async function uploadAsset(params) {
+  const contentType = detectContentType(params.filename, params.content);
+  const sha = sha256Hex(params.content);
+  const contentHash = `sha256:${sha}`;
+  const idempotencyKey = generateUploadIdempotencyKey(params.content, params.scope);
+  const response = await params.client.request({
+    method: "POST",
+    path: "/assets",
+    body: {
+      filename: params.filename,
+      contentType,
+      sizeBytes: params.content.length,
+      contentHash
+    },
+    idempotencyKey,
+    responseSchema: params.schema,
+    signal: params.signal
+  });
+  if (!response.deduplicated) {
+    const first = await tryPut({
+      uploadUrl: response.uploadUrl,
+      content: params.content,
+      contentType,
+      signal: params.signal,
+      dispatcher: params.putDispatcher
+    });
+    if (!first.ok) {
+      if (first.kind === "fatal") {
+        throw new ApiError(
+          "STORAGE_UPLOAD_FAILED",
+          `Upload to signed URL failed for ${params.filename} (HTTP ${first.status ?? "unknown"}).`,
+          { retryable: false }
+        );
+      }
+      const retry = await tryPut({
+        uploadUrl: response.uploadUrl,
+        content: params.content,
+        contentType,
+        signal: params.signal,
+        dispatcher: params.putDispatcher
+      });
+      if (!retry.ok) {
+        throw new ApiError(
+          "STORAGE_UPLOAD_FAILED",
+          `Upload to signed URL failed for ${params.filename} after one retry.`,
+          { retryable: true }
+        );
+      }
+    }
+  }
+  return {
+    assetId: response.assetId,
+    publicUrl: response.publicUrl,
+    deduplicated: response.deduplicated,
+    bytes: params.content.length,
+    contentHash
+  };
+}
+async function tryPut(args) {
+  try {
+    const response = await undiciRequest2(args.uploadUrl, {
+      method: "PUT",
+      body: args.content,
+      headers: {
+        "content-type": args.contentType,
+        "content-length": String(args.content.length)
+      },
+      signal: args.signal,
+      dispatcher: args.dispatcher
+    });
+    await response.body.text();
+    const status = response.statusCode;
+    if (status >= 200 && status < 300) return { ok: true };
+    if (status >= 400 && status < 500) return { ok: false, kind: "fatal", status };
+    return { ok: false, kind: "retryable", status };
+  } catch {
+    return { ok: false, kind: "retryable" };
+  }
+}
+function sha256Hex(content) {
+  return createHash2("sha256").update(content).digest("hex");
+}
+var MAGIC_NUMBERS = [
+  { contentType: "image/png", prefix: [137, 80, 78, 71, 13, 10, 26, 10] },
+  { contentType: "image/jpeg", prefix: [255, 216, 255] },
+  { contentType: "image/webp", prefix: [82, 73, 70, 70] }
+  // also matches WAV — disambiguated below
+];
+var EXTENSION_FALLBACK = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  mp4: "video/mp4",
+  mov: "video/quicktime",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  pdf: "application/pdf",
+  txt: "text/plain",
+  json: "application/json"
+};
+function detectContentType(filename, content) {
+  if (content.length >= 6) {
+    const head = content.subarray(0, 6).toString("ascii");
+    if (head === "GIF87a" || head === "GIF89a") return "image/gif";
+  }
+  if (content.length >= 12 && content.subarray(4, 8).toString("ascii") === "ftyp") {
+    return "video/mp4";
+  }
+  for (const { contentType, prefix } of MAGIC_NUMBERS) {
+    if (matchesPrefix(content, prefix)) {
+      if (contentType === "image/webp") {
+        const formatId = content.subarray(8, 12).toString("ascii");
+        if (formatId === "WEBP") return "image/webp";
+        if (formatId === "WAVE") return "audio/wav";
+        break;
+      }
+      return contentType;
+    }
+  }
+  const ext = filename.toLowerCase().split(".").pop();
+  if (ext && EXTENSION_FALLBACK[ext]) {
+    return EXTENSION_FALLBACK[ext];
+  }
+  return "application/octet-stream";
+}
+function matchesPrefix(content, prefix) {
+  if (content.length < prefix.length) return false;
+  for (let i = 0; i < prefix.length; i++) {
+    if (content[i] !== prefix[i]) return false;
+  }
+  return true;
+}
 
 // src/errors/codes.ts
 var LOGIN_HINT = "Run `clickraft login` to authenticate.";
@@ -1594,10 +1771,9 @@ var GenerationResultSchema = z9.object({
 }).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";
+import "undici";
 
 // src/schemas/assets.ts
 import { z as z10 } from "zod";
@@ -1622,60 +1798,16 @@ async function uploadFile(opts) {
   const size = await safeStatSize(opts.filePath);
   validateSize(size);
   const content = await safeReadFile(opts.filePath);
-  const contentType = detectContentType(opts.filePath, content);
-  const sha = sha256Hex(content);
-  const contentHash = `sha256:${sha}`;
-  const filename = basename(opts.filePath);
-  const idempotencyKey = generateUploadIdempotencyKey(content, scope);
   const client = opts.client ?? await buildClient(opts);
-  const response = await postAssetMetadata({
+  return uploadAsset({
     client,
-    filename,
-    contentType,
-    sizeBytes: content.length,
-    contentHash,
-    idempotencyKey,
-    signal: opts.signal
+    content,
+    filename: basename(opts.filePath),
+    scope,
+    signal: opts.signal,
+    putDispatcher: opts.putDispatcher,
+    schema: UploadResponseSchema
   });
-  if (!response.deduplicated) {
-    const first = await tryPut({
-      uploadUrl: response.uploadUrl,
-      content,
-      contentType,
-      signal: opts.signal,
-      dispatcher: opts.putDispatcher
-    });
-    if (!first.ok) {
-      if (first.kind === "fatal") {
-        throw new ApiError(
-          "STORAGE_UPLOAD_FAILED",
-          `Upload to signed URL failed for ${filename} (HTTP ${first.status ?? "unknown"}).`,
-          { retryable: false }
-        );
-      }
-      const retry = await tryPut({
-        uploadUrl: response.uploadUrl,
-        content,
-        contentType,
-        signal: opts.signal,
-        dispatcher: opts.putDispatcher
-      });
-      if (!retry.ok) {
-        throw new ApiError(
-          "STORAGE_UPLOAD_FAILED",
-          `Upload to signed URL failed for ${filename} after one retry.`,
-          { retryable: true }
-        );
-      }
-    }
-  }
-  return {
-    assetId: response.assetId,
-    publicUrl: response.publicUrl,
-    deduplicated: response.deduplicated,
-    bytes: content.length,
-    contentHash
-  };
 }
 async function buildClient(opts) {
   const cfg = await loadConfig({
@@ -1690,42 +1822,6 @@ async function buildClient(opts) {
     cloudflareAccess: cfg.cloudflareAccess
   });
 }
-async function postAssetMetadata(args) {
-  return args.client.request({
-    method: "POST",
-    path: "/assets",
-    body: {
-      filename: args.filename,
-      contentType: args.contentType,
-      sizeBytes: args.sizeBytes,
-      contentHash: args.contentHash
-    },
-    idempotencyKey: args.idempotencyKey,
-    responseSchema: UploadResponseSchema,
-    signal: args.signal
-  });
-}
-async function tryPut(args) {
-  try {
-    const response = await undiciRequest2(args.uploadUrl, {
-      method: "PUT",
-      body: args.content,
-      headers: {
-        "content-type": args.contentType,
-        "content-length": String(args.content.length)
-      },
-      signal: args.signal,
-      dispatcher: args.dispatcher
-    });
-    await response.body.text();
-    const status = response.statusCode;
-    if (status >= 200 && status < 300) return { ok: true };
-    if (status >= 400 && status < 500) return { ok: false, kind: "fatal", status };
-    return { ok: false, kind: "retryable", status };
-  } catch {
-    return { ok: false, kind: "retryable" };
-  }
-}
 async function safeStatSize(filePath) {
   let stats;
   try {
@@ -1787,61 +1883,6 @@ function validateSize(bytes) {
     );
   }
 }
-function sha256Hex(content) {
-  return createHash2("sha256").update(content).digest("hex");
-}
-var MAGIC_NUMBERS = [
-  { contentType: "image/png", prefix: [137, 80, 78, 71, 13, 10, 26, 10] },
-  { contentType: "image/jpeg", prefix: [255, 216, 255] },
-  { contentType: "image/webp", prefix: [82, 73, 70, 70] }
-  // also matches WAV — disambiguated below
-];
-var EXTENSION_FALLBACK = {
-  png: "image/png",
-  jpg: "image/jpeg",
-  jpeg: "image/jpeg",
-  gif: "image/gif",
-  webp: "image/webp",
-  mp4: "video/mp4",
-  mov: "video/quicktime",
-  mp3: "audio/mpeg",
-  wav: "audio/wav",
-  pdf: "application/pdf",
-  txt: "text/plain",
-  json: "application/json"
-};
-function detectContentType(filePath, content) {
-  if (content.length >= 6) {
-    const head = content.subarray(0, 6).toString("ascii");
-    if (head === "GIF87a" || head === "GIF89a") return "image/gif";
-  }
-  if (content.length >= 12 && content.subarray(4, 8).toString("ascii") === "ftyp") {
-    return "video/mp4";
-  }
-  for (const { contentType, prefix } of MAGIC_NUMBERS) {
-    if (matchesPrefix(content, prefix)) {
-      if (contentType === "image/webp") {
-        const formatId = content.subarray(8, 12).toString("ascii");
-        if (formatId === "WEBP") return "image/webp";
-        if (formatId === "WAVE") return "audio/wav";
-        break;
-      }
-      return contentType;
-    }
-  }
-  const ext = filePath.toLowerCase().split(".").pop();
-  if (ext && EXTENSION_FALLBACK[ext]) {
-    return EXTENSION_FALLBACK[ext];
-  }
-  return "application/octet-stream";
-}
-function matchesPrefix(content, prefix) {
-  if (content.length < prefix.length) return false;
-  for (let i = 0; i < prefix.length; i++) {
-    if (content[i] !== prefix[i]) return false;
-  }
-  return true;
-}
 
 // src/commands/generate/internal.ts
 async function buildGenerateClient(opts) {
@@ -3087,54 +3128,19 @@ async function buildWorkflowClient(opts) {
   });
 }
 
-// src/commands/workflow/get.ts
-async function getWorkflow(opts) {
-  const client = opts.client ?? await buildWorkflowClient(opts);
-  return client.request({
-    method: "GET",
-    path: `/workflows/${encodeURIComponent(opts.id)}`,
-    responseSchema: WorkflowDetailSchema,
-    signal: opts.signal
-  });
-}
-
 // src/commands/workflow/apply.ts
 async function applyWorkflow(opts) {
   const client = opts.client ?? await buildWorkflowClient(opts);
-  try {
-    return await patchWorkflow(client, opts);
-  } catch (err) {
-    if (!(err instanceof ApiError)) throw err;
-    const isRevConflict = err.code === "CANVAS_REV_MISMATCH" || err.meta.status === 409 && err.meta.details != null;
-    if (!isRevConflict || !opts.autoRev) throw err;
-    const snapshot = await getWorkflow({ id: opts.id, client, signal: opts.signal });
-    const retryResult = await patchWorkflow(client, {
-      ...opts,
-      canvasRev: snapshot.canvas_rev,
-      // Fresh key — the body changed (different canvas_rev), so reusing
-      // the caller's key would trigger IDEMPOTENCY_KEY_CONFLICT.
-      idempotencyKey: void 0
-    });
-    return { ...retryResult, retriedWithRev: snapshot.canvas_rev };
-  }
-}
-async function patchWorkflow(client, opts) {
-  const data = await client.request({
-    method: "PATCH",
-    path: `/workflows/${encodeURIComponent(opts.id)}`,
-    body: {
-      canvas_rev: opts.canvasRev,
-      operations: opts.operations
-    },
+  return applyWorkflowWithRetry({
+    client,
+    id: opts.id,
+    canvasRev: opts.canvasRev,
+    operations: opts.operations,
     idempotencyKey: opts.idempotencyKey,
-    responseSchema: WorkflowMutateResponseSchema,
-    signal: opts.signal
+    autoRev: opts.autoRev,
+    signal: opts.signal,
+    schemas: { mutate: WorkflowMutateResponseSchema, detail: WorkflowDetailSchema }
   });
-  return {
-    canvasRev: data.canvas_rev,
-    applied: data.applied,
-    workflow: data.workflow
-  };
 }
 
 // src/commands/workflow/create.ts
@@ -3165,6 +3171,17 @@ async function createWorkflow(opts) {
   });
 }
 
+// src/commands/workflow/get.ts
+async function getWorkflow(opts) {
+  const client = opts.client ?? await buildWorkflowClient(opts);
+  return client.request({
+    method: "GET",
+    path: `/workflows/${encodeURIComponent(opts.id)}`,
+    responseSchema: WorkflowDetailSchema,
+    signal: opts.signal
+  });
+}
+
 // src/commands/workflow/list.ts
 async function listWorkflows(opts) {
   const client = opts.client ?? await buildWorkflowClient(opts);