foss-design 0.3.1 → 0.3.2

package/README.md

@@ -37,7 +37,7 @@ Or install the `design` command globally: `npm i -g foss-design`.
 | `build [canvas…] [--out] [--tar]` | Static site. |
 | `login`, `logout` | Sign this machine in to foss-design Cloud (a link with the code in it). |
 | `link [<project>] [--new <name>]` | List cloud projects, or link `.design` to one. |
-| `push [canvas…] [--resolved <unit>]`, `pull [canvas…] [--theirs <unit>]` | Sync with the cloud; exit 2 on a conflict. |
+| `push [canvas…] [--resolved <unit>]`, `pull [canvas…] [--theirs <unit>]` | Sync with the cloud, with progress; push prints the web link of each pushed canvas; exit 2 on a conflict. |
 
 Requirements: Node.js 20.19+. `check --render` and `shot` need an installed Chrome, Chromium, Edge or Brave, or `DESIGN_CHROME` pointing at one.
 

package/dist/cli.js

@@ -1440,10 +1440,10 @@ function optsOutOfSystem(html) {
 }
 function injectIntoHtml(html, head) {
   const tags = headTags(head);
-  const open = /<head(\s[^>]*)?>/i.exec(html);
-  if (open) return `${html.slice(0, open.index + open[0].length)}
+  const open2 = /<head(\s[^>]*)?>/i.exec(html);
+  if (open2) return `${html.slice(0, open2.index + open2[0].length)}
 ${tags}
-${html.slice(open.index + open[0].length)}`;
+${html.slice(open2.index + open2[0].length)}`;
   const htmlOpen = /<html(\s[^>]*)?>/i.exec(html);
   if (htmlOpen)
     return html.slice(0, htmlOpen.index + htmlOpen[0].length) + `
@@ -1806,14 +1806,55 @@ for (const stream of [process.stdout, process.stderr]) {
     throw error;
   });
 }
+var live = process.stdout.isTTY === true;
+var open = false;
+function endLine() {
+  if (!open) return;
+  process.stdout.write("\n");
+  open = false;
+}
 function print(line = "") {
+  endLine();
   process.stdout.write(`${line}
 `);
 }
 function warn(line) {
+  endLine();
   process.stderr.write(`${yellow("warning")} ${line}
 `);
 }
+var silentProgress = { update() {
+}, done() {
+} };
+function progress() {
+  let last = 0;
+  let latest = "";
+  const show = (line) => {
+    if (live) {
+      process.stdout.write(`\r\x1B[2K${dim(line)}`);
+      open = true;
+    } else process.stdout.write(`${dim(line)}
+`);
+  };
+  return {
+    update(line) {
+      latest = line;
+      const now = Date.now();
+      if (now - last < (live ? 100 : 5e3)) return;
+      last = now;
+      show(line);
+    },
+    done(line = latest) {
+      if (!line) return;
+      if (live) {
+        process.stdout.write(`\r\x1B[2K${dim(line)}
+`);
+        open = false;
+      } else process.stdout.write(`${dim(line)}
+`);
+    }
+  };
+}
 
 // src/cli/commands/build.ts
 function pack(out) {
@@ -2505,8 +2546,8 @@ function printUrls(paths, url) {
 async function waitForServer(paths, timeoutMs) {
   const until = Date.now() + timeoutMs;
   while (Date.now() < until) {
-    const live = await liveServer(paths);
-    if (live) return live;
+    const live2 = await liveServer(paths);
+    if (live2) return live2;
     await new Promise((resolve) => setTimeout(resolve, 150));
   }
   return null;
@@ -2533,12 +2574,12 @@ async function stopServer(paths) {
   return true;
 }
 async function ensureServer(paths, options) {
-  const live = await liveServer(paths);
-  const stale = live && live.version !== packageVersion();
-  if (live && !options.restart && !stale) return live;
+  const live2 = await liveServer(paths);
+  const stale = live2 && live2.version !== packageVersion();
+  if (live2 && !options.restart && !stale) return live2;
   if (stale)
-    print(dim(`Restarting the preview server: it runs foss-design ${live.version}, this is ${packageVersion()}.`));
-  if (live) await stopServer(paths);
+    print(dim(`Restarting the preview server: it runs foss-design ${live2.version}, this is ${packageVersion()}.`));
+  if (live2) await stopServer(paths);
   fs16.mkdirSync(paths.cache, { recursive: true });
   const log = fs16.openSync(logFile(paths), "w");
   const args = [PKG.cli, "preview", "--foreground", "--root", paths.root];
@@ -2866,6 +2907,7 @@ function errorFor(host, status, body, retryAfter) {
   if (status === 401)
     return new CloudError(`Not signed in to ${host}, or the token was revoked. Run \`design login\`.`, status, code);
   let message = text(data.message) ?? DEFAULT_MESSAGE[status] ?? `${host} answered ${status}`;
+  if (status === 413 && !str(data.error)) message = `A proxy in front of ${host} refused it as too large (HTTP 413)`;
   if (code === "account_banned") message = `Your account is banned: ${message}`;
   if (limit) message += ` (limit: ${limit})`;
   if (status === 429 && retryAfter) message += `; retry in ${retryAfter}s`;
@@ -3222,13 +3264,26 @@ function allUnitKeys(link, local, remote) {
 }
 
 // src/cloud/sync.ts
-function openSync(paths, log) {
+function openSync(paths, log, progress2 = () => silentProgress) {
   const link = requireLink(paths);
   const credential = requireCredential(link.host);
-  return { paths, link, client: new CloudClient(link.host, credential.token), log };
+  return { paths, link, client: new CloudClient(link.host, credential.token), log, progress: progress2 };
+}
+var TRANSFERS = 8;
+var megabytes = (bytes) => `${(bytes / 1024 / 1024).toFixed(bytes < 10 * 1024 * 1024 ? 1 : 0)} MB`;
+function rate(bytes, started) {
+  const elapsed = (Date.now() - started) / 1e3;
+  return elapsed < 1 ? "" : ` \xB7 ${(bytes / 1024 / 1024 / elapsed).toFixed(1)} MB/s`;
+}
+var seconds = (started) => `${((Date.now() - started) / 1e3).toFixed(1)}s`;
+function webUrl(link, unit) {
+  const base = `${link.host.replace(/\/+$/, "")}/p/${encodeURIComponent(link.project)}`;
+  if (!unit) return base;
+  if (unit === SYSTEM_UNIT) return `${base}/system`;
+  return `${base}/c/${encodeURIComponent(unit.slice("canvas/".length))}`;
 }
 function newReport(command, link) {
-  return { ok: true, command, host: link.host, project: link.project, units: [], hints: [] };
+  return { ok: true, command, host: link.host, project: link.project, url: webUrl(link), units: [], hints: [] };
 }
 function unitArg(value) {
   if (value === SYSTEM_UNIT || value === "@system") return SYSTEM_UNIT;
@@ -3953,7 +4008,7 @@ function applyUnit(paths, key, local, target, blobs) {
   return counts;
 }
 async function pull(ctx, options) {
-  const { paths, client, log } = ctx;
+  const { paths, client } = ctx;
   const link = structuredClone(ctx.link);
   const report = newReport("pull", link);
   const selected = unique(options.units.map(unitArg));
@@ -4056,10 +4111,20 @@ async function pull(ctx, options) {
     else download.push(hash);
   }
   if (download.length) {
-    log(`Downloading ${plural2(download.length, "file")}\u2026`);
-    await mapLimit(download, 4, async (hash) => {
-      blobs.set(hash, await client.getBlob(link.project, hash));
+    const bar = ctx.progress();
+    const started = Date.now();
+    let gotFiles = 0;
+    let gotBytes = 0;
+    const line = () => `Downloading ${gotFiles}/${download.length} files \xB7 ${megabytes(gotBytes)}${rate(gotBytes, started)}`;
+    bar.update(line());
+    await mapLimit(download, TRANSFERS, async (hash) => {
+      const data = await client.getBlob(link.project, hash);
+      blobs.set(hash, data);
+      gotFiles++;
+      gotBytes += data.length;
+      bar.update(line());
     });
+    bar.done(`Downloaded ${plural2(download.length, "file")} (${megabytes(gotBytes)}) in ${seconds(started)}`);
   }
   for (const plan of plans) {
     const { key, report: entry } = plan;
@@ -4095,7 +4160,6 @@ async function pull(ctx, options) {
 // src/cloud/push.ts
 import fs24 from "fs";
 import path24 from "path";
-var megabytes = (bytes) => `${(bytes / 1024 / 1024).toFixed(bytes < 10 * 1024 * 1024 ? 1 : 0)} MB`;
 function blockedReport(status, message) {
   return {
     unit: status.key,
@@ -4234,7 +4298,7 @@ async function push(ctx, options) {
   const pushing = toPush.filter((key) => {
     const s = status(key);
     if (systemPush || resolved.includes(key) || s.changed.length || !remote.has(key)) return true;
-    report.units.push({ unit: key, action: "unchanged", rev: s.baseRev });
+    report.units.push({ unit: key, action: "unchanged", rev: s.baseRev, url: webUrl(link, key) });
     return false;
   });
   if (!pushing.length) return report;
@@ -4277,17 +4341,40 @@ async function push(ctx, options) {
     const unknown = missing.find((hash) => !files.has(hash));
     if (unknown) throw new CliError(`The cloud asked for ${unknown.slice(0, 12)}, which is not part of this push`);
     const bytes = missing.reduce((sum, hash) => sum + fs24.statSync(files.get(hash)).size, 0);
-    log(`Uploading ${plural2(missing.length, "file")} (${megabytes(bytes)})\u2026`);
-    await mapLimit(missing, 4, async (hash) => {
-      await client.putBlob(link.project, hash, fs24.readFileSync(files.get(hash)));
+    const bar = ctx.progress();
+    const started = Date.now();
+    let sentFiles = 0;
+    let sentBytes = 0;
+    const line = () => `Uploading ${sentFiles}/${missing.length} files \xB7 ${megabytes(sentBytes)} of ${megabytes(bytes)}${rate(sentBytes, started)}`;
+    bar.update(line());
+    await mapLimit(missing, TRANSFERS, async (hash) => {
+      const file = files.get(hash);
+      const data = fs24.readFileSync(file);
+      try {
+        await client.putBlob(link.project, hash, data);
+      } catch (error) {
+        if (error instanceof CloudError && error.status === 413)
+          throw new CliError(`${path24.relative(process.cwd(), file)} (${megabytes(data.length)}): ${error.message}`);
+        throw error;
+      }
+      sentFiles++;
+      sentBytes += data.length;
+      bar.update(line());
     });
+    bar.done(`Uploaded ${plural2(missing.length, "file")} (${megabytes(bytes)}) in ${seconds(started)}`);
   }
   log(`Pushing ${plural2(units.length, "unit")}\u2026`);
   const revs2 = await client.push(link.project, units);
   for (const unit of units) {
     const rev = revs2.get(unit.key) ?? unit.baseRev + 1;
     link.units[unit.key] = { rev, files: hashes(unit.source) };
-    report.units.push({ unit: unit.key, action: unit.baseRev ? "pushed" : "created", rev, baseRev: unit.baseRev });
+    report.units.push({
+      unit: unit.key,
+      action: unit.baseRev ? "pushed" : "created",
+      rev,
+      baseRev: unit.baseRev,
+      url: webUrl(link, unit.key)
+    });
   }
   for (const key of resolved) fs24.rmSync(incomingDir(paths, key), { recursive: true, force: true });
   writeLink(paths, link);
@@ -4312,8 +4399,8 @@ function printReport(report) {
   const shown = report.units.filter((entry) => !QUIET.has(entry.action));
   const quiet = report.units.length - shown.length;
   const moved = report.units.some((entry) => GOOD.has(entry.action));
-  if (report.ok && !moved) print(`${bold(`Nothing to ${report.command}`)} ${dim(`${report.project} \xB7 ${report.host}`)}`);
-  else if (report.ok) print(`${bold(verb)} ${report.project} ${dim(report.host)}`);
+  if (report.ok && !moved) print(`${bold(`Nothing to ${report.command}`)} ${dim(report.url)}`);
+  else if (report.ok) print(`${bold(verb)} ${report.url}`);
   else print(`${bold(report.command === "push" ? "Push stopped" : "Pull finished with conflicts")} ${dim(report.host)}`);
   const width = Math.max(0, ...shown.map((entry) => entry.unit.length));
   for (const entry of shown) {
@@ -4327,6 +4414,7 @@ function printReport(report) {
     ) : "";
     const detail2 = [entry.action.replaceAll("_", " "), revs(entry), files].filter(Boolean).join("  ");
     print(`  ${mark} ${entry.unit.padEnd(width)}  ${detail2}`);
+    if (entry.url && GOOD.has(entry.action)) print(`      ${dim("\u2192")} ${entry.url}`);
     if (entry.message) print(`      ${dim(entry.message)}`);
   }
   if (quiet) print(dim(`  ${plural2(quiet, "unit")} ${report.command === "push" ? "unchanged" : "up to date"}`));
@@ -4335,8 +4423,8 @@ function printReport(report) {
 async function runSync(paths, command, json, run) {
   let report;
   try {
-    report = await run(openSync(paths, json ? () => {
-    } : (line) => print(dim(line))));
+    report = await run(json ? openSync(paths, () => {
+    }) : openSync(paths, (line) => print(dim(line)), progress));
   } catch (error) {
     if (!json) throw error;
     let link = null;
@@ -4350,6 +4438,7 @@ async function runSync(paths, command, json, run) {
       command,
       host: link?.host ?? "",
       project: link?.project ?? "",
+      url: link ? webUrl(link) : "",
       units: [],
       hints: [],
       error: {
@@ -4416,7 +4505,8 @@ ${bold("Cloud")}  ${dim("units: system (design.json + system/) and canvas/<id>;
                                              (linking to another project replaces the link)
   push [canvas\u2026] [--json]                    Build and upload what changed here (or the named units); a
        [--resolved <unit>]                   system change pushes every active canvas with it. Stops if
-                                             the cloud is ahead; --resolved marks a merged conflict
+                                             the cloud is ahead; --resolved marks a merged conflict.
+                                             Prints the web link of every pushed canvas
   pull [canvas\u2026] [--json]                    Take cloud changes into .design; a unit changed on both sides
        [--theirs <unit>]                     goes to .design/.cache/cloud/incoming/<unit> (exit 2);
                                              --theirs takes the cloud version and drops local changes
@@ -4530,6 +4620,7 @@ async function main(argv) {
   }
 }
 main(process.argv.slice(2)).catch((error) => {
+  endLine();
   if (error instanceof CliError) {
     process.stderr.write(`${red("error")} ${error.message}
 `);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "foss-design",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "Design canvases and design systems for coding agents: live, animated, clickable screens on an infinite canvas, served locally from a .design folder.",
   "type": "module",
   "license": "MIT",