gipity 1.0.420 → 1.0.424

package/dist/commands/push.js

@@ -3,13 +3,13 @@ import { resolve } from 'path';
 import { pushFile } from '../sync.js';
 import { error as clrError, success } from '../colors.js';
 export const pushCommand = new Command('push')
-    .description('Push a file')
-    .argument('<file>', 'File path to push')
+    .description('Push one or more files')
+    .argument('<files...>', 'File path(s) to push')
     .option('--quiet', 'Suppress output')
     .option('--background', 'Fork and exit immediately')
-    .action(async (file, opts) => {
+    .action(async (files, opts) => {
     try {
-        const fullPath = resolve(file);
+        const fullPaths = files.map(f => resolve(f));
         if (opts.background) {
             // Detach a background `gipity push` and exit immediately. Goes through
             // spawnCommand (Node binary running our own entry script - no IPC
@@ -17,16 +17,21 @@ export const pushCommand = new Command('push')
             // `windowsHide: true` so the detached child never flashes a console
             // window on Windows.
             const { spawnCommand } = await import('../platform.js');
-            const child = spawnCommand(process.execPath, [process.argv[1], 'push', fullPath, '--quiet'], {
+            const child = spawnCommand(process.execPath, [process.argv[1], 'push', ...fullPaths, '--quiet'], {
                 detached: true,
                 stdio: 'ignore',
             });
             child.unref();
             return;
         }
-        await pushFile(fullPath);
+        // Sequential on purpose: pushFile takes the per-project sync lock, so
+        // parallel pushes would just contend on it. One process pushing N files
+        // still beats the old N processes × N lock acquisitions.
+        for (const fullPath of fullPaths) {
+            await pushFile(fullPath);
+        }
         if (!opts.quiet) {
-            console.log(success(`Pushed ${file}`));
+            console.log(success(files.length === 1 ? `Pushed ${files[0]}` : `Pushed ${files.length} files`));
         }
     }
     catch (err) {

package/dist/commands/sandbox.js

@@ -2,7 +2,8 @@ import { Command } from 'commander';
 import { readFileSync, existsSync, statSync } from 'fs';
 import { dirname, extname, relative } from 'path';
 import { post } from '../api.js';
-import { resolveProjectContext, getConfigPath } from '../config.js';
+import { resolveProjectContext, getConfigPath, shouldIgnore } from '../config.js';
+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';
@@ -34,19 +35,57 @@ const PIN_LANGUAGE_HELP = [
     '  gipity sandbox run --language bash "<code>" # explicit flag (js | py | bash)',
     '  gipity sandbox run --file script.sh         # inferred from the file extension',
 ].join('\n');
+// Words that open a code statement, not a command line. A single positional
+// starting with one of these is a JS/Python snippet whose language we must not
+// guess (see resolveLanguage) - everything here is either invalid in bash or,
+// worse, VALID in bash with a different meaning (`export FOO=1`, `for ...`).
+const CODE_OPENERS = new Set([
+    'const', 'let', 'var', 'function', 'async', 'await', 'import', 'export',
+    'console', 'require', 'print', 'def', 'class', 'lambda', 'from', 'return',
+    'for', 'while', 'if', 'try', 'with',
+]);
+/**
+ * True when a bare inline string is unmistakably a shell COMMAND LINE
+ * (`node tests/game.test.js`, `ls -la`, `ffmpeg -i in.mp4 out.gif`) rather
+ * than a code snippet. Deliberately conservative: one line, starts with a
+ * plain command word (no parens/quotes/operators in it), not a code opener,
+ * not an assignment (`x = 1` is Python-or-bash-ambiguous). Anything that
+ * fails these checks still goes through the explicit-pin error below.
+ */
+export function looksLikeShellCommand(code) {
+    if (code.includes('\n'))
+        return false;
+    const m = /^([A-Za-z0-9_.~/-]+)(\s|$)/.exec(code.trim());
+    if (!m)
+        return false;
+    const token = m[1].toLowerCase();
+    if (CODE_OPENERS.has(token))
+        return false;
+    if (/^\s*[A-Za-z_][A-Za-z0-9_]*\s*=/.test(code))
+        return false; // assignment
+    // A lone bare word (`foo`) is as likely a typo as a command; require either
+    // arguments after the word or a path-shaped word (`./build.sh`, `bin/run`).
+    return /\s\S/.test(code.trim()) || token.includes('/');
+}
 /**
  * Resolve the language from an explicit signal, or exit.
  *
- * Precedence: interpreter token > --language > --file extension.
+ * Precedence: interpreter token > --language > --file extension > the
+ * command-line heuristic above (bash).
  *
- * There is no default. js/python/bash are mutually exclusive, and plenty of
- * snippets parse as more than one of them (`x = 1`, `a[0]`, `foo()`), so any
- * default silently runs some fraction of input in the wrong interpreter. The old
- * behavior defaulted to JavaScript, which meant a shell one-liner ran as JS and
- * died with a Node `SyntaxError` at `/work/_run.js` - after paying for a project
- * sync and a server round trip. Failing here instead costs nothing and says what
- * to type. (`docs/skills/sandbox-tools.md` used to carry a hand-written "always
- * pin the language" warning to work around this; the CLI enforces it now.)
+ * Beyond that there is no default. js/python/bash are mutually exclusive, and
+ * plenty of snippets parse as more than one of them (`x = 1`, `a[0]`, `foo()`),
+ * so a blanket default silently runs some fraction of input in the wrong
+ * interpreter. The old behavior defaulted to JavaScript, which meant a shell
+ * one-liner ran as JS and died with a Node `SyntaxError` at `/work/_run.js` -
+ * after paying for a project sync and a server round trip. The one shape we DO
+ * default is the unambiguous command line (`gipity sandbox run "node
+ * tests/game.test.js"`): it was the single most common rejected invocation,
+ * the CLI had everything it needed to run it, and no code snippet matches the
+ * heuristic. Ambiguous snippets still fail here, costing nothing and saying
+ * what to type. (`docs/skills/sandbox-tools.md` used to carry a hand-written
+ * "always pin the language" warning to work around this; the CLI enforces it
+ * now.)
  */
 export function resolveLanguage(opts) {
     const explicit = opts.langFromInterp
@@ -67,6 +106,8 @@ export function resolveLanguage(opts) {
         console.error(dim(`Pass --language explicitly:\n  gipity sandbox run --language py --file ${opts.filePath}`));
         process.exit(1);
     }
+    if (opts.inlineCode && looksLikeShellCommand(opts.inlineCode))
+        return 'bash';
     console.error(clrError('No language specified for inline code.'));
     console.error(dim(`Pin it one of three ways:\n${PIN_LANGUAGE_HELP}`));
     process.exit(1);
@@ -216,21 +257,33 @@ GCC/Rust).
             process.exit(1);
         }
     }
-    // Language precedence: interpreter token > --language > file extension.
-    // There is deliberately no fallback: resolveLanguage() exits when nothing
-    // pinned one, rather than guessing. This runs BEFORE the project sync and the
-    // server round trip below, so a missing language costs nothing but the message.
-    const language = resolveLanguage({ langFromInterp, langOpt: opts.language, filePath });
+    // Language precedence: interpreter token > --language > file extension >
+    // unambiguous-command-line heuristic (bash). resolveLanguage() exits when
+    // nothing pins one and the input isn't command-shaped, rather than guessing.
+    // This runs BEFORE the project sync and the server round trip below, so a
+    // missing language costs nothing but the message.
+    const language = resolveLanguage({ langFromInterp, langOpt: opts.language, filePath, inlineCode });
     // Args are good - now it's worth resolving (and announcing) the project.
     const { config } = await resolveProjectContext();
     const timeout = 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
+    // a bare "no such file". Catch it here, where we can say why.
+    const scratchInputs = (opts.input ?? []).filter((p) => shouldIgnore(p.replace(/\\/g, '/').replace(/^\.\//, ''), SCRATCH_IGNORE));
+    if (scratchInputs.length) {
+        console.error(clrError(`Scratch paths are never mirrored into the sandbox: ${scratchInputs.join(', ')}`));
+        console.error(dim(`  ${SCRATCH_IGNORE.join(', ')} are ignored by sync, so the sandbox never sees them.`));
+        console.error(dim('  Stage inputs at a real project path (src/, docs/, assets/) and delete them afterward.'));
+        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
     // process - would otherwise be invisible to the run and the first invocation
     // would silently miss its inputs. Syncing first makes the auto-mirror reflect
-    // local state regardless of how files got there ("no manual copy needed").
+    // local state however files got there - with the one exception of the scratch
+    // namespaces above, which sync ignores and so the mirror never carries.
     // 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()) {

package/dist/commands/storage.js

@@ -38,12 +38,25 @@ function printUsage(d) {
     row('Dedup saved', formatBytes(s.dedupSavedBytes), `${s.dedupedObjects.toLocaleString()} shared`);
     row('Billed', formatBytes(s.physicalBytes), 'versions kept, dedup applied');
     if (d.projects.length > 0) {
+        // The server returns only the biggest projects. Say so, and account for the
+        // rest - a list that looks exhaustive but isn't sends people hunting for
+        // space in the wrong place.
+        const totals = d.projectTotals;
+        const hidden = totals.count - d.projects.length;
         console.log('');
-        console.log(`${bold('By project')} ${muted('(live files only)')}`);
+        const scope = hidden > 0
+            ? `(top ${d.projects.length} of ${totals.count.toLocaleString()}, live files only)`
+            : '(live files only)';
+        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`);
         }
+        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`);
+        }
     }
     const r = d.versionRetention;
     console.log('');

package/dist/commands/test.js

@@ -178,6 +178,19 @@ export const testCommand = new Command('test')
         console.log(clrError(`Run failed: ${data.errorMessage}`));
         console.log('');
     }
+    // Failures recap. Results stream incrementally above, but agents usually
+    // read this output through a `tail` window, so anything printed early is
+    // lost - restate every failure (name + assertion message) right before
+    // the summary, where it's guaranteed to survive truncation from the top.
+    if (data.failed > 0) {
+        console.log(clrError('Failures:'));
+        for (const r of data.results.filter(r => r.status === 'failed')) {
+            const where = r.path ? `${r.path}/` : '';
+            console.log(`  ${statusIcon('failed')} ${where}${r.name || '(unnamed test - the file may have crashed outside a test)'}`);
+            console.log(`      ${clrError(r.error || `(no assertion message recorded - inspect with: gipity test status ${runGuid} --json)`)}`);
+        }
+        console.log('');
+    }
     // Summary
     const parts = [];
     if (data.passed > 0)

package/dist/helpers/sync.js

@@ -1,7 +1,7 @@
 /**
  * sync.ts - Shared sync-before-action helper.
  */
-import { sync } from '../sync.js';
+import { sync, isLocalTreeClean } from '../sync.js';
 import { muted, error as clrError } from '../colors.js';
 import { createProgressReporter } from '../progress.js';
 /**
@@ -15,6 +15,13 @@ import { createProgressReporter } from '../progress.js';
 export async function syncBeforeAction(opts) {
     if (opts.sync === false)
         return;
+    // Nothing changed locally since the last sync → nothing to push, and the
+    // action (deploy etc.) reads server-side state anyway. Skip the whole sync
+    // round trip. The probe is local-only stat checks and conservative: any
+    // doubt (size/mtime moved, never synced, no baseline) falls through to a
+    // real sync. `--force` always takes the full path.
+    if (!opts.force && isLocalTreeClean())
+        return;
     // 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).