gipity 1.1.3 → 1.1.5

package/dist/commands/page-screenshot.js

@@ -8,6 +8,7 @@ import { brand, bold, muted, success, warning } from '../colors.js';
 import { formatSize } from '../utils.js';
 import { run } from '../helpers/index.js';
 import { withSpinner } from '../progress.js';
+import { readScriptFile } from './page-eval.js';
 import { uploadCameraFeed, assertCameraFile, deleteFixture } from '../page-fixtures.js';
 /** `mobile` and `tablet` name a real handset/tablet rather than just a window size.
  *  The server emulates it end to end - mobile user-agent, DPR, and crucially TOUCH,
@@ -234,7 +235,8 @@ export const pageScreenshotCommand = new Command('screenshot')
     .option('--wait <ms>', `Sleep this many ms after DOMContentLoaded before capturing (default 1000, max ${MAX_POST_LOAD_DELAY_MS}). With --camera it defaults to ${CAMERA_DEFAULT_DELAY_MS} so the vision model is up. Same flag as page eval/inspect.`)
     .option('--wait-for <selector>', `Wait until this CSS selector appears before capturing, then capture (deterministic - beats guessing a --wait). Same flag as page eval/inspect. Gate on what you are photographing ('[data-vision="ready"]', '#verdict:not(:empty)'). Max ${WAIT_FOR_MAX_MS}ms (--wait-timeout).`)
     .option('--wait-timeout <ms>', `Max ms to wait for --wait-for before giving up (default ${WAIT_FOR_DEFAULT_MS}, max ${WAIT_FOR_MAX_MS}). Timing out is reported - the capture still happens, so you see the state it got stuck in.`)
-    .option('--action <js>', 'Run JS in the page before capturing — e.g. click a button to enter a state ("document.getElementById(\'play\').click()"). Runs as an async function body, so const/await and app-relative import(\'./…\') work. Runs after the post-load delay, then settles again before the shot. If it throws, the capture still happens and the failure is reported.')
+    .option('--action <js>', 'Run JS in the page before capturing - e.g. click a button to enter a state ("document.getElementById(\'play\').click()"). Runs as an async function body, so const/await and app-relative import(\'./...\') work. Runs after the post-load delay, then settles again before the shot. If it throws, the capture still happens and the failure is reported.')
+    .option('--file <path>', 'Read the pre-capture script from a file instead of inline --action (mutually exclusive), or --file - to read it from stdin (pipe a heredoc: --file - <<\'EOF\' ... EOF) with no tmp file. For a multi-step driver - click through a flow, wait for it to render - then capture. Same async-function-body semantics as --action; same --file flag as page eval.')
     .option('--full', 'Capture the full scrollable page (default: viewport only). Scrolls the page through first so scroll-reveal/fade-in-on-scroll (IntersectionObserver) sections render into the shot instead of capturing blank.')
     .option('-o, --output <file>', 'Output path (single viewport only; default .gipity/screenshots/ss-<host>-<timestamp>.png)')
     .option('--no-reload-between', 'Skip reload between viewports (faster, lower fidelity - only safe for static pages)')
@@ -264,8 +266,27 @@ export const pageScreenshotCommand = new Command('screenshot')
     if (aliasFlag) {
         console.error(muted(`Note: treating ${aliasFlag} as --action — it runs your JS in the page before the capture. --action is the canonical flag.`));
     }
-    const actionScript = [opts.action, ...ACTION_ALIAS_FLAGS.map((f) => opts[f.slice(2)])]
+    // The pre-capture script can come inline (--action / its JS-intent aliases) or
+    // from a file/stdin (--file, the same script-passing ergonomics as page eval).
+    // They are mutually exclusive: one page load runs one pre-capture body, so a
+    // caller that passed both meant one of them — say so rather than silently
+    // concatenating a driver script onto a stray click.
+    const inlineAction = [opts.action, ...ACTION_ALIAS_FLAGS.map((f) => opts[f.slice(2)])]
         .filter(Boolean).join('\n');
+    if (opts.file && inlineAction) {
+        throw new Error('Pass either --file <path> or an inline --action script, not both');
+    }
+    let actionScript = inlineAction;
+    if (opts.file) {
+        try {
+            actionScript = readScriptFile(opts.file);
+        }
+        catch {
+            throw new Error(opts.file === '-'
+                ? "--file - reads the pre-capture script from stdin, but stdin was empty/unreadable - pipe it in, e.g. gipity page screenshot \"<url>\" --file - <<'EOF' ... EOF"
+                : `Cannot read file: ${opts.file}`);
+        }
+    }
     // --wait is the canonical name (it is what `page inspect`/`page eval` call it);
     // --post-load-delay stays as a hidden alias. Whether the caller named EITHER is
     // what decides the defaults below, so keep the raw "was it set" signal.
@@ -351,7 +372,7 @@ export const pageScreenshotCommand = new Command('screenshot')
         assertCameraFile(opts.camera);
         if (!projectGuid)
             throw new Error('--camera needs a linked project (the frame is hosted for the browser to fetch) — run `gipity link` first.');
-        console.log(muted(`Hosting camera feed ${opts.camera}…`));
+        console.log(muted(`Hosting camera feed ${opts.camera}...`));
         camera = await uploadCameraFeed(projectGuid, opts.camera);
     }
     // The pre-capture script the server runs after the post-load delay: the
@@ -386,7 +407,7 @@ export const pageScreenshotCommand = new Command('screenshot')
         try {
             entries = opts.json
                 ? await doShoot()
-                : await withSpinner('Capturing…', doShoot, { done: null });
+                : await withSpinner('Capturing...', doShoot, { done: null });
         }
         catch (err) {
             // The sandbox budget covers the WHOLE capture — load, --action, settle,
@@ -546,9 +567,17 @@ Waiting for the page to reach a state before the shot?
 
 Capturing a state that needs an interaction (start a game, open a menu, dismiss a modal)?
   Use --action to run JS in the page before the shot — it fires after the wait
-  (and after any --wait-for gate), then settles again so the result has painted. Do
-  NOT hand-roll a 'page eval' that returns a base64 image: the eval result is capped
-  (~16KB) and truncates the PNG.
+  (and after any --wait-for gate), then settles again so the result has painted. For
+  a multi-step driver (click, wait, click) pipe it as a heredoc with --file - (same
+  as 'page eval') instead of cramming it into one inline string:
+    gipity page screenshot "https://dev.gipity.ai/me/app/" --file - <<'EOF'
+    document.getElementById('load-sample').click();
+    await new Promise(r => setTimeout(r, 500));
+    document.getElementById('run').click();
+    await new Promise(r => setTimeout(r, 2000));
+    EOF
+  Do NOT hand-roll a 'page eval' that returns a base64 image: the eval result is
+  capped (~16KB) and truncates the PNG.
 
 Capturing an off-screen region or reading element data?
     • --full captures the ENTIRE scrollable page (then crop to the region).

package/dist/commands/page-test.js

@@ -268,7 +268,7 @@ export const pageTestCommand = new Command('test')
     // Interactive mode (--observe drives it):
     .option('--observe <expr>', 'Interactive: JS expression sampled in each client to read shared state (e.g. presence count). Switches on interactive mode.')
     .option('--action <expr>', 'Interactive: one-time JS run in each client before observing (e.g. fill a name + submit). {{label}}/{{i}} are substituted per client.')
-    .option('--labels <csv>', 'Per-client labels substituted for {{label}} in the URL/--action/--observe (default client-0, client-1, …)')
+    .option('--labels <csv>', 'Per-client labels substituted for {{label}} in the URL/--action/--observe (default client-0, client-1, ...)')
     .option('--hold <ms>', `Interactive: total observe window per client (${MIN_HOLD_MS}-${MAX_HOLD_MS}ms)`, '8000')
     .option('--samples <k>', 'Interactive: number of observations across the hold window (2-30)', '6')
     .option('--wait-for <selector>', 'Interactive: wait for this CSS selector before running --action (deterministic readiness gate)')

package/dist/commands/records.js

@@ -9,7 +9,7 @@ import { confirm } from '../utils.js';
 // Records API is the only records surface that exists server-side; there is no
 // /projects/<guid>/records mirror.)
 export const recordsCommand = new Command('records')
-    .description('Manage records-kit data (registry-driven CRUD)');
+    .description('Manage app records (Gipity Records - validated CRUD with audit history)');
 recordsCommand
     .command('list')
     .description('List record tables')
@@ -91,6 +91,19 @@ recordsCommand
     const res = await get(`/api/${config.projectGuid}/records/${table}/${id}`);
     console.log(opts.json ? JSON.stringify(res.data) : JSON.stringify(res.data, null, 2));
 }));
+recordsCommand
+    .command('history <table> <id>')
+    .description('Audit history for a record (who/what changed it, with English summaries)')
+    .option('--limit <n>', 'Max events', '20')
+    .option('--json', 'Output as JSON')
+    .action((table, id, opts) => run('History', async () => {
+    const config = requireConfig();
+    const res = await get(`/api/${config.projectGuid}/records/${table}/${id}/history?limit=${encodeURIComponent(opts.limit)}`);
+    printList(res.data, opts, 'No history for this record.', e => {
+        const summary = e.detail?.summary || `${e.action} ${e.entity_type} ${e.entity_id}`;
+        return `${muted(e.created_at)}  ${bold(e.source || '-')}  ${summary}`;
+    });
+}));
 recordsCommand
     .command('create <table>')
     .description('Create a record')

package/dist/commands/remove.js

@@ -22,7 +22,7 @@ export const removeCommand = new Command('remove')
     const doRemove = () => post(`/projects/${config.projectGuid}/remove`, { name: kit });
     const res = opts.json
         ? await doRemove()
-        : await withSpinner('Removing…', doRemove, { done: null });
+        : await withSpinner('Removing...', doRemove, { done: null });
     const data = res.data;
     // Pull the kit's deletions locally. Whitelist ONLY the kit's own removed files
     // so they bypass the bulk-delete guard (the removal is explicit), while any

package/dist/commands/sandbox.js

@@ -6,7 +6,7 @@ import { resolveProjectContext, getConfigPath, getProjectRoot, shouldIgnore } fr
 import { SCRATCH_IGNORE } from '../setup.js';
 import { sync } from '../sync.js';
 import { error as clrError, dim } from '../colors.js';
-import { run } from '../helpers/index.js';
+import { run, parseDuration } from '../helpers/index.js';
 import { createProgressReporter, withSpinner } from '../progress.js';
 const LANG_MAP = {
     js: 'javascript',
@@ -144,6 +144,77 @@ function explainSplitArgs(args) {
     lines.push('', 'Fix, in order of preference:', dim('  1. Put the code in a file (best for anything with quotes, $(...), or newlines):'), '       gipity sandbox run --file script.sh', dim('  2. Use the interpreter shorthand on a file:'), '       gipity sandbox run bash script.sh', dim('  3. Keep it inline, but as ONE argument your shell will not split:'), "       gipity sandbox run --language bash 'echo hi'");
     return lines.join('\n');
 }
+// Regex fragments for the scratch directory names, derived from SCRATCH_IGNORE
+// so this can never drift from what sync actually ignores. Each pattern's
+// trailing '/' is dropped, dots are escaped, and a leading-`*` glob (`*_tmp/`)
+// becomes a filename-char run so `frames_tmp/` is matched too. `shouldIgnore`
+// is the authoritative filter downstream, so a slightly broad candidate here is
+// harmless — it just gets dropped if sync wouldn't actually ignore it.
+const SCRATCH_DIR_PATTERNS = SCRATCH_IGNORE
+    .map((p) => p.replace(/\/$/, ''))
+    .filter(Boolean)
+    .map((p) => p.replace(/[.]/g, '\\.').replace(/\*/g, '[A-Za-z0-9._-]*'));
+/**
+ * References to a scratch directory inside a code body — the files the sandbox's
+ * auto-mirror will NOT carry, because sync ignores the scratch namespaces. Two
+ * shapes of the same trap are matched:
+ *   - project-relative `tmp/nimbus.pdf` (how you name a root file locally), and
+ *   - mirror-absolute `/work/tmp/nimbus.pdf` (how you name that same file inside
+ *     the container, where the auto-mirror lands the project under /work/).
+ * Both are returned project-relative (the `/work/` prefix stripped) so the caller
+ * can resolve them on local disk and print a clean path. Deliberately NOT matched:
+ * `/tmp/out` (the container's own writable /tmp is fine) nor `mytmp/x` (word
+ * boundary). Covers every SCRATCH_IGNORE namespace, including the `*_tmp/` glob.
+ * Returns the distinct referenced paths. Exported for tests.
+ */
+export function scratchRefsInCode(code) {
+    const dirs = SCRATCH_DIR_PATTERNS.join('|');
+    if (!dirs)
+        return [];
+    // Match either a `/work/`-prefixed reference or a bare one that is not preceded
+    // by a slash (absolute/nested path) or a word/dot char (mytmp/, a.tmp/).
+    const re = new RegExp(`(?:\\/work\\/|(?<![\\w/.]))(?:${dirs})\\/[A-Za-z0-9._\\-\\/]+`, 'g');
+    return [...new Set((code.match(re) ?? []).map((m) => m.replace(/^\/work\//, '')))];
+}
+/**
+ * True when the code WRITES `p` at its FIRST use, so the file is produced inside
+ * the sandbox and any later reference (an `ls`/`cat` to inspect it, a second
+ * pass over it) reads that in-sandbox copy rather than an unmirrored input. Two
+ * output shapes are recognized, judged at the path's first occurrence:
+ *   - a flagged/redirected output: `-o p`, `-of p`, `--output p`, `> p`, `>> p`, `tee p`;
+ *   - an ffmpeg trailing-positional output: ffmpeg names its output as the last
+ *     positional (NO `-o` flag), so a path in an ffmpeg segment that is not the
+ *     `-i`/`--input` argument is an output.
+ * This keeps the write-then-inspect pattern in one script working (ffmpeg writes
+ * tmp/clip.mp4, then `ls tmp/clip.mp4`), while still catching a genuine staged
+ * INPUT read whose first use is not a write (`cat tmp/x`, `pandoc tmp/x.md ...`,
+ * `open('tmp/x')`, `ffmpeg -i tmp/x ...`). It also lets the normal iterate loop
+ * through: a scratch OUTPUT lands locally after the first run, so on a re-run it
+ * exists, but its first reference is still the write.
+ */
+export function isWriteTarget(code, p) {
+    const path = p.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const m = new RegExp(`(?:\\/work\\/)?${path}(?![\\w./-])`).exec(code);
+    if (!m)
+        return false;
+    const idx = m.index;
+    const before = code.slice(Math.max(0, idx - 40), idx);
+    // Flagged / redirected output position immediately before the path.
+    if (/(?:^|[\s'"`;(])(?:-o|-of|--out(?:put)?[= ]|>>?|tee(?:\s+-a)?)\s*['"`]?(?:\/work\/)?$/.test(before))
+        return true;
+    // ffmpeg's output is a trailing positional (no `-o`): a path in an ffmpeg
+    // segment that isn't the `-i`/`--input` argument is an output.
+    const segStart = Math.max(code.lastIndexOf('&&', idx), code.lastIndexOf('||', idx), code.lastIndexOf(';', idx), code.lastIndexOf('|', idx), code.lastIndexOf('\n', idx));
+    // segStart points at the FIRST char of the separator; a two-char operator
+    // (`&&`/`||`) leaves its second char in the slice, so strip any leading
+    // operator/space chars before reading the command word. Without this, the
+    // canonical `mkdir -p tmp && ffmpeg -i a.png tmp/out.mp4` idiom left a stray
+    // `&` that defeated the command extractor and false-blocked the re-run.
+    const seg = code.slice(segStart + 1, idx).replace(/^[\s&|;]+/, '');
+    const cmd = /^\s*([A-Za-z0-9_./-]+)/.exec(seg)?.[1]?.split('/').pop()?.toLowerCase();
+    const afterInputFlag = /(?:^|[\s'"`])(?:-i|--input)[= ]\s*['"`]?$/.test(before);
+    return cmd === 'ffmpeg' && !afterInputFlag;
+}
 /** Project-relative path from the process cwd, or undefined when there's
  *  no local config (one-off mode) or the cwd is at/above the project root. */
 function resolveRelativeCwd() {
@@ -171,7 +242,16 @@ sandboxCommand
     // positional arg is the canonical spelling). Accept it as a working alias
     // rather than bouncing the guess into an unknown-option --help detour.
     .addOption(new Option('--code <code>', 'Alias for the positional inline <code> arg').hideHelp())
-    .option('--timeout <seconds>', 'Execution timeout in seconds', '30')
+    // `bash -c '<code>'` and `node -e '<code>'` are the universal ways to run an
+    // inline command, and an agent reaches for them by reflex - but the bare
+    // `-c` / `-e` used to hit commander's OWN parser first ("unknown option
+    // '-c'"), before the interpreter-token logic below ever ran. Declaring them
+    // as hidden inline-code aliases makes the idiom just work: `-c`/`--cmd`
+    // implies bash, `-e`/`--eval` implies node, and a leading `bash`/`python`/
+    // `node` token still pins the language (so `python -c '...'` runs as python).
+    .addOption(new Option('-c, --cmd <code>', 'Inline code (bash idiom: `sandbox run bash -c "<code>"`)').hideHelp())
+    .addOption(new Option('-e, --eval <code>', 'Inline code (node idiom: `sandbox run node -e "<code>"`)').hideHelp())
+    .option('--timeout <seconds>', 'Execution timeout. Bare number = seconds; or pass an explicit unit that means the same on both this and `page eval --timeout`, e.g. --timeout 90s.', '30')
     .option('--input <path>', 'Narrow to specific project files instead of auto-mirroring the whole tree (repeatable). Use this only for >1 GB projects or when you want surgical control.', (v, prev) => [...(prev ?? []), v])
     // Named "discard", not "no-sync": in Gipity vocabulary "sync" means the
     // local<->cloud file sync, so a no-sync spelling reads as "give me the file
@@ -214,6 +294,8 @@ Examples:
   $ gipity sandbox run --file build_report.py
   $ gipity sandbox run python build_report.py   # same thing, interpreter shorthand
   $ gipity sandbox run bash "echo hi; ffmpeg -version"   # inline, language pinned
+  $ gipity sandbox run bash -c "ffmpeg -version"         # the bash -c idiom also works
+  $ gipity sandbox run node -e "console.log(process.version)"  # and node -e
 
   # Surgical: only these files are mirrored in
   $ gipity sandbox run --language bash \\
@@ -242,13 +324,26 @@ GCC/Rust).
     let inlineCode;
     let filePath = opts.file;
     let langFromInterp;
-    // --code alias: fold it into the positional slot before the shape checks.
-    if (opts.code !== undefined) {
-        if (args.length) {
-            console.error(clrError('Pass the code once: either positionally or via --code, not both'));
+    // Inline code may arrive via a flag alias instead of the positional slot:
+    //   --code            language-agnostic (needs --language or an interpreter token)
+    //   --cmd / -c        the `bash -c '<code>'` idiom → implies bash
+    //   --eval / -e       the `node -e '<code>'` idiom → implies node
+    // Fold whichever was given into the positional slot before the shape checks,
+    // preserving a leading interpreter token (`python -c '...'` stays python).
+    const flagCode = opts.code ?? opts.cmd ?? opts.eval;
+    if (flagCode !== undefined) {
+        // The positional slot may legitimately hold ONLY a leading interpreter
+        // token that pins the language; anything more is a duplicate copy of the code.
+        const leadIsInterp = args.length === 1 && INTERPRETERS[args[0].toLowerCase()] !== undefined;
+        if (args.length > (leadIsInterp ? 1 : 0)) {
+            console.error(clrError('Pass the code once: either positionally or via --code/--cmd/-c/--eval/-e, not both'));
             process.exit(1);
         }
-        args = [opts.code];
+        const interp = leadIsInterp ? args[0]
+            : opts.cmd !== undefined ? 'bash'
+                : opts.eval !== undefined ? 'node'
+                    : undefined;
+        args = interp ? [interp, flagCode] : [flagCode];
     }
     if (args.length >= 2 && INTERPRETERS[args[0].toLowerCase()] !== undefined) {
         langFromInterp = INTERPRETERS[args[0].toLowerCase()];
@@ -267,7 +362,9 @@ GCC/Rust).
         process.exit(1);
     }
     if (inlineCode !== undefined && filePath) {
-        console.error(clrError('Pass either an inline <code> arg or --file <path>, not both'));
+        console.error(clrError('Pass the code ONE way, not both: an inline <code> arg OR --file <path>.'));
+        console.error(dim("  inline:  gipity sandbox run bash 'echo hi'"));
+        console.error(dim('  file:    gipity sandbox run --file script.sh'));
         process.exit(1);
     }
     if (inlineCode === undefined && !filePath) {
@@ -299,7 +396,10 @@ GCC/Rust).
     }
     // Args are good - now it's worth resolving (and announcing) the project.
     const { config } = await resolveProjectContext();
-    const timeout = parseInt(opts.timeout, 10);
+    // A bare number is native SECONDS; an explicit suffix (90s / 1500ms / 2m) is
+    // portable with `page eval --timeout` and converted to seconds here.
+    const durOpt = parseDuration(opts.timeout, 's');
+    const timeout = durOpt ? Math.max(1, Math.round(durOpt.value)) : parseInt(opts.timeout, 10);
     const cwd = resolveRelativeCwd();
     // A scratch path is never synced, so it can never reach the VFS the sandbox
     // mirrors from - `--input tmp/frame.png` would fail inside the container with
@@ -311,6 +411,31 @@ GCC/Rust).
         console.error(dim('  Stage inputs at a real project path (src/, docs/, assets/) and delete them afterward.'));
         process.exit(1);
     }
+    // Same trap, one step less obvious: a scratch file referenced as an INPUT
+    // from inside the code body (not via --input). The auto-mirror skips the
+    // scratch namespaces, so the container hits a bare "No such file" for a path
+    // the caller can plainly see on local disk. Catch it here, pre-sync, with the
+    // reason. We flag a reference only when that scratch file ACTUALLY EXISTS
+    // locally — which cleanly separates a staged input (must exist to be read)
+    // from a scratch OUTPUT target like `tmp/preview.png` (valid; doesn't exist
+    // yet, and outputs written under tmp/ come back on their own).
+    if (source) {
+        const scratchReads = scratchRefsInCode(source).filter((p) => shouldIgnore(p, SCRATCH_IGNORE)
+            && existsSync(resolve(process.cwd(), p))
+            // A previous run's OUTPUT lands locally, so on a re-run it exists -
+            // but a path written at its FIRST use (ffmpeg output, -o, >) is
+            // produced in the sandbox, so a later inspect (`ls`/`cat`) in the same
+            // script reads that copy, not the mirror. Only a genuine staged input
+            // read (first use isn't a write) is blocked.
+            && !isWriteTarget(source, p));
+        if (scratchReads.length) {
+            console.error(clrError(`Scratch files are never mirrored into the sandbox, so it can't read: ${scratchReads.join(', ')}`));
+            console.error(dim(`  ${SCRATCH_IGNORE.join(', ')} are ignored by sync, so the sandbox never sees them.`));
+            console.error(dim('  Stage the input at a real project path (src/, docs/, assets/) and delete it afterward.'));
+            console.error(dim('  (Writing OUTPUT under tmp/ is fine — scratch outputs come back to your local tmp/.)'));
+            process.exit(1);
+        }
+    }
     // Push local working-tree changes up before executing. The sandbox mirrors
     // the *server* (VFS), not the local cwd, so any input staged outside Claude's
     // Write/Edit auto-push hook - a Bash `cp`/`ffmpeg`/redirect, or any external
@@ -339,7 +464,7 @@ GCC/Rust).
     });
     const res = opts.json
         ? await doRun()
-        : await withSpinner('Running in sandbox…', doRun, { done: null });
+        : 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
@@ -407,6 +532,18 @@ GCC/Rust).
                 if (pulledLocal)
                     console.log(dim("Not pulled locally - run 'gipity sync' to fetch them."));
             }
+            // A sandbox output that lands directly at the project ROOT (a bare
+            // filename, no directory) is almost always a throwaway probe, not a
+            // real asset - real assets live under src/, functions/, assets/, etc.
+            // Root files sync and are picked up by the deploy `files` phase, so a
+            // stray one ships unless the caller remembers to delete it. Point at
+            // tmp/ (local-only, never synced or deployed) at the moment of use so
+            // the next probe never has to be hand-cleaned off a deployable path.
+            const rootStrays = [...onDisk, ...notOnDisk].filter((f) => !f.includes('/'));
+            if (rootStrays.length > 0) {
+                console.log(dim(`\nNote: ${rootStrays.join(', ')} landed at the project root and will deploy with the files phase.`));
+                console.log(dim('For a throwaway probe or fixture, write it under tmp/ instead - scratch outputs stay on local disk and never sync or deploy.'));
+            }
         }
         if (scratchWritten.length > 0) {
             console.log('\nScratch outputs (local only - never synced or deployed):');
@@ -418,7 +555,42 @@ GCC/Rust).
             for (const f of res.data.skippedOutputFiles)
                 console.log(dim(`${f}`));
         }
+        // Silent-failure guard: a command that exits 0 yet leaves a 0-byte output
+        // almost always failed silently - a broken ffmpeg filter, or an OOM the
+        // shell swallowed. Without this the only signal is an `ls -la` afterward,
+        // and the agent burns a turn inferring "the encode failed" from a file
+        // size. Name it at the moment it happens, for scratch (bytes returned
+        // inline) and synced outputs (stat on local disk) alike.
+        if (res.data.exitCode === 0) {
+            const emptyScratch = (res.data.scratchFiles ?? [])
+                .filter((f) => f.contentBase64.length === 0)
+                .map((f) => f.path.replace(/\\/g, '/'));
+            const root = getProjectRoot();
+            const emptyOutputs = pulledLocal && root
+                ? (res.data.outputFiles ?? []).filter((f) => {
+                    try {
+                        return statSync(resolve(root, f)).size === 0;
+                    }
+                    catch {
+                        return false;
+                    }
+                })
+                : [];
+            const empties = [...new Set([...emptyScratch, ...emptyOutputs])];
+            if (empties.length > 0) {
+                console.error(dim(`Note: ${empties.join(', ')} was written but is empty (0 bytes) - the command exited 0 but likely failed silently (a broken filter, or an out-of-memory kill the shell swallowed). Re-check the command, or shrink the job if it may have run out of memory.`));
+            }
+        }
         if (res.data.exitCode !== 0) {
+            // A process killed by a signal exits 128+signal. 137 (SIGKILL) on the
+            // sandbox is almost always the OS OOM-killer - the raw `/work/_run.sh:
+            // Killed` line the shell prints never says so, so a bare retry at the
+            // same size just OOMs again. Name it and point at the usual fix.
+            if (res.data.exitCode === 137) {
+                console.error(clrError('The sandbox process was killed (exit 137) - it ran out of memory.'));
+                console.error(dim('  Shrink the job: for ffmpeg, downscale (-vf scale=640:-2) and add -preset ultrafast;'));
+                console.error(dim('  for ImageMagick, lower -density/-resize. Process in smaller chunks if it still OOMs.'));
+            }
             // No "did you mean another language?" hint is needed: the language is now
             // always something the caller pinned, never a silent default we chose.
             process.exit(res.data.exitCode);

package/dist/commands/save.js

@@ -52,7 +52,7 @@ export const saveCommand = new Command('save')
     const doExport = () => downloadWithHeaders(`/projects/${config.projectGuid}/export`);
     const { buffer, headers } = opts.json
         ? await doExport()
-        : await withSpinner('Exporting…', doExport, { done: null });
+        : await withSpinner('Exporting...', doExport, { done: null });
     const filename = dispositionFilename(headers) ?? `${config.projectSlug}.gip`;
     let dest = path.resolve(output ?? filename);
     if (output && fs.existsSync(dest) && fs.statSync(dest).isDirectory()) {

package/dist/commands/secrets.js

@@ -34,7 +34,7 @@ secretsCommand
     }
     console.log(bold(`${res.data.length} ${scope} secret${res.data.length === 1 ? '' : 's'}:`));
     for (const s of res.data) {
-        const masked = s.preview ? muted(`…${s.preview}`) : muted('(hidden)');
+        const masked = s.preview ? muted(`...${s.preview}`) : muted('(hidden)');
         console.log(`  ${s.name}  ${masked}  ${muted(`updated ${new Date(s.updated_at).toLocaleDateString()}`)}`);
     }
 }));

package/dist/commands/service.js

@@ -21,12 +21,17 @@ const SERVICES = [
 ];
 export const serviceCommand = new Command('service')
     .description('Call an app service (llm, tts, image, transcribe, ...)')
-    .addHelpText('after', '\nCall a Gipity app service: LLM, image, music, TTS, and more.');
+    .addHelpText('after', '\nCall a Gipity app service: LLM, image, music, TTS, and more.\nPer-service docs: gipity skill read app-llm | app-tts | app-image | app-video | app-audio (transcribe, sound, music) | app-location');
 serviceCommand
     .command('list')
     .description('List callable app services')
-    .action(() => run('Services', async () => {
+    .option('--json', 'Output the service list as JSON')
+    .action((opts) => run('Services', async () => {
     requireConfig();
+    if (opts.json) {
+        console.log(JSON.stringify(SERVICES));
+        return;
+    }
     const width = SERVICES.reduce((m, s) => Math.max(m, s.name.length), 0);
     console.log('Call one with `gipity service call <name> \'{"json":"body"}\'`');
     console.log(muted('(GET endpoints like llm/models, tts/voices take --get and no body)'));

package/dist/commands/setup.js

@@ -19,8 +19,7 @@ import { Command } from 'commander';
 import { getAuth, sessionExpired, refreshTokenIfNeeded } from '../auth.js';
 import { interactiveLogin } from '../login-flow.js';
 import { runRelaySetup } from '../relay/onboarding.js';
-import * as relayState from '../relay/state.js';
-import { bold, brand, success, muted, error as clrError } from '../colors.js';
+import { bold, muted, error as clrError } from '../colors.js';
 export const connectCommand = new Command('connect')
     .alias('setup') // legacy name, kept working but not advertised
     .description('Connect this computer to gipity.ai so the web CLI can drive it (no project, no launch)')
@@ -46,11 +45,10 @@ export const connectCommand = new Command('connect')
         console.log('');
         // ── Step 2: Relay setup (always run — the user asked for it) ───────
         const enabled = await runRelaySetup({ mode: 'run-now' });
-        // ── Step 3: Done. No project, no Claude Code launch. ──────────────
+        // ── Step 3: Done. No project, no Claude Code launch. The shared flow
+        // already printed its own "Done!" line - just add the manage hint. ──
         if (enabled) {
-            const running = relayState.isRelayEnabled() && !relayState.isPaused();
-            console.log(`  ${success('Done')} — your relay ${running ? 'is running in the background' : 'is set up'} and will start with your computer.`);
-            console.log(`  ${muted('Open')} ${brand('gipity.ai')} ${muted('and start a chat to drive your coding agent here. Manage it with `gipity relay status`.')}`);
+            console.log(`  ${muted('Manage it anytime with `gipity relay status`.')}`);
         }
         else {
             console.log(`  ${muted('No relay set up. Run `gipity connect` again anytime, or `gipity build` to start building.')}`);

package/dist/commands/status.js

@@ -4,7 +4,7 @@ import { join, resolve } from 'path';
 import { homedir } from 'os';
 import { getAuth, sessionExpired } from '../auth.js';
 import { get, usingEnvToken, ApiError } from '../api.js';
-import { getConfig, liveUrl } from '../config.js';
+import { getConfig, liveUrl, resolveApiBase } from '../config.js';
 import { brand, success, warning, muted, error as clrError } from '../colors.js';
 import { GIPITY_PLUGIN_ID, GIPITY_MARKETPLACE_NAME, setupClaudeHooks, ensureGipityPlugin, ensureGipityPluginInstalled, userScopeInstallState } from '../setup.js';
 import { flushBugQueue } from '../bug-queue.js';
@@ -39,15 +39,20 @@ function checkGipityPlugin() {
     const stale = missing.length === 1 && missing[0] === 'install' && install.exists;
     return { missing, ok: missing.length === 0, stale };
 }
+/** `account` is the server's `account_slug` for the authenticated identity
+ *  (only populated on 'ok' - the /users/me call that proved the probe also
+ *  returns it) - used for the ownership cross-check against the locally
+ *  cached project (bug cli#S2: a wrong-account session used to read as
+ *  fully healthy until a later command 404'd). */
 async function probeAuth(loggedIn) {
     if (!loggedIn && !usingEnvToken())
-        return 'none';
+        return { state: 'none', account: null };
     if (!usingEnvToken() && sessionExpired())
-        return 'expired';
+        return { state: 'expired', account: null };
     // Cap the probe well below the API layer's 60s request timeout - status is
     // a diagnostic command and must answer fast even when the network is dark.
-    const timeout = new Promise(res => setTimeout(() => res('unreachable'), 5000).unref?.());
-    const call = get('/users/me').then(() => 'ok', (err) => (err instanceof ApiError && err.statusCode === 401 ? 'rejected' : 'unreachable'));
+    const timeout = new Promise(res => setTimeout(() => res({ state: 'unreachable', account: null }), 5000).unref?.());
+    const call = get('/users/me').then((res) => ({ state: 'ok', account: res.data?.accountSlug ?? null }), (err) => ({ state: (err instanceof ApiError && err.statusCode === 401 ? 'rejected' : 'unreachable'), account: null }));
     return Promise.race([call, timeout]);
 }
 // `whoami` is the name agents reach for first when they want the signed-in
@@ -71,6 +76,12 @@ export const statusCommand = new Command('status')
     // is empty, which is the common case, so this stays a no-op most runs.
     const queueDelivered = (auth && !sessionExpired()) ? await flushBugQueue().catch(() => 0) : 0;
     const probe = await probeAuth(!!auth);
+    // RBAC lets a project be shared to a collaborator whose own account
+    // legitimately differs from the project owner's - so this is advisory,
+    // never a hard error. Only meaningful once a live 'ok' call has actually
+    // returned an account to compare against config.accountSlug.
+    const accountMismatch = probe.state === 'ok' && !!config && !!probe.account && probe.account !== config.accountSlug;
+    const apiBaseInUse = resolveApiBase();
     if (opts.json) {
         console.log(JSON.stringify({
             project: config ? {
@@ -78,17 +89,21 @@ export const statusCommand = new Command('status')
                 slug: config.projectSlug,
                 account: config.accountSlug,
                 apiBase: config.apiBase,
+                apiBaseInUse,
                 url: liveUrl(config),
             } : null,
             // `valid` reflects the refresh token (the real session) - access
             // tokens auto-renew, so their expiry must not read as "invalid".
             // `probe` is what one live call just proved: 'rejected' means every
             // authenticated command will fail even though `valid` reads true.
+            // 'mismatch' overrides 'ok' when the live account isn't the one that
+            // owns this project - `valid` still reads true (the token IS valid).
             auth: (auth || usingEnvToken()) ? {
                 email: auth?.email,
+                account: probe.account,
                 source: usingEnvToken() ? 'agent-token' : 'session',
-                valid: usingEnvToken() ? probe !== 'rejected' : !sessionExpired(),
-                probe,
+                valid: usingEnvToken() ? probe.state !== 'rejected' : !sessionExpired(),
+                probe: accountMismatch ? 'mismatch' : probe.state,
             } : null,
             plugin: hookCheck,
         }, null, 2));
@@ -102,28 +117,42 @@ export const statusCommand = new Command('status')
         console.log(`${muted('Account:')} ${config.accountSlug}`);
         console.log(`${muted('Live:')} ${liveUrl(config)}`);
         console.log(`${muted('API:')} ${config.apiBase}`);
+        // apiBase is only what THIS project recorded - resolveApiBase() is what
+        // every real request actually uses (it can diverge via GIPITY_API_BASE,
+        // --api-base, or a disallowed host being dropped to the default). Surface
+        // the divergence rather than silently trusting the recorded value.
+        if (apiBaseInUse !== config.apiBase) {
+            console.log(`${muted('API (in use):')} ${warning(apiBaseInUse)} ${muted('(overrides .gipity.json — GIPITY_API_BASE / --api-base / allowlist)')}`);
+        }
         if (config.agentGuid)
             console.log(`${muted('Agent:')} ${config.agentGuid}`);
     }
     if (usingEnvToken()) {
-        console.log(`${muted('Auth:')} ${probe === 'rejected'
+        console.log(`${muted('Auth:')} ${probe.state === 'rejected'
             ? warning('agent API token (GIPITY_TOKEN) rejected by the server — mint a new one: gipity skill read agent-deploy')
-            : success('agent API token (GIPITY_TOKEN)')}${probe === 'unreachable' ? ` ${muted('(unverified — API unreachable)')}` : ''}`);
+            : success('agent API token (GIPITY_TOKEN)')}${probe.state === 'unreachable' ? ` ${muted('(unverified — API unreachable)')}` : ''}`);
     }
     else if (!auth) {
         console.log(`${muted('Auth:')} ${warning('not logged in. Run: gipity login')}`);
     }
-    else if (probe === 'expired') {
+    else if (probe.state === 'expired') {
         console.log(`${muted('Auth:')} ${warning(`session expired for ${auth.email}. Run: gipity login (headless/CI: set GIPITY_TOKEN — gipity skill read agent-deploy)`)}`);
     }
-    else if (probe === 'rejected') {
+    else if (probe.state === 'rejected') {
         // Locally fresh but the server says no (refresh token rotated away or
         // revoked). Without the live probe this printed a green identity while
         // every authenticated command failed.
         console.log(`${muted('Auth:')} ${warning(`session for ${auth.email} was rejected by the server. Run: gipity login (headless/CI: set GIPITY_TOKEN — gipity skill read agent-deploy)`)}`);
     }
     else {
-        console.log(`${muted('Auth:')} ${success(auth.email)}${probe === 'unreachable' ? ` ${muted('(unverified — API unreachable)')}` : ''}`);
+        console.log(`${muted('Auth:')} ${success(auth.email)}${probe.state === 'unreachable' ? ` ${muted('(unverified — API unreachable)')}` : ''}`);
+    }
+    // Source-independent (session or GIPITY_TOKEN): a mismatch under an agent
+    // token is the same wrong-account class and must not be hidden inside the
+    // cascade above, which only special-cases 'rejected' for that source.
+    if (accountMismatch) {
+        console.log(`${muted('Account:')} ${warning(`logged-in account (${probe.account}) differs from this project's account (${config.accountSlug}). If you didn't expect this you may be logged into the wrong account — run: gipity login`)}`);
+        console.log(muted('(If this project was shared with you via gipity rbac, this is expected.)'));
     }
     if (queueDelivered > 0) {
         console.log(`${muted('Bug queue:')} ${success(`delivered ${queueDelivered} queued bug report${queueDelivered === 1 ? '' : 's'}`)}`);

package/dist/commands/storage.js

@@ -50,12 +50,12 @@ function printUsage(d) {
         console.log(`${bold('By project')} ${muted(scope)}`);
         for (const p of d.projects) {
             const name = p.projectName ?? '(no project)';
-            row(name.length > 16 ? `${name.slice(0, 15)}…` : name, formatBytes(p.liveBytes), `${p.liveFiles.toLocaleString()} files`);
+            row(name.length > 16 ? `${name.slice(0, 13)}...` : name, formatBytes(p.liveBytes), `${p.liveFiles.toLocaleString()} files`);
         }
         if (hidden > 0) {
             const shownBytes = d.projects.reduce((n, p) => n + p.liveBytes, 0);
             const shownFiles = d.projects.reduce((n, p) => n + p.liveFiles, 0);
-            row(`…and ${hidden.toLocaleString()} more`, formatBytes(totals.liveBytes - shownBytes), `${(totals.liveFiles - shownFiles).toLocaleString()} files`);
+            row(`...and ${hidden.toLocaleString()} more`, formatBytes(totals.liveBytes - shownBytes), `${(totals.liveFiles - shownFiles).toLocaleString()} files`);
         }
     }
     const r = d.versionRetention;