gipity 1.0.379 → 1.0.381

package/dist/commands/add.js

@@ -8,14 +8,14 @@ import { sync } from '../sync.js';
 import { success, muted, bold } from '../colors.js';
 import { run } from '../helpers/index.js';
 const STARTERS = [
-    { key: 'web-fullstack', hint: 'backend API + database (weather-by-zip demo)' },
     { key: 'web-vision-cam', hint: 'fullscreen camera app with on-device vision (MediaPipe)' },
     { key: '2d-game', hint: '2D games with Phaser 3 - platformer, arcade, puzzle' },
     { key: '3d-world', hint: 'playable 3D multiplayer rocket-launcher demo' },
-    { key: 'api', hint: 'pure API backend, no frontend' },
 ];
 const BLANK = [
     { key: 'web-simple', hint: 'static frontend-only site - pages, dashboards, simple games' },
+    { key: 'web-fullstack', hint: 'backend API + database wiring - frontend, functions, migrations; deploys green' },
+    { key: 'api', hint: 'pure API backend, no frontend - one example function + test' },
     { key: '3d-engine', hint: '3D multiplayer wiring - Three.js + Rapier + Gipity Realtime' },
 ];
 const HIDDEN = [{ key: 'app-itsm', hint: 'IT service management / helpdesk / ticketing' }];

package/dist/knowledge.js

@@ -40,7 +40,7 @@ Prefer the cheapest option that works - CLI and sandbox are instant and free, ap
 
 1. CLI commands (fast, no agent overhead). The \`gipity\` CLI covers add, deploy, db, fn, logs, browser, sync, memory, skill, and more. All commands support \`--json\`.
 2. Cloud sandbox via \`gipity sandbox run\` - Docker container with pre-installed tools for media (ffmpeg, ImageMagick, sox), documents (pandoc, LibreOffice), and data (pandas, matplotlib, sqlite3). Run \`gipity skill read sandbox-tools\` for the full toolkit. No network from inside the sandbox - fetch what you need before sending it in.
-3. App services - runtime HTTP endpoints your deployed app calls directly at \`https://a.gipity.ai/api/<PROJECT_GUID>/services/*\`. Available: LLM, TTS, image, sound, music, transcribe, video, file upload, realtime, location. Load the matching skill (\`app-llm\`, \`app-tts\`, etc.) before writing service code - they have the schemas, auth pattern, and common-mistake guards. For one-off generation during development, prefer \`gipity generate <image|video|speech|music>\` or \`gipity chat\`.
+3. App services - runtime HTTP endpoints your deployed app calls directly at \`https://a.gipity.ai/api/<PROJECT_GUID>/services/*\`. Available: LLM, TTS, image, sound, music, transcribe, video, file upload, realtime, location. Load the matching skill (\`app-llm\`, \`app-tts\`, etc.) before writing service code - they have the schemas, auth pattern, and common-mistake guards. For one-off generation during development, prefer \`gipity generate <image|video|speech|music>\` or \`gipity chat\`. \`gipity generate\` saves to a generic file in the current directory by default (e.g. \`./generated.png\`) — pass \`-o <path>\` to write it straight into your source tree so it deploys (e.g. \`gipity generate image "hero banner" -o src/assets/images/hero.png\`) instead of generating at cwd and moving it.
 4. Delegate to Gip (\`gipity chat "<task>"\`) - only when the work genuinely needs agent reasoning or a tool not in the CLI, sandbox, or app services. Required for: Twitter/X search, Gmail, calendar, push notifications, video understanding, audio source isolation, cross-model second opinions, multi-step orchestration. Don't use \`gipity chat\` for anything the sandbox can do - it's slower and burns tokens.
 
 You are the developer. Write files in this directory - they auto-sync to Gipity via hooks. Don't run \`npm install\`, \`npm start\`, \`node\`, or \`python\` locally; there is no local runtime. Code runs in the Gipity sandbox.

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.381",
   "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",