gipity 1.1.3 → 1.1.4

package/dist/knowledge.js

@@ -37,12 +37,10 @@ Kits are reusable building blocks added to an existing app, not whole templates
     - \`gipity add chatbot\` - Drop-in chatbot - configurable persona, scope guardrails, static knowledge (20k budget), streaming responses. Headless engine + bubble widget; bring your own UI if you want. Works in any app.
     - \`gipity add audio-align\` - Audio + lyrics -> word-level timing JSON. Demucs vocal isolation + MMS_FA forced alignment, runs as a Modal L4 GPU job (~$0.01 per 3-min song). For karaoke captions, subtitling, language learning, dubbing alignment.
     - \`gipity add i18n\` - Multi-language for web apps - language picker, locale persistence, RTL, plural/translation lookup. Scaffolds src/js/strings.js and wires it up; move your copy there and read it with t('key'). Web only.
-    - \`gipity add records\` - Registry-driven records: declare objects/fields as data, get generic CRUD functions with validation, full-text search, soft delete, ACTOR provenance, and an audit event spine - every write is transactional (row + event). Field types include relations ({id,label}), currency, emails/phones/links composites. Ships backend functions + migrations. Needs a database (web-fullstack/api template). See the \`app-records\` skill.
-    - \`gipity add views\` - Generic UI over records-kit objects: sortable/filterable table with full-text search, create/edit/delete forms with type-appropriate widgets, kanban board with drag-to-update. Renders entirely from the field registry - zero per-object UI code. Requires the records kit. See the \`app-records\` skill.
-    - \`gipity add agent-api\` - Make your app agent-operable: named API keys (kit_api_keys) let agents and scripts write through the records kit's single write path with AGENT/API actor attribution - machine writes land on the same audit spine as human edits. Requires the records kit. See the \`app-records\` skill.
     - \`gipity add contacts\` - Source-agnostic contact data layer for lead-gen/CRM apps: import people from LinkedIn CSV + Gmail + pasted lists, resolve duplicates into one person while keeping EVERY value from every source with provenance (multi-valued attributes, never overwrites). Exact email/URL auto-merge; fuzzy name+company goes to a human merge-review queue (reversible). Re-imports detect job changes and emit signals. User-definable tags, full-text search, and a transactional event spine. Ships backend functions + migrations. Needs a database (web-fullstack/api template).
     - \`gipity add stripe\` - Charge your app's end-users for one-time purchases and subscriptions via Stripe. Owner connects their own Stripe account through Gipity-hosted onboarding (no API keys to paste); money lands in their account, Gipity takes a small platform fee. Ships a buy-button / pricing component, a subscription-status helper for gating UI, a webhook-verified fulfillment function, and the payments/subscriptions tables. The platform brokers checkout + signature-verified webhooks. Needs a database (web-fullstack/api template).
-    - \`gipity add notify\` - Web push notifications for any web app, including iOS home-screen web apps (iOS 16.4+). The platform owns the VAPID keys, encryption, and delivery — no keys to paste, no crypto, no server. Ships a <gipity-notify-button>, a service worker, and a PWA manifest; the device subscribes itself and self-heals stale subscriptions. Send from a function with the injected notify() service (one flat credit per send, owner-billed) or test with \`gipity notify test\`. Works in any template — no database required.`;
+    - \`gipity add notify\` - Web push notifications for any web app, including iOS home-screen web apps (iOS 16.4+). The platform owns the VAPID keys, encryption, and delivery — no keys to paste, no crypto, no server. Ships a <gipity-notify-button>, a service worker, and a PWA manifest; the device subscribes itself and self-heals stale subscriptions. Send from a function with the injected notify() service (one flat credit per send, owner-billed) or test with \`gipity notify test\`. Works in any template — no database required.
+    - \`gipity add servicenow\` - Use ServiceNow tables as a data source: OAuth (client-credentials) authenticated polling pull into a local Postgres mirror (sn_records, any table, configurable), plus write-back into ServiceNow via the Table API. Optional real-time sync layers a ServiceNow Business Rule + Script Include on top, pushing changes to a webhook the instant they happen. Ships a cron workflow for the pull cycle, sn-pull/sn-write/sn-webhook functions, and setup scripts that automate the ServiceNow-side configuration. Needs a database (web-fullstack/api template).`;
 export const SKILLS_CONTENT = `# Gipity Integration
 
 Gipity is the cloud platform your project runs on - hosting, databases, deployment, file storage, code execution, workflows, and monitoring. Gip is the cloud agent that runs on Gipity.
@@ -155,7 +153,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.) 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.
+- **\`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. Leave scratch files where they are when you're done; there's nothing to clean up (no \`rm\` turn) - they're invisible to sync and deploy. (\`*_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.
 
@@ -171,7 +169,7 @@ App services skills (load before calling \`/services/*\` endpoints):
 - \`app-audio\` - sound effects, music, transcription
 - \`app-auth\` - sign in with Gipity, popup vs redirect
 - \`app-files\` - uploads, variants, file listing
-- \`app-image\` - text-to-image only (no input image / editing); providers, sizes, aspect ratios
+- \`app-image\` - text-to-image AND instruction editing (pass \`images\` to edit an uploaded photo); providers, sizes, aspect ratios
 - \`app-llm\` - chat completions, streaming, image input
 - \`app-location\` - user location & reverse geocoding for deployed apps (first-party - no third-party geocoder)
 - \`app-notify\` - web push notifications for deployed apps (incl. iOS home-screen web apps) - notify kit + injected notify() service, platform owns the keys
@@ -194,7 +192,6 @@ App development skills:
 - \`web-ui-patterns\` - default Gipity look (theme tokens) + web UI recipes - feeds, copy-to-clipboard
 
 Kit skills (reusable building blocks - \`gipity add <kit>\`):
-- \`app-records\` - the records + views kits: registry-driven CRUD with search + audit history, and generated tables/kanban/forms (gipity add records)
 - \`audio-align\` - the audio-align kit: forced alignment of audio + lyrics into word-level timing JSON
 - \`chatbot\` - the chatbot kit: persona + scope guardrails + static knowledge, bubble widget or headless engine
 

package/dist/updater/bootstrap.js

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { LOCAL_DIR, LOCAL_ENTRY, LOCAL_PKG_DIR, writeState, readState } from './state.js';
-import { resolveCommand, spawnSyncCommand } from '../platform.js';
+import { npmInstallGipity, isWedged, resetLocalTree, acquireUpdateLock, releaseUpdateLock } from './install.js';
 export function isBootstrapped() {
     return existsSync(LOCAL_ENTRY);
 }
@@ -20,28 +20,39 @@ export function bootstrap(version, quiet = false) {
     if (!existsSync(pkgJsonPath)) {
         writeFileSync(pkgJsonPath, JSON.stringify({ name: 'gipity-local', private: true, version: '0.0.0' }, null, 2));
     }
+    if (!acquireUpdateLock()) {
+        // A background updater is mid-install; run from the current build now and
+        // pick up the local install on a later invocation.
+        if (!quiet)
+            process.stderr.write(`gipity: another update is in progress - using the currently installed build.\n`);
+        return false;
+    }
     if (!quiet)
         process.stderr.write(`Setting up gipity local install at ~/.gipity/local (one-time)...\n`);
-    // --ignore-scripts: don't run install lifecycle hooks (gipity ships
-    // precompiled, deps need no build), so a compromised package can't execute
-    // code during this self-managed install.
-    const res = spawnSyncCommand(resolveCommand('npm'), ['install', '--no-audit', '--no-fund', '--ignore-scripts', `gipity@${version}`], {
-        cwd: LOCAL_DIR,
-        stdio: ['ignore', 'pipe', 'pipe'],
-        encoding: 'utf-8',
-    });
-    if (res.status !== 0 || !existsSync(LOCAL_ENTRY)) {
+    let res;
+    try {
+        res = npmInstallGipity(version);
+        if (!res.ok && !res.spawnError && isWedged(res.stderr)) {
+            // Interrupted-install corruption fails every npm run in the dir forever;
+            // wipe the tree and retry once.
+            resetLocalTree();
+            res = npmInstallGipity(version);
+        }
+    }
+    finally {
+        releaseUpdateLock();
+    }
+    if (!res.ok) {
         if (!quiet) {
-            const stderr = (res.stderr || '').toString();
-            const notPublished = /E404|No matching version|notarget/i.test(stderr);
+            const notPublished = /E404|No matching version|notarget/i.test(res.stderr);
             if (notPublished) {
                 process.stderr.write(`gipity v${version} is not yet published to npm - using the currently installed build.\n`);
             }
             else {
-                // res.error (e.g. ENOENT when npm can't be launched) carries the real
-                // cause; res.status is null in that case, so prefer the error message.
-                const firstLine = stderr.split('\n').map(l => l.trim()).find(l => l.length > 0)
-                    || (res.error ? res.error.message : `npm exit ${res.status}`);
+                // res.spawnError (e.g. ENOENT when npm can't be launched) carries the
+                // real cause; res.status is null in that case, so prefer its message.
+                const firstLine = res.stderr.split('\n').map(l => l.trim()).find(l => l.length > 0)
+                    || (res.spawnError ? res.spawnError.message : `npm exit ${res.status}`);
                 const reason = firstLine.length > 160 ? firstLine.slice(0, 157) + '...' : firstLine;
                 process.stderr.write(`gipity: could not set up local install (${reason}). Using the currently installed build.\n`);
             }

package/dist/updater/check.js

@@ -3,7 +3,7 @@ import { createRequire as __cliCreateRequire } from 'module';
 const require = __cliCreateRequire(import.meta.url);
 
 // src/updater/check.ts
-import { appendFileSync, existsSync as existsSync2 } from "fs";
+import { appendFileSync } from "fs";
 
 // src/updater/state.ts
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
@@ -55,6 +55,10 @@ function updatesDisabled() {
   return { disabled: false };
 }
 
+// src/updater/install.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, rmSync, statSync, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+import { dirname, join as join2 } from "path";
+
 // src/platform.ts
 import { execSync, spawn, spawnSync } from "child_process";
 function resolveCommand(cmd) {
@@ -83,6 +87,56 @@ function spawnSyncCommand(cmd, args = [], options = {}) {
   return spawnSync(cmd, [...args], { windowsHide: true, ...options });
 }
 
+// src/updater/install.ts
+var UPDATE_LOCK = join2(GIPITY_DIR, "update.lock");
+var LOCK_STALE_MS = 10 * 60 * 1e3;
+function npmInstallGipity(version) {
+  const res = spawnSyncCommand(resolveCommand("npm"), ["install", "--no-audit", "--no-fund", "--ignore-scripts", `gipity@${version}`], {
+    cwd: LOCAL_DIR,
+    stdio: ["ignore", "ignore", "pipe"],
+    encoding: "utf-8"
+  });
+  return {
+    ok: res.status === 0 && existsSync2(LOCAL_ENTRY),
+    status: res.status,
+    stderr: (res.stderr || "").toString(),
+    spawnError: res.error
+  };
+}
+var WEDGE_CODES = /\b(ENOTEMPTY|EEXIST|ENOTDIR|EISDIR|EJSONPARSE)\b/;
+function isWedged(stderr) {
+  return WEDGE_CODES.test(stderr);
+}
+function resetLocalTree(dir = LOCAL_DIR) {
+  mkdirSync2(dir, { recursive: true });
+  rmSync(join2(dir, "node_modules"), { recursive: true, force: true });
+  rmSync(join2(dir, "package-lock.json"), { force: true });
+  writeFileSync2(join2(dir, "package.json"), JSON.stringify({ name: "gipity-local", private: true, version: "0.0.0" }, null, 2));
+}
+function acquireUpdateLock(lockPath = UPDATE_LOCK) {
+  mkdirSync2(dirname(lockPath), { recursive: true });
+  try {
+    writeFileSync2(lockPath, String(process.pid), { flag: "wx" });
+    return true;
+  } catch {
+    try {
+      if (Date.now() - statSync(lockPath).mtimeMs > LOCK_STALE_MS) {
+        unlinkSync(lockPath);
+        writeFileSync2(lockPath, String(process.pid), { flag: "wx" });
+        return true;
+      }
+    } catch {
+    }
+    return false;
+  }
+}
+function releaseUpdateLock(lockPath = UPDATE_LOCK) {
+  try {
+    unlinkSync(lockPath);
+  } catch {
+  }
+}
+
 // src/updater/check.ts
 var CHECK_INTERVAL_MS = 4 * 60 * 60 * 1e3;
 function log(line) {
@@ -112,12 +166,24 @@ async function fetchLatestVersion() {
   return json.version;
 }
 function installVersion(version) {
-  const res = spawnSyncCommand(resolveCommand("npm"), ["install", "--silent", "--no-audit", "--no-fund", "--ignore-scripts", `gipity@${version}`], {
-    cwd: LOCAL_DIR,
-    stdio: "ignore"
-  });
-  if (res.error) log(`npm spawn failed: ${res.error.message}`);
-  return res.status === 0 && existsSync2(LOCAL_ENTRY);
+  let res = npmInstallGipity(version);
+  if (!res.ok && !res.spawnError && isWedged(res.stderr)) {
+    log(`wedged install tree detected; wiping node_modules and retrying:
+${res.stderr.trim().slice(-2e3)}`);
+    resetLocalTree();
+    res = npmInstallGipity(version);
+    if (res.ok) log("clean reinstall succeeded");
+  }
+  if (res.ok) return { ok: true };
+  if (res.spawnError) {
+    log(`npm spawn failed: ${res.spawnError.message}`);
+    return { ok: false, detail: res.spawnError.message };
+  }
+  if (res.stderr.trim()) log(`npm stderr (exit ${res.status}):
+${res.stderr.trim().slice(-2e3)}`);
+  if (res.status === 0) return { ok: false, detail: "npm succeeded but the installed package is missing dist/index.js" };
+  const firstLine = res.stderr.split("\n").map((l) => l.trim()).find((l) => l.length > 0) || `npm exit ${res.status}`;
+  return { ok: false, detail: firstLine.length > 160 ? firstLine.slice(0, 157) + "..." : firstLine };
 }
 async function runCheck(opts = {}) {
   const state = readState();
@@ -150,17 +216,27 @@ async function runCheck(opts = {}) {
     log(`up-to-date (current=${current}, latest=${latest})`);
     return { updated: false, reason: "up-to-date" };
   }
+  if (!acquireUpdateLock()) {
+    log("skipped: another update is already in progress");
+    return { updated: false, reason: "another update is already in progress" };
+  }
   log(`upgrading ${current} \u2192 ${latest}`);
-  const ok = installVersion(latest);
   state.lastCheckAt = Date.now();
-  if (ok) {
+  writeState(state);
+  let install;
+  try {
+    install = installVersion(latest);
+  } finally {
+    releaseUpdateLock();
+  }
+  if (install.ok) {
     state.installedVersion = latest;
     state.lastError = null;
     writeState(state);
     log(`upgraded to ${latest}`);
     return { updated: true, from: current, to: latest };
   }
-  state.lastError = `npm install gipity@${latest} failed`;
+  state.lastError = `npm install gipity@${latest} failed` + (install.detail ? `: ${install.detail}` : "");
   writeState(state);
   log(state.lastError);
   return { updated: false, reason: state.lastError };

package/dist/updater/install.js

@@ -0,0 +1,82 @@
+// Shared npm-install runner for the bootstrap and background-update paths,
+// plus recovery for the wedged-tree failure mode and a lock that keeps two
+// updaters out of ~/.gipity/local at the same time.
+import { existsSync, mkdirSync, rmSync, statSync, unlinkSync, writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { GIPITY_DIR, LOCAL_DIR, LOCAL_ENTRY } from './state.js';
+import { resolveCommand, spawnSyncCommand } from '../platform.js';
+export const UPDATE_LOCK = join(GIPITY_DIR, 'update.lock');
+const LOCK_STALE_MS = 10 * 60 * 1000;
+/**
+ * Run `npm install gipity@<version>` in ~/.gipity/local with stderr captured
+ * so failures carry the real cause (npm --silent suppresses even its error
+ * report, so it is deliberately absent).
+ *
+ * --ignore-scripts: this can run unattended in the background, so don't let a
+ * compromised package's install lifecycle hooks execute. gipity ships
+ * precompiled (dist/) and its deps need no build step, so nothing is lost.
+ */
+export function npmInstallGipity(version) {
+    const res = spawnSyncCommand(resolveCommand('npm'), ['install', '--no-audit', '--no-fund', '--ignore-scripts', `gipity@${version}`], {
+        cwd: LOCAL_DIR,
+        stdio: ['ignore', 'ignore', 'pipe'],
+        encoding: 'utf-8',
+    });
+    return {
+        ok: res.status === 0 && existsSync(LOCAL_ENTRY),
+        status: res.status,
+        stderr: (res.stderr || '').toString(),
+        spawnError: res.error,
+    };
+}
+// An interrupted install (shutdown mid-upgrade, an overlapping npm process)
+// leaves node_modules half-renamed, after which npm fails every install in
+// the dir with one of these until the tree is wiped. Reproduced: ENOTEMPTY
+// renaming node_modules/gipity over a leftover node_modules/.gipity-<hash>
+// staging dir. Deliberately narrow - transient failures (network, registry,
+// E404) must NOT wipe a still-working tree.
+const WEDGE_CODES = /\b(ENOTEMPTY|EEXIST|ENOTDIR|EISDIR|EJSONPARSE)\b/;
+export function isWedged(stderr) {
+    return WEDGE_CODES.test(stderr);
+}
+/** Wipe the local install tree back to a pristine, installable state.
+ *  `dir` is overridable for tests only. */
+export function resetLocalTree(dir = LOCAL_DIR) {
+    mkdirSync(dir, { recursive: true });
+    rmSync(join(dir, 'node_modules'), { recursive: true, force: true });
+    rmSync(join(dir, 'package-lock.json'), { force: true });
+    writeFileSync(join(dir, 'package.json'), JSON.stringify({ name: 'gipity-local', private: true, version: '0.0.0' }, null, 2));
+}
+/**
+ * Take the cross-process update lock. The shim spawns a detached updater on
+ * every gipity command, so during a long install another invocation would
+ * otherwise start a second npm install in the same dir (a reproduced way to
+ * corrupt it). A lock older than LOCK_STALE_MS is from a dead updater
+ * (machine shutdown mid-install) and is taken over.
+ * `lockPath` is overridable for tests only.
+ */
+export function acquireUpdateLock(lockPath = UPDATE_LOCK) {
+    mkdirSync(dirname(lockPath), { recursive: true });
+    try {
+        writeFileSync(lockPath, String(process.pid), { flag: 'wx' });
+        return true;
+    }
+    catch {
+        try {
+            if (Date.now() - statSync(lockPath).mtimeMs > LOCK_STALE_MS) {
+                unlinkSync(lockPath);
+                writeFileSync(lockPath, String(process.pid), { flag: 'wx' });
+                return true;
+            }
+        }
+        catch { /* lost the race to another process */ }
+        return false;
+    }
+}
+export function releaseUpdateLock(lockPath = UPDATE_LOCK) {
+    try {
+        unlinkSync(lockPath);
+    }
+    catch { /* already gone */ }
+}
+//# sourceMappingURL=install.js.map

package/dist/updater/shim.js

@@ -38,9 +38,9 @@ function spawnSyncCommand(cmd, args = [], options = {}) {
 }
 
 // src/updater/shim.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync2 } from "fs";
 import { fileURLToPath, pathToFileURL } from "url";
-import { dirname, resolve, join as join4 } from "path";
+import { dirname as dirname2, resolve, join as join5 } from "path";
 
 // src/updater/state.ts
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
@@ -76,33 +76,96 @@ function writeState(state) {
 }
 
 // src/updater/bootstrap.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join2 } from "path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
+import { join as join3 } from "path";
+
+// src/updater/install.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, rmSync, statSync, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+import { dirname, join as join2 } from "path";
+var UPDATE_LOCK = join2(GIPITY_DIR, "update.lock");
+var LOCK_STALE_MS = 10 * 60 * 1e3;
+function npmInstallGipity(version) {
+  const res = spawnSyncCommand(resolveCommand("npm"), ["install", "--no-audit", "--no-fund", "--ignore-scripts", `gipity@${version}`], {
+    cwd: LOCAL_DIR,
+    stdio: ["ignore", "ignore", "pipe"],
+    encoding: "utf-8"
+  });
+  return {
+    ok: res.status === 0 && existsSync2(LOCAL_ENTRY),
+    status: res.status,
+    stderr: (res.stderr || "").toString(),
+    spawnError: res.error
+  };
+}
+var WEDGE_CODES = /\b(ENOTEMPTY|EEXIST|ENOTDIR|EISDIR|EJSONPARSE)\b/;
+function isWedged(stderr) {
+  return WEDGE_CODES.test(stderr);
+}
+function resetLocalTree(dir = LOCAL_DIR) {
+  mkdirSync2(dir, { recursive: true });
+  rmSync(join2(dir, "node_modules"), { recursive: true, force: true });
+  rmSync(join2(dir, "package-lock.json"), { force: true });
+  writeFileSync2(join2(dir, "package.json"), JSON.stringify({ name: "gipity-local", private: true, version: "0.0.0" }, null, 2));
+}
+function acquireUpdateLock(lockPath = UPDATE_LOCK) {
+  mkdirSync2(dirname(lockPath), { recursive: true });
+  try {
+    writeFileSync2(lockPath, String(process.pid), { flag: "wx" });
+    return true;
+  } catch {
+    try {
+      if (Date.now() - statSync(lockPath).mtimeMs > LOCK_STALE_MS) {
+        unlinkSync(lockPath);
+        writeFileSync2(lockPath, String(process.pid), { flag: "wx" });
+        return true;
+      }
+    } catch {
+    }
+    return false;
+  }
+}
+function releaseUpdateLock(lockPath = UPDATE_LOCK) {
+  try {
+    unlinkSync(lockPath);
+  } catch {
+  }
+}
+
+// src/updater/bootstrap.ts
 function isBootstrapped() {
-  return existsSync2(LOCAL_ENTRY);
+  return existsSync3(LOCAL_ENTRY);
 }
 function bootstrap(version, quiet = false) {
-  mkdirSync2(LOCAL_DIR, { recursive: true });
-  const pkgJsonPath = join2(LOCAL_DIR, "package.json");
-  if (!existsSync2(pkgJsonPath)) {
-    writeFileSync2(pkgJsonPath, JSON.stringify({ name: "gipity-local", private: true, version: "0.0.0" }, null, 2));
+  mkdirSync3(LOCAL_DIR, { recursive: true });
+  const pkgJsonPath = join3(LOCAL_DIR, "package.json");
+  if (!existsSync3(pkgJsonPath)) {
+    writeFileSync3(pkgJsonPath, JSON.stringify({ name: "gipity-local", private: true, version: "0.0.0" }, null, 2));
+  }
+  if (!acquireUpdateLock()) {
+    if (!quiet) process.stderr.write(`gipity: another update is in progress - using the currently installed build.
+`);
+    return false;
   }
   if (!quiet) process.stderr.write(`Setting up gipity local install at ~/.gipity/local (one-time)...
 `);
-  const res = spawnSyncCommand(resolveCommand("npm"), ["install", "--no-audit", "--no-fund", "--ignore-scripts", `gipity@${version}`], {
-    cwd: LOCAL_DIR,
-    stdio: ["ignore", "pipe", "pipe"],
-    encoding: "utf-8"
-  });
-  if (res.status !== 0 || !existsSync2(LOCAL_ENTRY)) {
+  let res;
+  try {
+    res = npmInstallGipity(version);
+    if (!res.ok && !res.spawnError && isWedged(res.stderr)) {
+      resetLocalTree();
+      res = npmInstallGipity(version);
+    }
+  } finally {
+    releaseUpdateLock();
+  }
+  if (!res.ok) {
     if (!quiet) {
-      const stderr = (res.stderr || "").toString();
-      const notPublished = /E404|No matching version|notarget/i.test(stderr);
+      const notPublished = /E404|No matching version|notarget/i.test(res.stderr);
       if (notPublished) {
         process.stderr.write(`gipity v${version} is not yet published to npm - using the currently installed build.
 `);
       } else {
-        const firstLine = stderr.split("\n").map((l) => l.trim()).find((l) => l.length > 0) || (res.error ? res.error.message : `npm exit ${res.status}`);
+        const firstLine = res.stderr.split("\n").map((l) => l.trim()).find((l) => l.length > 0) || (res.spawnError ? res.spawnError.message : `npm exit ${res.status}`);
         const reason = firstLine.length > 160 ? firstLine.slice(0, 157) + "..." : firstLine;
         process.stderr.write(`gipity: could not set up local install (${reason}). Using the currently installed build.
 `);
@@ -119,8 +182,8 @@ function bootstrap(version, quiet = false) {
 }
 
 // src/trace.ts
-import { openSync, writeSync, mkdirSync as mkdirSync3 } from "fs";
-import { join as join3 } from "path";
+import { openSync, writeSync, mkdirSync as mkdirSync4 } from "fs";
+import { join as join4 } from "path";
 import { homedir as homedir2 } from "os";
 var TRACE_KEY = /* @__PURE__ */ Symbol.for("gipity.traceOutput");
 function installOutputTrace(label) {
@@ -132,10 +195,10 @@ function installOutputTrace(label) {
       existing.emit({ event: "reenter", label });
       return;
     }
-    const dir = join3(process.env.GIPITY_DIR || join3(homedir2(), ".gipity"), "trace");
-    mkdirSync3(dir, { recursive: true });
+    const dir = join4(process.env.GIPITY_DIR || join4(homedir2(), ".gipity"), "trace");
+    mkdirSync4(dir, { recursive: true });
     const stamp = (/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace("T", "_").replace(/:/g, "-");
-    const fd = openSync(join3(dir, `${stamp}-pid${process.pid}.jsonl`), "a");
+    const fd = openSync(join4(dir, `${stamp}-pid${process.pid}.jsonl`), "a");
     const emit = (rec) => {
       try {
         writeSync(fd, JSON.stringify({ t: (/* @__PURE__ */ new Date()).toISOString(), ...rec }) + "\n");
@@ -170,12 +233,12 @@ function installOutputTrace(label) {
 
 // src/updater/shim.ts
 installOutputTrace("shim");
-var __dirname = dirname(fileURLToPath(import.meta.url));
+var __dirname = dirname2(fileURLToPath(import.meta.url));
 var pkgRoot = resolve(__dirname, "..", "..");
-var shimPkg = JSON.parse(readFileSync2(join4(pkgRoot, "package.json"), "utf-8"));
-var isDevLink = existsSync3(join4(pkgRoot, "src"));
+var shimPkg = JSON.parse(readFileSync2(join5(pkgRoot, "package.json"), "utf-8"));
+var isDevLink = existsSync4(join5(pkgRoot, "src"));
 function startBackgroundUpdater() {
-  const checkScript = join4(__dirname, "check.js");
+  const checkScript = join5(__dirname, "check.js");
   try {
     const child = spawnCommand(process.execPath, [checkScript], {
       detached: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gipity",
-  "version": "1.1.3",
+  "version": "1.1.4",
   "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",
@@ -14,7 +14,7 @@
     "prepack": "npm run build",
     "dev": "tsc --watch",
     "test": "npm run test:smoke",
-    "test:smoke": "npm run build && node --test dist/__tests__/utils.test.js dist/__tests__/platform.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-unretrievable.test.js dist/__tests__/sync-clean-check.test.js dist/__tests__/sync-lock.test.js dist/__tests__/auth-lock.test.js dist/__tests__/api-401-retry.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__/session-pool.test.js dist/__tests__/relay-diagnostics.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__/ingest-queue.test.js dist/__tests__/media-upload.test.js dist/__tests__/stream-delta.test.js dist/__tests__/phase-tracker.test.js dist/__tests__/relay-ingest-contract.test.js dist/__tests__/prompts.test.js dist/__tests__/capture-transcript.test.js dist/__tests__/capture-parsers.test.js dist/__tests__/agents.test.js dist/__tests__/capture-lock.test.js dist/__tests__/capture-resolve.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-bug.test.js dist/__tests__/cli-cmd-bug-queue.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-storage.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-setup.test.js dist/__tests__/cli-cmd-doctor.test.js dist/__tests__/claude-setup.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 dist/__tests__/setup-codex-hooks.test.js dist/__tests__/trace.test.js",
+    "test:smoke": "npm run build && node --test dist/__tests__/utils.test.js dist/__tests__/platform.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-unretrievable.test.js dist/__tests__/sync-clean-check.test.js dist/__tests__/sync-lock.test.js dist/__tests__/auth-lock.test.js dist/__tests__/api-401-retry.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__/build-picker.test.js dist/__tests__/relay-state.test.js dist/__tests__/relay-daemon.test.js dist/__tests__/session-pool.test.js dist/__tests__/relay-diagnostics.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__/ingest-queue.test.js dist/__tests__/media-upload.test.js dist/__tests__/stream-delta.test.js dist/__tests__/phase-tracker.test.js dist/__tests__/relay-ingest-contract.test.js dist/__tests__/prompts.test.js dist/__tests__/capture-transcript.test.js dist/__tests__/capture-parsers.test.js dist/__tests__/agents.test.js dist/__tests__/capture-lock.test.js dist/__tests__/capture-resolve.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-bug.test.js dist/__tests__/cli-cmd-bug-queue.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-storage.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-setup.test.js dist/__tests__/cli-cmd-doctor.test.js dist/__tests__/claude-setup.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 dist/__tests__/setup-codex-hooks.test.js dist/__tests__/trace.test.js",
     "test:smoke:quick": "node scripts/smoke-quick.mjs",
     "test:e2e": "tsc && GIPITY_E2E=1 node --test --test-timeout=180000 dist/__tests__/cli-e2e-live.test.js dist/__tests__/cli-e2e-sync-live.test.js dist/__tests__/cli-e2e-sync-stress-live.test.js dist/__tests__/cli-e2e-rollback-live.test.js dist/__tests__/cli-e2e-services-media-live.test.js dist/__tests__/cli-e2e-workflow-live.test.js dist/__tests__/cli-e2e-sandbox-live.test.js dist/__tests__/cli-e2e-page-fetch-live.test.js dist/__tests__/cli-e2e-page-test-live.test.js",
     "test:e2e:sync": "tsc && GIPITY_E2E=1 node --test --test-timeout=180000 dist/__tests__/cli-e2e-sync-live.test.js",