gipity 1.0.398 → 1.0.399

package/dist/commands/add.js

@@ -7,6 +7,7 @@ import { requireConfig } from '../config.js';
 import { sync } from '../sync.js';
 import { success, muted, bold } from '../colors.js';
 import { run } from '../helpers/index.js';
+import { createProgressReporter, withSpinner } from '../progress.js';
 const STARTERS = [
     { key: 'web-vision-cam', hint: 'fullscreen camera app with on-device vision (MediaPipe)' },
     { key: 'object-spotter', hint: 'camera app that boxes, labels, and counts objects (YOLOX on-device)' },
@@ -198,9 +199,14 @@ export const addCommand = new Command('add')
             force: opts.force,
         };
     }
-    const res = await post(`/projects/${config.projectGuid}/add`, body);
+    // The server runs the whole install pipeline before responding; animate the
+    // wait, then clear the spinner so the installed-files list is the result.
+    const doAdd = () => post(`/projects/${config.projectGuid}/add`, body);
+    const res = opts.json
+        ? await doAdd()
+        : await withSpinner('Installing…', doAdd, { done: null });
     // Pull the created/installed files down to local.
-    const syncResult = await sync({ interactive: false });
+    const syncResult = await sync({ interactive: false, progress: opts.json ? undefined : createProgressReporter() });
     const data = res.data;
     if (opts.json) {
         console.log(JSON.stringify({ ...data, synced: syncResult.applied }));

package/dist/commands/chat.js

@@ -4,6 +4,7 @@ import { resolveProjectContext, saveConfig } from '../config.js';
 import { sync } from '../sync.js';
 import { error as clrError, muted, success } from '../colors.js';
 import { run, printList, printResult } from '../helpers/index.js';
+import { createProgressReporter, withSpinner } from '../progress.js';
 export const chatCommand = new Command('chat')
     .description('Send a message to your agent')
     .argument('<message>', 'Message to send')
@@ -19,7 +20,12 @@ export const chatCommand = new Command('chat')
         const body = useExisting
             ? { content: message, projectGuid: config.projectGuid }
             : { agentGuid: config.agentGuid, content: message, projectGuid: config.projectGuid };
-        const res = await post(endpoint, body);
+        // The agent can think for many seconds; animate the wait, then clear the
+        // spinner (done:null) so the reply itself is the result. JSON mode skips it.
+        const doChat = () => post(endpoint, body);
+        const res = opts.json
+            ? await doChat()
+            : await withSpinner('Thinking…', doChat, { done: null });
         // Save conversation guid for continuity. Skipped in one-off mode: the
         // config was resolved from the server's Home project and there is no
         // local `.gipity.json` to update - persisting here would create one in
@@ -31,7 +37,10 @@ export const chatCommand = new Command('chat')
         let syncSummary = '';
         let syncChanges = [];
         if (res.data.filesChanged) {
-            const syncResult = await sync({ interactive: false });
+            const syncResult = await sync({
+                interactive: false,
+                progress: opts.json ? undefined : createProgressReporter(),
+            });
             if (syncResult.applied > 0) {
                 syncSummary = `\nSynced ${syncResult.applied} change${syncResult.applied > 1 ? 's' : ''}:\n${syncResult.summary}`;
             }

package/dist/commands/claude.js

@@ -5,7 +5,7 @@ import { execSync, spawn } from 'child_process';
 import { homedir } from 'os';
 import { fileURLToPath } from 'url';
 import { resolveCommand } from '../platform.js';
-import { getAuth, saveAuth } from '../auth.js';
+import { getAuth, saveAuth, sessionExpired } from '../auth.js';
 import { get, post, publicPost, ApiError, getAccountSlug } from '../api.js';
 import { getConfig, saveConfigAt, clearConfigCache, getApiBaseOverride, DEFAULT_API_BASE, getConfigPath } from '../config.js';
 import { sync } from '../sync.js';
@@ -291,7 +291,15 @@ export const claudeCommand = new Command('claude')
         if (!nonInteractive) {
             printBanner({ version: __clPkg.version, email: auth?.email, cwd: process.cwd() });
         }
-        if (auth) {
+        if (auth && sessionExpired()) {
+            // The cached auth.json exists but its refresh token has lapsed, so the
+            // first API call below would 401 anyway. Re-login up front instead of
+            // printing "Logged in" and immediately contradicting it with "session
+            // expired" once the projects fetch fails.
+            console.log(`  ${muted('Your session expired. Let\'s sign you back in.')}\n`);
+            auth = await interactiveLogin();
+        }
+        else if (auth) {
             console.log(`  Logged in (${auth.email}).`);
         }
         else {

package/dist/commands/deploy.js

@@ -4,6 +4,7 @@ import { requireConfig } from '../config.js';
 import { formatSize } from '../utils.js';
 import { success, error as clrError, warning, muted, bold, brand } from '../colors.js';
 import { run, syncBeforeAction } from '../helpers/index.js';
+import { withSpinner } from '../progress.js';
 // ── Status icons ───────────────────────────────────────────────────────
 function statusIcon(status) {
     if (status === 'ok')
@@ -32,14 +33,16 @@ export const deployCommand = new Command('deploy')
     }
     const config = requireConfig();
     await syncBeforeAction(opts);
-    // Call server - pipeline runs entirely server-side
-    const res = await post(`/projects/${config.projectGuid}/deploy`, {
+    const doDeploy = () => post(`/projects/${config.projectGuid}/deploy`, {
         target,
         sourceDir: opts.sourceDir,
         optimize: opts.optimize,
         force: opts.force,
         only: opts.only?.split(',').map((s) => s.trim()),
     });
+    const res = opts.json
+        ? await doDeploy()
+        : await withSpinner(`Deploying to ${target}…`, doDeploy, { done: null });
     const d = res.data;
     if (opts.json) {
         console.log(JSON.stringify(d));

package/dist/commands/generate.js

@@ -4,8 +4,9 @@ import { resolveProjectContext, getConfigPath } from '../config.js';
 import { pushFile } from '../sync.js';
 import { writeFileSync } from 'fs';
 import { resolve as resolvePath, dirname, relative, isAbsolute } from 'path';
-import { error as clrError, success, muted, info } from '../colors.js';
+import { error as clrError, success, muted } from '../colors.js';
 import { printCommandError } from '../helpers/command.js';
+import { withSpinner } from '../progress.js';
 import { IMAGE_MODELS_DOC, IMAGE_GEMINI_ASPECT_RATIOS, IMAGE_GEMINI_SIZES, VIDEO_MODELS_DOC, TTS_PROVIDER_DESCRIPTIONS } from '../provider-docs.js';
 /** Download a URL and save to a local file, then push it up to the project so
  *  the cloud (and anything that mirrors it) immediately matches local disk.
@@ -73,7 +74,7 @@ Examples:
     .action(async (prompt, opts) => {
     try {
         const { config } = await resolveProjectContext();
-        const result = await post(`/projects/${config.projectGuid}/generate/image`, {
+        const doGenerate = () => post(`/projects/${config.projectGuid}/generate/image`, {
             prompt,
             provider: opts.provider,
             model: opts.model,
@@ -83,6 +84,9 @@ Examples:
             image_size: opts.imageSize,
             seed: Number.isFinite(opts.seed) ? opts.seed : undefined,
         });
+        const result = opts.json
+            ? await doGenerate()
+            : await withSpinner('Generating image…', doGenerate, { done: null });
         const ext = result.content_type.includes('png') ? 'png' : 'jpg';
         const filename = opts.output || `generated.${ext}`;
         const savedPath = await downloadFile(result.url, filename);
@@ -131,14 +135,16 @@ Examples:
     .action(async (prompt, opts) => {
     try {
         const { config } = await resolveProjectContext();
-        if (!opts.json)
-            console.log(info('Generating video (this may take 30-120 seconds)...')); // keep --json stdout pure JSON
-        const result = await post(`/projects/${config.projectGuid}/generate/video`, {
+        const doGenerate = () => post(`/projects/${config.projectGuid}/generate/video`, {
             prompt,
             model: opts.model,
             aspect_ratio: opts.aspect,
             resolution: opts.resolution,
         });
+        // Veo runs 30-120s; the bouncing bar + timer keeps the wait honest.
+        const result = opts.json
+            ? await doGenerate()
+            : await withSpinner('Generating video…', doGenerate, { done: null });
         const filename = opts.output || 'generated.mp4';
         const savedPath = await downloadFile(result.url, filename);
         if (opts.json) {
@@ -191,13 +197,16 @@ Examples:
                 process.exit(1);
             }
         }
-        const result = await post(`/projects/${config.projectGuid}/generate/speech`, {
+        const doGenerate = () => post(`/projects/${config.projectGuid}/generate/speech`, {
             text,
             provider: opts.provider,
             voice: opts.voice,
             language: opts.language,
             speakers,
         });
+        const result = opts.json
+            ? await doGenerate()
+            : await withSpinner('Generating speech…', doGenerate, { done: null });
         const filename = opts.output || 'speech.mp3';
         const savedPath = await downloadFile(result.url, filename);
         if (opts.json) {
@@ -240,14 +249,15 @@ Examples:
     .action(async (prompt, opts) => {
     try {
         const { config } = await resolveProjectContext();
-        if (!opts.json)
-            console.log(info('Generating music...')); // keep --json stdout pure JSON
-        const result = await post(`/projects/${config.projectGuid}/generate/music`, {
+        const doGenerate = () => post(`/projects/${config.projectGuid}/generate/music`, {
             prompt,
             duration_seconds: opts.duration,
             model: opts.model,
             instrumental: !opts.vocals,
         });
+        const result = opts.json
+            ? await doGenerate()
+            : await withSpinner('Generating music…', doGenerate, { done: null });
         const filename = opts.output || 'music.mp3';
         const savedPath = await downloadFile(result.url, filename);
         if (opts.json) {

package/dist/commands/page-screenshot.js

@@ -6,6 +6,7 @@ import { getProjectRoot } from '../config.js';
 import { brand, bold, muted, success } from '../colors.js';
 import { formatSize } from '../utils.js';
 import { run } from '../helpers/index.js';
+import { withSpinner } from '../progress.js';
 const DEVICE_PRESETS = {
     default: { width: 1280, height: 720 },
     desktop: { width: 1920, height: 1080 },
@@ -143,7 +144,13 @@ export const pageScreenshotCommand = new Command('screenshot')
         ...(opts.fakeMedia ? { fakeMedia: true } : {}),
         ...(opts.action ? { action: opts.action } : {}),
     };
-    const entries = await postForTarEntries('/tools/browser/screenshot', body);
+    // Load + render across viewports runs server-side and can take many
+    // seconds; animate the wait, then clear so the saved-files summary is the
+    // result. JSON mode skips the spinner (shares stdout).
+    const doShoot = () => postForTarEntries('/tools/browser/screenshot', body);
+    const entries = opts.json
+        ? await doShoot()
+        : await withSpinner('Capturing…', doShoot, { done: null });
     const metaEntry = entries.find((e) => e.name === 'meta.json');
     if (!metaEntry)
         throw new Error('Server response missing meta.json');

package/dist/commands/remove.js

@@ -5,6 +5,7 @@ import { sync } from '../sync.js';
 import { success, muted } from '../colors.js';
 import { run } from '../helpers/index.js';
 import { confirm } from '../utils.js';
+import { createProgressReporter, withSpinner } from '../progress.js';
 export const removeCommand = new Command('remove')
     .description('Remove an installed kit from the project (inverse of `gipity add <kit>`).')
     .argument('<kit>', 'Kit key/directory under src/packages/ to remove')
@@ -18,10 +19,13 @@ export const removeCommand = new Command('remove')
             return;
         }
     }
-    const res = await post(`/projects/${config.projectGuid}/remove`, { name: kit });
+    const doRemove = () => post(`/projects/${config.projectGuid}/remove`, { name: kit });
+    const res = opts.json
+        ? await doRemove()
+        : await withSpinner('Removing…', doRemove, { done: null });
     // Force the pull so the kit's deletions land locally without tripping the
     // bulk-deletion guard - the removal is an explicit, user-invoked action.
-    const syncResult = await sync({ interactive: false, force: true });
+    const syncResult = await sync({ interactive: false, force: true, progress: opts.json ? undefined : createProgressReporter() });
     const data = res.data;
     if (opts.json) {
         console.log(JSON.stringify({ ...data, synced: syncResult.applied }));

package/dist/commands/sandbox.js

@@ -6,6 +6,7 @@ import { resolveProjectContext, getConfigPath } from '../config.js';
 import { sync } from '../sync.js';
 import { error as clrError, dim } from '../colors.js';
 import { run } from '../helpers/index.js';
+import { createProgressReporter, withSpinner } from '../progress.js';
 const LANG_MAP = {
     js: 'javascript',
     javascript: 'javascript',
@@ -159,15 +160,20 @@ GCC/Rust).
     // Bidirectional + CAS, so it's a cheap manifest check when nothing changed.
     // Symmetric with the post-run pull below. Skip in one-off mode (no project).
     if (getConfigPath()) {
-        await sync({ interactive: false });
+        await sync({ interactive: false, progress: opts.json ? undefined : createProgressReporter() });
     }
-    const res = await post(`/projects/${config.projectGuid}/sandbox/execute`, {
+    // The run blocks until the sandbox finishes (up to the timeout); animate the
+    // wait, then clear the spinner so stdout/stderr is the result. JSON skips it.
+    const doRun = () => post(`/projects/${config.projectGuid}/sandbox/execute`, {
         code: source,
         language,
         timeout: isNaN(timeout) ? 30 : timeout,
         input_files: opts.input,
         cwd,
     });
+    const res = opts.json
+        ? await doRun()
+        : await withSpinner('Running in sandbox…', doRun, { done: null });
     // Pull sandbox-written outputs down to the local cwd automatically. The
     // server has already mirrored them into the project (VFS) and handed back
     // the exact list, so honoring it here means files land locally without a
@@ -175,7 +181,7 @@ GCC/Rust).
     // `filesChanged` flag. Skip in one-off mode (no local project to sync into).
     const pulledLocal = !!(res.data.outputFiles?.length && getConfigPath());
     if (pulledLocal) {
-        await sync({ interactive: false });
+        await sync({ interactive: false, progress: opts.json ? undefined : createProgressReporter() });
     }
     if (opts.json) {
         console.log(JSON.stringify({ ...res.data, filesSynced: pulledLocal }));

package/dist/helpers/sync.js

@@ -3,6 +3,7 @@
  */
 import { sync } from '../sync.js';
 import { muted, error as clrError } from '../colors.js';
+import { createProgressReporter } from '../progress.js';
 /**
  * Sync local files with the server before an action (deploy, test, scaffold).
  * Respects --no-sync and --json flags. Non-interactive: bulk-deletion guard
@@ -14,7 +15,14 @@ import { muted, error as clrError } from '../colors.js';
 export async function syncBeforeAction(opts) {
     if (opts.sync === false)
         return;
-    const result = await sync({ interactive: false, force: opts.force });
+    // Pass a progress reporter so a large pre-action upload shows the transfer
+    // bar instead of a silent pause (the reporter is a no-op on non-TTY / when
+    // piped, so JSON and headless output stay clean).
+    const result = await sync({
+        interactive: false,
+        force: opts.force,
+        progress: opts.json ? undefined : createProgressReporter(),
+    });
     if (result.applied > 0 && !opts.json) {
         console.log(muted(`Synced ${result.applied} change${result.applied > 1 ? 's' : ''}`));
     }

package/dist/index.js

@@ -57,6 +57,24 @@ import { bold, dim, brand, muted, success } from './colors.js';
 import { normalizeAliases } from './flag-aliases.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(resolve(__dirname, '../package.json'), 'utf-8'));
+// Local builds stamp dist/build-info.json (git SHA + dirty flag) via the npm
+// `postbuild` hook, so `-v` can show whether the linked binary is your latest
+// code. It is intentionally absent from published installs: the npm `files`
+// allowlist ships only dist/**/*.js, so a released CLI prints a clean
+// `v1.0.398` with no dev marker. package.json `version` stays the source of
+// truth for the published release; this marker never touches it.
+function versionLabel() {
+    const base = `v${pkg.version}`;
+    try {
+        const info = JSON.parse(readFileSync(resolve(__dirname, 'build-info.json'), 'utf-8'));
+        if (info?.sha)
+            return `${base} (dev ${info.sha}${info.dirty ? ', modified' : ''})`;
+    }
+    catch {
+        // No build-info.json (published install or pre-build) → clean version.
+    }
+    return base;
+}
 // Custom -v/--version output: include auth status so agents know whether
 // the next CLI call will succeed. Intercepted before Commander parses,
 // because Commander's built-in `.version()` only prints a string and exits.
@@ -79,7 +97,7 @@ const pkg = JSON.parse(readFileSync(resolve(__dirname, '../package.json'), 'utf-
             authLine = `${success('Logged in')} as ${auth.email}`;
         }
         console.log('');
-        console.log(`${brand(bold('Gipity'))} ${muted(`v${pkg.version}`)}`);
+        console.log(`${brand(bold('Gipity'))} ${muted(versionLabel())}`);
         console.log(authLine);
         console.log('');
         process.exit(0);
@@ -150,7 +168,7 @@ program.configureHelp({
         const padOpt = (s) => s.padEnd(optColWidth);
         const lines = [];
         lines.push('');
-        lines.push(`${brand(bold('Gipity CLI'))} ${muted(`v${pkg.version}`)}`);
+        lines.push(`${brand(bold('Gipity CLI'))} ${muted(versionLabel())}`);
         lines.push(dim(GIPITY_TAGLINE));
         lines.push(dim('Hosting, databases, deploys, workflows - one place. Pair with Claude Code or use standalone.'));
         lines.push(dim('Works with Claude Code, Codex, Aider, or any AI coding tool - no MCP server needed.'));

package/dist/progress.js

@@ -1,33 +1,57 @@
 // ── Gipity CLI Progress Reporter ────────────────────────────────────────
 // One central place for long-running terminal feedback, so commands don't
-// each reinvent status lines. Two channels:
+// each reinvent status lines. Three channels, one shared visual vocabulary:
 //
 //   phase(msg)              - a discrete step with no measurable size
 //                             (scanning, hashing). Prints one committed line.
-//   transfer(label, n, tot) - a determinate byte transfer. Renders a single
-//                             in-place bar that updates as bytes move.
+//   transfer(label, n, tot) - a DETERMINATE byte transfer. Renders a single
+//                             in-place bar that fills as bytes move.
+//   spinner(label)          - an INDETERMINATE wait (a server call where we
+//                             can't measure bytes: deploy, generate, chat).
+//                             Renders the SAME-width track as transfer(), but
+//                             with a short block that bounces left↔right plus
+//                             an elapsed timer, so a long wait never reads as
+//                             frozen. Settles to a committed ✓/✗ line.
 //
 // On a non-TTY (piped output, hook-driven sync, headless -p) the reporter is a
 // silent no-op - no `\r` spam in logs. Colors come from ./colors so the bar
 // matches the rest of the CLI (orange fill + percentage).
-import { brand, brandBold, muted, dim } from './colors.js';
+import { brand, brandBold, muted, dim, success, error as clrError } from './colors.js';
 import { formatSize } from './utils.js';
 const CLEAR_TO_EOL = '\x1b[K';
 const BAR_WIDTH = 18;
 const RENDER_THROTTLE_MS = 60;
+// Indeterminate bounce: a short block sliding across the same BAR_WIDTH track
+// the determinate bar fills. Frame cadence is slow enough to read, fast enough
+// to feel alive.
+const SPIN_BLOCK = 5;
+const SPIN_FRAME_MS = 90;
+/** Compact elapsed: "8s", "1m 04s". Keeps the timer narrow and glanceable. */
+function formatElapsed(ms) {
+    const s = Math.floor(ms / 1000);
+    if (s < 60)
+        return `${s}s`;
+    const m = Math.floor(s / 60);
+    return `${m}m ${String(s % 60).padStart(2, '0')}s`;
+}
 class TerminalProgress {
-    /** True while an in-place transfer line is on screen and not yet committed. */
+    /** True while an in-place transfer/spinner line is on screen and not 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;
+    /** Active indeterminate spinner timer, if any. */
+    spinTimer = null;
     phase(message) {
+        this.stopSpinTimer();
         this.commitLive();
         process.stdout.write(`  ${muted(message)}\n`);
     }
     transfer(label, doneBytes, totalBytes) {
+        // A determinate transfer takes over the live line from any spinner.
+        this.stopSpinTimer();
         // 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
@@ -46,32 +70,115 @@ class TerminalProgress {
             return;
         this.lastRenderAt = now;
         this.liveOpen = true;
-        process.stdout.write('\r' + this.frame(label, doneBytes, totalBytes) + CLEAR_TO_EOL);
+        process.stdout.write('\r' + this.barFrame(label, doneBytes, totalBytes) + CLEAR_TO_EOL);
         if (finished) {
             this.commitLive();
             this.barSettled = true;
         }
     }
+    spinner(label) {
+        this.stopSpinTimer();
+        this.commitLive();
+        const startedAt = Date.now();
+        let tick = 0;
+        const draw = () => {
+            this.liveOpen = true;
+            process.stdout.write('\r' + this.spinFrame(label, tick++, Date.now() - startedAt) + CLEAR_TO_EOL);
+        };
+        draw();
+        this.spinTimer = setInterval(draw, SPIN_FRAME_MS);
+        // Don't let the animation keep the event loop (and process) alive on its own.
+        this.spinTimer.unref?.();
+        const settle = (icon, message) => {
+            this.stopSpinTimer();
+            if (this.liveOpen)
+                process.stdout.write('\r');
+            if (icon) {
+                // Replace the spinner line in place with a committed ✓/✗ result line.
+                const elapsed = muted(formatElapsed(Date.now() - startedAt));
+                process.stdout.write(`  ${icon}  ${muted(message ?? label)}  ${elapsed}${CLEAR_TO_EOL}\n`);
+            }
+            else if (this.liveOpen) {
+                // Silent stop: clear the spinner row but DON'T advance - leave the
+                // cursor at column 0 so the command's own result overwrites the row
+                // instead of leaving a blank line behind it.
+                process.stdout.write(CLEAR_TO_EOL);
+            }
+            this.liveOpen = false;
+        };
+        return {
+            succeed: (m) => settle(success('✓'), m),
+            fail: (m) => settle(clrError('✗'), m),
+            stop: () => settle(null),
+        };
+    }
     finish() {
+        this.stopSpinTimer();
         this.commitLive();
     }
+    stopSpinTimer() {
+        if (this.spinTimer) {
+            clearInterval(this.spinTimer);
+            this.spinTimer = null;
+        }
+    }
     commitLive() {
         if (!this.liveOpen)
             return;
         process.stdout.write('\n');
         this.liveOpen = false;
     }
-    frame(label, done, total) {
+    barFrame(label, done, total) {
         const pct = total > 0 ? Math.min(100, Math.floor((done / total) * 100)) : 100;
         const filled = Math.round((pct / 100) * BAR_WIDTH);
         const bar = brand('█'.repeat(filled)) + dim('░'.repeat(BAR_WIDTH - filled));
         const sizes = muted(`${formatSize(done)} / ${formatSize(total)}`);
         return `  ${muted(label)}  ${bar}  ${brandBold(`${pct}%`)}  ${sizes}`;
     }
+    spinFrame(label, tick, elapsedMs) {
+        // Ping-pong the block's left edge between 0 and (BAR_WIDTH - SPIN_BLOCK).
+        const span = BAR_WIDTH - SPIN_BLOCK;
+        const cycle = span * 2;
+        const phase = tick % cycle;
+        const pos = phase <= span ? phase : cycle - phase;
+        const bar = dim('░'.repeat(pos)) +
+            brand('█'.repeat(SPIN_BLOCK)) +
+            dim('░'.repeat(BAR_WIDTH - pos - SPIN_BLOCK));
+        return `  ${muted(label)}  ${bar}  ${muted(formatElapsed(elapsedMs))}`;
+    }
 }
-const NOOP = { phase() { }, transfer() { }, finish() { } };
+const NOOP_SPINNER = { succeed() { }, fail() { }, stop() { } };
+const NOOP = {
+    phase() { }, transfer() { }, finish() { },
+    spinner: () => NOOP_SPINNER,
+};
 /** A reporter that draws on a TTY and stays silent otherwise. */
 export function createProgressReporter() {
     return process.stdout.isTTY ? new TerminalProgress() : NOOP;
 }
+/**
+ * Run an indeterminate async operation behind the standard bouncing-block
+ * spinner: animate `label` while it's in flight, then settle. On success the
+ * line becomes a ✓ (`done`, or `label` if omitted) — or, when `done` is null,
+ * the spinner just clears silently (use this when the command prints its own
+ * result, e.g. a chat reply). On throw it becomes a ✗ and re-throws so the
+ * caller's own error handling still runs. On a non-TTY this is a silent
+ * pass-through. The single wrapper every command uses for a server call whose
+ * size/duration we can't measure (deploy, generate, chat, sandbox, …).
+ */
+export async function withSpinner(label, fn, opts = {}) {
+    const sp = (opts.reporter ?? createProgressReporter()).spinner(label);
+    try {
+        const result = await fn();
+        if (opts.done === null)
+            sp.stop();
+        else
+            sp.succeed(opts.done);
+        return result;
+    }
+    catch (e) {
+        sp.fail();
+        throw e;
+    }
+}
 //# sourceMappingURL=progress.js.map

package/dist/relay/daemon.js

@@ -632,6 +632,12 @@ async function handleDispatch(d) {
     // prompt is correct (same authority as running `claude -p` in a local
     // terminal yourself).
     const args = ['claude', '-p', d.message, '--permission-mode', 'bypassPermissions'];
+    // Per-chat model: the user picked it with `/model` in the web CLI. `gipity
+    // claude` forwards --model straight through to the `claude` binary, which
+    // honors it on both a fresh session and a --resume. null => agent default.
+    if (d.model) {
+        args.push('--model', d.model);
+    }
     if (d.kind === 'resume' && d.remote_session_id) {
         args.push('--resume', d.remote_session_id);
     }

package/dist/upload.js

@@ -1,4 +1,5 @@
 import { createReadStream } from 'fs';
+import { Transform } from 'stream';
 import { extname } from 'path';
 import { createHash } from 'crypto';
 import { post, putToPresignedUrl, ApiError } from './api.js';
@@ -170,11 +171,35 @@ export async function uploadOneFile(projectGuid, localPath, virtualPath, opts =
 export async function transferToS3(localPath, size, mime, data, opts = {}) {
     // Single-part (covers fresh + resumed PUT - single PUT is idempotent on the staging key).
     if (data.method === 'PUT') {
+        // Report bytes as they flow to S3 so the progress bar moves during the
+        // transfer instead of sitting at 0% until the whole file lands (a large
+        // file - e.g. a 674 MB video - otherwise looks hung for minutes). A
+        // pass-through Transform counts each chunk as fetch pulls it; we don't
+        // attach a 'data' listener, which would drain the stream before fetch
+        // reads it.
+        let reported = 0;
         const etag = await withRetry('PUT', async () => {
+            // A retried attempt re-streams from the top, so back out whatever the
+            // failed attempt already counted to keep the shared total accurate.
+            if (reported) {
+                opts.onBytes?.(-reported);
+                reported = 0;
+            }
             const stream = createReadStream(localPath);
-            return putToPresignedUrl(data.url, stream, size, data.headers?.['Content-Type'] ?? mime);
+            let body = stream;
+            if (opts.onBytes) {
+                const counter = new Transform({
+                    transform(chunk, _enc, cb) { reported += chunk.length; opts.onBytes(chunk.length); cb(null, chunk); },
+                });
+                stream.on('error', err => counter.destroy(err));
+                body = stream.pipe(counter);
+            }
+            return putToPresignedUrl(data.url, body, size, data.headers?.['Content-Type'] ?? mime);
         });
-        opts.onBytes?.(size);
+        // True up to exactly `size`: a dedup/no-op PUT streams nothing, and chunk
+        // sums can fall a hair short of the stat size on the final read.
+        if (reported !== size)
+            opts.onBytes?.(size - reported);
         return { etag };
     }
     // Multipart - start with any parts that already landed (resume case).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gipity",
-  "version": "1.0.398",
+  "version": "1.0.399",
   "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",
@@ -10,6 +10,7 @@
   "type": "module",
   "scripts": {
     "build": "tsc && chmod +x dist/index.js dist/gipcc.js dist/gipccd.js dist/updater/shim.js dist/updater/check.js",
+    "postbuild": "node scripts/gen-build-info.mjs",
     "dev": "tsc --watch",
     "test": "npm run test:smoke",
     "test:smoke": "tsc && node --test dist/__tests__/utils.test.js dist/__tests__/colors.test.js dist/__tests__/config.test.js dist/__tests__/sync.test.js dist/__tests__/sync-apply.test.js dist/__tests__/sync-lock.test.js dist/__tests__/auth-lock.test.js dist/__tests__/push-cas.test.js dist/__tests__/upload.test.js dist/__tests__/progress.test.js dist/__tests__/updater.test.js dist/__tests__/cli-smoke.test.js dist/__tests__/claude-noninteractive.test.js dist/__tests__/claude-trust.test.js dist/__tests__/relay-state.test.js dist/__tests__/relay-daemon.test.js dist/__tests__/relay-installers.test.js dist/__tests__/relay-bridge-abort.test.js dist/__tests__/relay-redact.test.js dist/__tests__/relay-machine-id.test.js dist/__tests__/stream-json.test.js dist/__tests__/relay-ingest-contract.test.js dist/__tests__/prompts.test.js dist/__tests__/capture-transcript.test.js dist/__tests__/flag-aliases.test.js dist/__tests__/client-context.test.js dist/__tests__/adopt-cwd.test.js dist/__tests__/cli-cmd-agent.test.js dist/__tests__/cli-cmd-approval.test.js dist/__tests__/cli-cmd-audit.test.js dist/__tests__/cli-cmd-chat.test.js dist/__tests__/cli-cmd-credits.test.js dist/__tests__/cli-cmd-db.test.js dist/__tests__/cli-cmd-deploy.test.js dist/__tests__/cli-cmd-domain.test.js dist/__tests__/cli-cmd-email.test.js dist/__tests__/cli-cmd-file.test.js dist/__tests__/cli-cmd-fn.test.js dist/__tests__/cli-cmd-service.test.js dist/__tests__/cli-cmd-job.test.js dist/__tests__/cli-cmd-generate.test.js dist/__tests__/cli-cmd-gmail.test.js dist/__tests__/cli-cmd-info.test.js dist/__tests__/cli-cmd-init.test.js dist/__tests__/cli-cmd-location.test.js dist/__tests__/cli-cmd-text.test.js dist/__tests__/cli-cmd-login.test.js dist/__tests__/cli-cmd-logout.test.js dist/__tests__/cli-cmd-token.test.js dist/__tests__/cli-cmd-logs.test.js dist/__tests__/cli-cmd-memory.test.js dist/__tests__/cli-cmd-page.test.js dist/__tests__/cli-cmd-plan.test.js dist/__tests__/cli-cmd-project.test.js dist/__tests__/cli-cmd-rbac.test.js dist/__tests__/cli-cmd-realtime.test.js dist/__tests__/cli-cmd-records.test.js dist/__tests__/cli-cmd-relay.test.js dist/__tests__/cli-cmd-sandbox.test.js dist/__tests__/cli-cmd-add.test.js dist/__tests__/cli-cmd-remove.test.js dist/__tests__/cli-cmd-skill.test.js dist/__tests__/cli-cmd-test.test.js dist/__tests__/cli-cmd-workflow.test.js dist/__tests__/setup-skills-block.test.js dist/__tests__/setup-hooks.test.js",