gipity 1.0.379 → 1.0.380

package/dist/progress.js

@@ -19,11 +19,26 @@ class TerminalProgress {
     /** True while an in-place transfer line is on screen and not yet committed. */
     liveOpen = false;
     lastRenderAt = 0;
+    /** The label of the current transfer session; a change starts a fresh one. */
+    barLabel = null;
+    /** True once the current session hit 100% - late/overshoot ticks are dropped. */
+    barSettled = false;
     phase(message) {
         this.commitLive();
         process.stdout.write(`  ${muted(message)}\n`);
     }
     transfer(label, doneBytes, totalBytes) {
+        // A new label begins a fresh transfer session (e.g. downloads → uploads on
+        // the same reporter). Within a session, once we've drawn the 100% frame we
+        // drop any further ticks - download byte totals are estimated, so the wire
+        // can deliver a hair more or fewer bytes than expected and we don't want a
+        // late chunk reopening a second "100%" line.
+        if (label !== this.barLabel) {
+            this.barLabel = label;
+            this.barSettled = false;
+        }
+        if (this.barSettled)
+            return;
         const finished = totalBytes > 0 && doneBytes >= totalBytes;
         // Throttle mid-flight redraws; always paint the first and final frames.
         const now = Date.now();
@@ -32,8 +47,10 @@ class TerminalProgress {
         this.lastRenderAt = now;
         this.liveOpen = true;
         process.stdout.write('\r' + this.frame(label, doneBytes, totalBytes) + CLEAR_TO_EOL);
-        if (finished)
+        if (finished) {
             this.commitLive();
+            this.barSettled = true;
+        }
     }
     finish() {
         this.commitLive();

package/dist/sync.js

@@ -195,14 +195,14 @@ async function fetchRemote(projectGuid) {
     }
     return out;
 }
-async function downloadAll(projectGuid) {
+async function downloadAll(projectGuid, onBytes) {
     const stream = await downloadStream(`/projects/${projectGuid}/files/tree?content=tar`);
     const extract = tar.extract();
     const files = new Map();
     return new Promise((resolve, reject) => {
         extract.on('entry', (header, entryStream, next) => {
             const chunks = [];
-            entryStream.on('data', (c) => chunks.push(c));
+            entryStream.on('data', (c) => { chunks.push(c); onBytes?.(c.length); });
             entryStream.on('end', () => { files.set(header.name, Buffer.concat(chunks)); next(); });
             entryStream.resume();
         });
@@ -519,9 +519,23 @@ async function syncInner(projectGuid, root, ignore, opts, interactive) {
     const downloadedBytes = new Map();
     const needsBulkDownload = plannedToApply.some(a => a.kind === 'download' || a.kind === 'conflict');
     if (needsBulkDownload) {
-        p?.phase('Downloading updates from Gipity…');
+        // The tree endpoint streams the *whole* remote tree as one tar (the caller
+        // then picks out only the paths it planned to apply), so the bytes that
+        // actually move = the sum of every remote file's size. That's the honest
+        // denominator for the bar - it tracks real wire progress, not just the
+        // handful of changed files.
+        const downloadLabel = 'Downloading updates from Gipity';
+        const totalDownloadBytes = [...remote.values()].reduce((sum, r) => sum + r.size, 0);
+        let recvBytes = 0;
+        p?.transfer(downloadLabel, 0, totalDownloadBytes);
+        const onBytes = p
+            ? (delta) => {
+                recvBytes = Math.min(recvBytes + delta, totalDownloadBytes);
+                p.transfer(downloadLabel, recvBytes, totalDownloadBytes);
+            }
+            : undefined;
         try {
-            const all = await downloadAll(config.projectGuid);
+            const all = await downloadAll(config.projectGuid, onBytes);
             for (const a of plannedToApply) {
                 if (a.kind === 'download' || a.kind === 'conflict') {
                     const buf = all.get(a.path);
@@ -533,6 +547,11 @@ async function syncInner(projectGuid, root, ignore, opts, interactive) {
         catch (err) {
             errors.push(`Download batch failed: ${err.message}`);
         }
+        finally {
+            // Settle the bar even if the extracted-byte tally fell short of the
+            // estimate (the live line stays open until something hits 100% or finish()).
+            p?.finish();
+        }
     }
     // ── Writes pass: uploads, downloads, conflicts (rename + download + upload copy) ──
     // We serialize conflicts; uploads run with bounded concurrency.

package/dist/template-vars.js

@@ -68,7 +68,10 @@ export function buildTemplateVars(v) {
         '{{DESCRIPTION_META}}': v.description ? `\n  <meta name="description" content="${safeDesc}">` : '',
         '{{OG_DESCRIPTION}}': v.description ? `\n  <meta property="og:description" content="${safeDesc}">` : '',
         '{{JSON_LD_BLOCK}}': `<script type="application/ld+json">\n${jsonLd}\n  </script>`,
-        '{{ANALYTICS_SCRIPT}}': `<script defer src="https://media.gipity.ai/client/v1/gipity.js" data-app="${v.projectGuid}"></script>`,
+        // `crossorigin="anonymous"` so SDK errors surface with a real message/stack
+        // (CORS mode) instead of a sanitized message-less "Script error". The CDN
+        // returns Access-Control-Allow-Origin:*, so it works on any app domain.
+        '{{ANALYTICS_SCRIPT}}': `<script defer crossorigin="anonymous" src="https://media.gipity.ai/client/v1/gipity.js" data-app="${v.projectGuid}"></script>`,
     };
 }
 /** Pure string substitution — exported so the test can exercise it without

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gipity",
-  "version": "1.0.379",
+  "version": "1.0.380",
   "description": "The full-stack platform tuned for AI agents. Database, storage, auth, functions, deploy, and drop-in kits - all agent-tuned. Pair with Claude Code or use standalone.",
   "bin": {
     "gipity": "dist/updater/shim.js",