@cimplify/cli 0.2.8 → 0.3.1

package/dist/{add-7PTWJV4F.mjs → add-OUMIT4YX.mjs}

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-import { REGISTRY_INDEX, REGISTRY } from './chunk-H2HJQGFY.mjs';
-import { promptYesNo } from './chunk-L6474RPL.mjs';
-import { parseArgs, flagString, flagBool } from './chunk-4SBJVRGM.mjs';
-import { CliError, CLI_ERROR_CODE, info, bold, dim, success, result, yellow } from './chunk-NZ4RG62Z.mjs';
+import { REGISTRY_INDEX, REGISTRY } from './chunk-42PFJBC6.mjs';
+import { promptYesNo } from './chunk-RZQTHTXX.mjs';
+import { parseArgs, flagString, flagBool } from './chunk-C4M3DXKC.mjs';
+import { CliError, CLI_ERROR_CODE, info, bold, dim, success, result, yellow } from './chunk-I3XQSSOT.mjs';
 import { mkdirSync, existsSync, writeFileSync } from 'fs';
 import { resolve, join, dirname } from 'path';
 
@@ -54,21 +54,21 @@ async function writeComponent(component, options) {
   }
   return outcome;
 }
-function resolveDependencyOrder(roots) {
+function resolveOrder(roots, getDeps) {
   const visited = /* @__PURE__ */ new Set();
   const order = [];
   function visit(name) {
     if (visited.has(name)) return;
     visited.add(name);
-    const component = loadComponent(name);
-    for (const dep of component.registryDependencies) {
-      visit(dep);
-    }
+    for (const dep of getDeps(name)) visit(dep);
     order.push(name);
   }
   for (const root of roots) visit(root);
   return order;
 }
+function resolveDependencyOrder(roots) {
+  return resolveOrder(roots, (name) => loadComponent(name).registryDependencies);
+}
 async function run(argv) {
   const args = parseArgs(argv);
   const dirFlag = flagString(args, "dir");
@@ -122,4 +122,4 @@ async function run(argv) {
   });
 }
 
-export { run as default };
+export { run as default, resolveOrder };

package/dist/assets-DMK2QOPD.mjs

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+import { parseArgs, flagString, flagBool } from './chunk-C4M3DXKC.mjs';
+import { ApiClient } from './chunk-D7WMSGKK.mjs';
+import { readAuth } from './chunk-LS2VTSMQ.mjs';
+import { CliError, CLI_ERROR_CODE, step, yellow, dim, success, info, result, bold, green } from './chunk-I3XQSSOT.mjs';
+import { createHash } from 'crypto';
+import { promises } from 'fs';
+import path from 'path';
+
+var MANIFEST_FILE = "cimplify-assets.json";
+var DEFAULT_FOLDER = "assets";
+var MAX_FILE_SIZE_BYTES = 50 * 1024 * 1024;
+var CONTENT_TYPE_FALLBACK = "application/octet-stream";
+var MIME_BY_EXT = {
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".avif": "image/avif",
+  ".svg": "image/svg+xml",
+  ".pdf": "application/pdf",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".woff2": "font/woff2",
+  ".woff": "font/woff",
+  ".ttf": "font/ttf"
+};
+function endpointInit(businessId) {
+  return `/v1/businesses/${encodeURIComponent(businessId)}/assets/init`;
+}
+function endpointConfirm(businessId) {
+  return `/v1/businesses/${encodeURIComponent(businessId)}/assets/confirm`;
+}
+function manifestPath(cwd = process.cwd()) {
+  return path.join(cwd, MANIFEST_FILE);
+}
+async function readManifest(cwd = process.cwd()) {
+  try {
+    const raw = await promises.readFile(manifestPath(cwd), "utf8");
+    return JSON.parse(raw);
+  } catch (err) {
+    if (err.code === "ENOENT") return {};
+    throw err;
+  }
+}
+async function writeManifest(manifest, cwd = process.cwd()) {
+  const payload = `${JSON.stringify(manifest, null, 2)}
+`;
+  await promises.writeFile(manifestPath(cwd), payload, "utf8");
+}
+function mimeOf(filename) {
+  const ext = path.extname(filename).toLowerCase();
+  return MIME_BY_EXT[ext] ?? CONTENT_TYPE_FALLBACK;
+}
+function sha256Hex(buf) {
+  return createHash("sha256").update(buf).digest("hex");
+}
+async function walkFiles(root) {
+  const out = [];
+  async function visit(dir) {
+    const entries = await promises.readdir(dir, { withFileTypes: true });
+    for (const e of entries) {
+      const abs = path.join(dir, e.name);
+      if (e.isDirectory()) await visit(abs);
+      else if (e.isFile()) out.push(abs);
+    }
+  }
+  await visit(root);
+  return out;
+}
+async function run(argv) {
+  const args = parseArgs(argv);
+  const sub = args.positional[0];
+  if (!sub) {
+    throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, "Usage: cimplify assets <upload|ls|rm>");
+  }
+  switch (sub) {
+    case "upload":
+      return runUpload(args);
+    case "ls":
+      return runLs(args);
+    case "rm":
+      return runRm(args);
+    default:
+      throw new CliError(
+        CLI_ERROR_CODE.INVALID_INPUT,
+        `Unknown subcommand "${sub}". Use upload, ls, or rm.`
+      );
+  }
+}
+async function runUpload(args) {
+  const dir = args.positional[1];
+  if (!dir) {
+    throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, "Usage: cimplify assets upload <dir> [--folder <path>]");
+  }
+  const folder = flagString(args, "folder") ?? DEFAULT_FOLDER;
+  const force = flagBool(args, "force");
+  const root = path.resolve(process.cwd(), dir);
+  const stat = await promises.stat(root).catch(() => null);
+  if (!stat?.isDirectory()) {
+    throw new CliError(CLI_ERROR_CODE.NOT_FOUND, `Directory not found: ${root}`);
+  }
+  const auth = await readAuth();
+  const client = ApiClient.fromAuth(auth);
+  const manifest = await readManifest();
+  const files = await walkFiles(root);
+  const uploaded = [];
+  const skipped = [];
+  for (const abs of files) {
+    const rel = path.relative(root, abs).replaceAll(path.sep, "/");
+    const filename = path.basename(rel);
+    const keyForManifest = `${folder}/${rel}`;
+    const contentType = mimeOf(filename);
+    const buf = await promises.readFile(abs);
+    if (buf.byteLength > MAX_FILE_SIZE_BYTES) {
+      throw new CliError(
+        CLI_ERROR_CODE.INVALID_INPUT,
+        `${rel}: ${buf.byteLength} bytes exceeds 50 MB limit`
+      );
+    }
+    const hash = sha256Hex(buf);
+    const existing = manifest[keyForManifest];
+    if (existing && existing.sha256 === hash && !force) {
+      step(`${yellow("skip")} ${keyForManifest} ${dim("(unchanged)")}`);
+      skipped.push(keyForManifest);
+      continue;
+    }
+    const subfolder = path.posix.join(folder, path.posix.dirname(rel));
+    const init = await client.post(endpointInit(auth.businessId), {
+      folder: subfolder,
+      filename,
+      content_type: contentType,
+      size_bytes: buf.byteLength
+    });
+    step(`${dim("\u2192")}    ${keyForManifest} ${dim(`(${buf.byteLength} bytes)`)}`);
+    const putRes = await fetch(init.upload_url, {
+      method: "PUT",
+      headers: { "content-type": contentType },
+      body: buf
+    });
+    if (!putRes.ok) {
+      throw new CliError(
+        CLI_ERROR_CODE.NETWORK_ERROR,
+        `PUT to R2 failed for ${keyForManifest}: ${putRes.status} ${putRes.statusText}`
+      );
+    }
+    const confirmed = await client.post(endpointConfirm(auth.businessId), {
+      upload_id: init.upload_id
+    });
+    manifest[keyForManifest] = {
+      url: confirmed.url,
+      upload_id: init.upload_id,
+      folder: subfolder,
+      filename,
+      content_type: contentType,
+      size_bytes: buf.byteLength,
+      sha256: hash,
+      uploaded_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    uploaded.push(keyForManifest);
+  }
+  await writeManifest(manifest);
+  success(`Uploaded ${uploaded.length} file${uploaded.length === 1 ? "" : "s"} (${skipped.length} skipped)`);
+  info(dim(`Manifest: ${manifestPath()}`));
+  result({
+    uploaded_count: uploaded.length,
+    skipped_count: skipped.length,
+    manifest_path: manifestPath(),
+    uploaded,
+    skipped
+  });
+}
+async function runLs(args) {
+  const prefix = flagString(args, "prefix");
+  const manifest = await readManifest();
+  const entries = Object.entries(manifest).filter(([k]) => prefix ? k.startsWith(prefix) : true).sort(([a], [b]) => a.localeCompare(b));
+  if (entries.length === 0) {
+    info(dim("No assets uploaded yet."));
+  } else {
+    info(bold(`Assets in ${MANIFEST_FILE}:`));
+    for (const [key, entry] of entries) {
+      info(`  ${green("\u25CF")} ${key} ${dim(`\u2192 ${entry.url}`)}`);
+    }
+  }
+  result({
+    count: entries.length,
+    assets: entries.map(([key, entry]) => ({ key, ...entry }))
+  });
+}
+async function runRm(args) {
+  const key = args.positional[1];
+  if (!key) {
+    throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, "Usage: cimplify assets rm <key>");
+  }
+  const manifest = await readManifest();
+  if (!(key in manifest)) {
+    throw new CliError(CLI_ERROR_CODE.NOT_FOUND, `Key not found in manifest: ${key}`);
+  }
+  const removed = manifest[key];
+  delete manifest[key];
+  await writeManifest(manifest);
+  success(`Removed ${key} from manifest`);
+  info(dim("Note: remote blob is not deleted in v1 \u2014 only the manifest entry."));
+  result({ removed_key: key, removed_url: removed.url });
+}
+
+export { run as default, endpointConfirm, endpointInit, mimeOf, readManifest, sha256Hex, walkFiles, writeManifest };