gipity 1.0.420 → 1.0.422

package/dist/commands/deploy.js

@@ -80,11 +80,11 @@ export const deployCommand = new Command('deploy')
     const failedPhases = d.phases?.filter(p => p.status === 'failed') ?? [];
     if (failedPhases.length > 0) {
         // The database phase can fail on the account-wide database cap, whose
-        // server message ("Maximum of N databases reached. Drop one first.")
-        // names no command. The droppable databases live in OTHER projects, so
-        // the default project-scoped `gipity db list` shows nothing — point the
-        // caller straight at the account-wide list + drop path so they don't
-        // dead-end (or reach for raw DB access) to free a slot.
+        // server message ("Maximum of N databases reached (you have N). Drop one
+        // first.") names no command. The droppable databases live in OTHER
+        // projects, so the default project-scoped `gipity db list` shows nothing
+        // — point the caller straight at the account-wide list + drop path so
+        // they don't dead-end (or reach for raw DB access) to free a slot.
         if (failedPhases.some(p => /databases? reached|database (cap|limit)/i.test(p.summary))) {
             console.log('');
             console.log(muted('Free a slot under the account database cap:'));

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';
@@ -225,12 +226,23 @@ GCC/Rust).
     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/knowledge.js

@@ -154,7 +154,7 @@ To keep local-only material (research clones, scratch data, vendored references)
 Deploy is opt-in, not opt-out: the \`files\` phase uploads **only** what's under \`src/\` (plus \`functions/\` and \`migrations/\` as backend, not CDN files). Anything else at the project root is kept but never deployed. Put each kind of file in the right bucket so scratch and reference material can't bloat a deploy:
 
 - **\`src/\`** - the app itself. Synced **and** deployed to the CDN. Only app code, assets, and pages belong here.
-- **\`tmp/\`** - ephemeral scratch: file conversions, intermediate outputs, design staging. **Already ignored** (never synced, never deployed) - the one place to do throwaway work. Use this single root. (\`*_tmp/\` dirs and \`.gipityscratch/\` are auto-ignored too, as a safety net, so legacy scattered scratch like \`_vsd_tmp/\` can't leak - but write new scratch to \`tmp/\`, not scattered dirs.)
+- **\`tmp/\`** - ephemeral scratch: file conversions, intermediate outputs, design staging. **Already ignored** (never synced, never deployed) - the one place to do throwaway work. Use this single root. (\`*_tmp/\` dirs and \`.gipityscratch/\` are auto-ignored too, as a safety net, so legacy scattered scratch like \`_vsd_tmp/\` can't leak - but write new scratch to \`tmp/\`, not scattered dirs.) Because it never syncs, \`tmp/\` is also never mirrored into the sandbox: **don't stage \`gipity sandbox run\` inputs here** - the sandbox won't see them. Stage inputs under \`src/\`/\`docs/\` and delete them after.
 - **\`docs/\`** - reference material you want to keep: UI/architecture diagrams, design decks, notes, ADRs. Synced and versioned on the server (backed up, rollback-able) but **never deployed**, because it's outside \`src/\`. This is the home for "keep forever, don't ship" artifacts.
 - **\`tests/\`** - \`*.test.js\` suites. Synced, run by \`gipity test\`, never deployed. \`gipity test list [path]\` lists the test files (and what a filter selects) without running them.
 

package/dist/sync.js

@@ -1179,6 +1179,9 @@ async function syncInner(projectGuid, root, ignore, opts, interactive) {
     // turns "files we failed to fetch" into "delete those files." Skip ALL deletes
     // this run and let a clean sync replan them once the pull succeeds.
     let deletesSkippedIncomplete = 0;
+    // Directories that lost a file to a delete-local this run. Only these are
+    // candidates for empty-dir cleanup — see cleanupEmptyDirs.
+    const dirsTouchedByDelete = new Set();
     for (const a of plannedToApply) {
         if (downloadIncomplete && (a.kind === 'delete-local' || a.kind === 'delete-remote')) {
             deletesSkippedIncomplete++;
@@ -1199,11 +1202,13 @@ async function syncInner(projectGuid, root, ignore, opts, interactive) {
             }
             try {
                 unlinkSync(full);
+                dirsTouchedByDelete.add(dirname(full));
                 delete baseline.files[a.path];
                 applied++;
             }
             catch (err) {
                 if (err.code === 'ENOENT') {
+                    dirsTouchedByDelete.add(dirname(full));
                     delete baseline.files[a.path];
                     applied++;
                 }
@@ -1273,8 +1278,8 @@ async function syncInner(projectGuid, root, ignore, opts, interactive) {
         errors.push(`Skipped ${deletesSkippedIncomplete} deletion${deletesSkippedIncomplete === 1 ? '' : 's'} because the download was incomplete - ` +
             `nothing was deleted. Re-run \`gipity sync\` once the pull finishes to apply any real deletions.`);
     }
-    // Clean up empty local directories after delete-local actions.
-    cleanupEmptyDirs(root, config.ignore);
+    // Clean up local directories emptied by this run's delete-local actions.
+    cleanupEmptyDirs(root, dirsTouchedByDelete);
     // Adopt agreed content-match state into the baseline, and prune stale entries.
     // `plan()` is pure, so it emits these as lists and the mutation happens here.
     // Adopting (FIX M1) makes sync convergent - a locally+remotely-identical file
@@ -1296,43 +1301,51 @@ async function syncInner(projectGuid, root, ignore, opts, interactive) {
         deferredDeletes: skippedByGuard,
     };
 }
-function cleanupEmptyDirs(root, ignorePatterns) {
-    function walk(dir) {
-        let entries;
+/**
+ * Remove directories that THIS run's delete-local actions left empty.
+ *
+ * Scoped to `emptiedDirs` on purpose. The previous version walked the whole
+ * project tree and removed every empty directory it found, which also deleted
+ * ones the user had just created: `mkdir -p src/images/monsters` followed a few
+ * tool calls later by a write into it failed with ENOENT, because a full sync
+ * had pruned the directory in between. The VFS stores files only, so a freshly
+ * created empty directory has no remote counterpart and looked indistinguishable
+ * from "deleted on the server."
+ *
+ * Pruning only where sync actually removed a file preserves the original intent
+ * — don't leave an empty husk behind after a remote delete — while leaving every
+ * other directory alone. An unrelated empty directory is now simply never
+ * sync's business.
+ *
+ * Prunes upward, since removing `a/b/c` can leave `a/b` empty too. A directory
+ * holding only sync-ignored entries is not empty on disk, so it survives — the
+ * same outcome the old ignore-aware walk produced.
+ */
+function cleanupEmptyDirs(root, emptiedDirs) {
+    const isEmpty = (dir) => {
         try {
-            entries = readdirSync(dir, { withFileTypes: true });
+            return readdirSync(dir).length === 0;
         }
         catch {
             return false;
         }
-        let kept = 0;
-        for (const entry of entries) {
-            const full = join(dir, entry.name);
-            const rel = relative(root, full).replace(/\\/g, '/');
-            if (shouldIgnore(rel, ignorePatterns)) {
-                kept++;
-                continue;
-            }
-            if (entry.isDirectory()) {
-                if (!walk(full))
-                    kept++;
-            }
-            else {
-                kept++;
-            }
-        }
-        if (kept === 0 && dir !== root) {
+    };
+    // `emptiedDirs` holds dirname()s of resolveInRoot() results, which are
+    // lexically resolved — resolve the root the same way, or the containment
+    // guard below never matches and nothing is ever pruned.
+    const rootResolved = resolve(root);
+    for (const start of emptiedDirs) {
+        let dir = resolve(start);
+        while (dir !== rootResolved && dir.startsWith(rootResolved + sep) && isEmpty(dir)) {
             try {
                 rmdirSync(dir);
-                return true;
             }
             catch {
-                return false;
+                break;
             }
+            dir = dirname(dir);
         }
-        return false;
     }
-    walk(root);
 }
 // ─── Single-file push (used by `gipity push <file>`) ───────────
 export async function pushFile(filePath) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gipity",
-  "version": "1.0.420",
+  "version": "1.0.422",
   "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",