gipity 1.0.422 → 1.0.425

package/dist/knowledge.js

@@ -37,9 +37,9 @@ 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).
-    - \`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.
-    - \`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.
+    - \`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.`;
@@ -88,7 +88,7 @@ Prefer a live Gipity URL over an ephemeral artifact. When you'd otherwise reach
 
 The full "when to add a template" rule and the definition of done are spelled out in the two sections at the end of this document. In short: if the user wants something deployable (web app, game, API), \`gipity add <template>\` first (default \`web-simple\`); for a one-off task (analysis, PDFs, data work), use \`gipity sandbox run\` instead; to add a reusable building block to an existing app (e.g. multiplayer), \`gipity add <kit>\`.
 
-Build loop: \`gipity add\` → edit files → \`gipity deploy dev\` → \`gipity page inspect <url>\` → fix any errors → repeat until the definition of done is met.
+Build loop: \`gipity add\` → edit files → \`gipity deploy dev --inspect\` → fix any errors → repeat until the definition of done is met. \`deploy --inspect\` deploys and then runs the page-inspect report on the live URL in one command; use a standalone \`gipity page inspect <url>\` only when re-checking without deploying.
 
 \`add\` writes real files to disk - Read a scaffolded file before your first Write/Edit to it, or the call fails \`"File has not been read yet"\`. Don't rewrite from memory of the template.
 
@@ -136,6 +136,7 @@ gipity bug report --category <cli|deploy|template|kit|db|docs|skill|service|sand
 - **Never include PII or user data** (emails, names, secrets, tokens, prompt/file contents) — describe the platform problem in the abstract.
 - File it for *platform* problems, not your own mistakes or the app's own bugs. One report per distinct problem.
 - Reports go to a review queue for the team to triage into fixes; see what you've filed with \`gipity bug list\`.
+- Filed one by mistake? Withdraw it yourself: \`gipity bug retract <report-id> [--reason "<why>"]\` — works while it's still queued (status new/triaged). Never file a second report asking a human to close the first.
 
 ## Tool output is complete and synchronous
 
@@ -193,6 +194,7 @@ 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
 
@@ -202,7 +204,7 @@ Other key skills:
 - \`tts\` - agent-side speech tools (different from the \`app-tts\` HTTP service)`;
 export const DEFINITION_OF_DONE = `## Definition of done (build tasks)
 1. \`gipity deploy dev\` succeeds and you have a live URL.
-2. \`gipity page inspect <url>\` returns no console errors and the page loads (HTTP 200, no blank screen).
+2. \`gipity page inspect <url>\` returns no console errors and the page loads (HTTP 200, no blank screen). (\`gipity deploy dev --inspect\` covers 1 and 2 in one command.)
 3. For apps with functions: \`gipity test\` passes.
 4. Non-rendered files the task called for (\`llms.txt\`, \`AGENTS.md\`, \`SKILL.md\`, \`robots.txt\`, served JSON, etc.): \`page inspect\` only sees rendered HTML, so verify them with \`gipity page fetch <url> <files...>\`. It flags any that 404 or come back as the static-host shell (a missing file is served as \`index.html\` with a 200, so a bare status check would pass) and checks each \`content-type\`.
 5. You told the user the live URL.

package/dist/sync.js

@@ -29,7 +29,7 @@ import { get, del, downloadStream, ApiError } from './api.js';
 import { requireConfig, shouldIgnore, getConfigPath } from './config.js';
 import { formatSize, prompt, getAutoConfirm } from './utils.js';
 import { uploadOneFile, hashFile, guessMime, transferToS3, uploadInitBatch, uploadCompleteBatch, UploadConflictError, UPLOAD_CONCURRENCY, UPLOAD_INIT_BATCH_SIZE, UPLOAD_MAX_BYTES, UPLOAD_MAX_PATH_CHARS, } from './upload.js';
-import { DEFAULT_SYNC_IGNORE } from './setup.js';
+import { DEFAULT_SYNC_IGNORE, SCRATCH_IGNORE } from './setup.js';
 const CONFIG_FILE = '.gipity.json';
 import * as tar from 'tar-stream';
 // ─── Tunables ──────────────────────────────────────────────────
@@ -659,10 +659,53 @@ export function readGipityIgnore(root) {
 /** The ignore list a sync/push actually runs with: the project config's
  *  `ignore` (falling back to DEFAULT_SYNC_IGNORE when empty, so an empty list
  *  never means "sync everything - node_modules, .git and all"), plus any
- *  `.gipityignore` patterns. The ignore file itself never syncs. */
+ *  `.gipityignore` patterns, plus - unconditionally - the scratch namespaces.
+ *  The ignore file itself never syncs.
+ *
+ *  SCRATCH_IGNORE is unioned in even when the config has its own `ignore`
+ *  list, because scratch dirs are a PLATFORM CONVENTION, not a user
+ *  preference: they must mirror the server's `isEphemeralSandboxPath`
+ *  denylist (see the comment on SCRATCH_IGNORE in setup.ts) so the same
+ *  paths are throwaway everywhere - the sandbox refuses to persist them and
+ *  sync/deploy refuses to upload them. `config.ignore` is frozen into
+ *  .gipity.json at link time, so any project linked before a scratch dir was
+ *  added to the defaults would otherwise keep syncing it forever (tmp/ did
+ *  exactly this). Appended LAST so a stray `!tmp/` negation earlier in the
+ *  list can't re-include scratch; deduped so the matcher cache in
+ *  config.ts keys on one canonical pattern set. */
 export function effectiveIgnore(root, configIgnore) {
     const base = configIgnore && configIgnore.length ? configIgnore : DEFAULT_SYNC_IGNORE;
-    return [...base, GIPITY_IGNORE_FILE, ...readGipityIgnore(root)];
+    const merged = [...base, GIPITY_IGNORE_FILE, ...readGipityIgnore(root)];
+    return [...merged, ...SCRATCH_IGNORE.filter(p => !merged.includes(p))];
+}
+/** Fast, LOCAL-ONLY dirtiness probe: true when every local file matches its
+ *  baseline entry by size+mtime and nothing was added or deleted since the
+ *  last sync. Lets pre-action syncs (deploy) skip their server round trip:
+ *  deploy reads server-side (VFS) state, so with nothing to push the sync
+ *  adds no correctness, only latency. Conservative on purpose - any size or
+ *  mtime movement reads as dirty (no hashing here), never-synced projects
+ *  read as dirty, and callers then run the real sync(). */
+export function isLocalTreeClean() {
+    try {
+        const config = requireConfig();
+        const root = projectDir();
+        const baseline = readBaseline(config.projectGuid);
+        if (!baseline.lastFullSync)
+            return false;
+        const local = walkLocal(root, effectiveIgnore(root, config.ignore), baseline.files);
+        const baselineFiles = baseline.files;
+        if (local.size !== Object.keys(baselineFiles).length)
+            return false;
+        for (const [path, info] of local) {
+            const prior = baselineFiles[path];
+            if (!prior || prior.size !== info.size || prior.mtime !== info.mtime)
+                return false;
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
 }
 export async function sync(opts = {}) {
     const config = requireConfig();

package/dist/trace.js

@@ -0,0 +1,69 @@
+// Opt-in output tracing for diagnosing silent-success bugs (cli#125/#126/#108):
+// invocations that exit 0 but print nothing. With GIPITY_TRACE_OUTPUT=1, every
+// process.stdout/stderr write is teed as a JSONL record to
+// ~/.gipity/trace/<yyyy-mm-dd_hh-mm-ss>-pid<pid>.jsonl, alongside start/exit
+// markers carrying pid, argv, cwd, and TTY state. Diffing a trace against the
+// captured tool output shows whether the bytes were ever emitted by this
+// process (pointing at the environment) or never written (pointing at the CLI).
+//
+// Records are written with fs.writeSync on a raw fd, not a stream: the bug
+// class under investigation is process teardown eating output, so the trace
+// itself must not depend on stream flushing at exit.
+import { openSync, writeSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+// Keyed on globalThis, not module state: the shim and the CLI entry are
+// separate esbuild bundles loaded into one process (shim dynamic-imports the
+// entry), so a module-level flag would double-install the tee.
+const TRACE_KEY = Symbol.for('gipity.traceOutput');
+/** Install the stdout/stderr tee if GIPITY_TRACE_OUTPUT=1. Idempotent per
+ *  process; a re-entrant call (e.g. index.ts after shim.ts) logs a marker so
+ *  the trace shows the in-process import chain actually ran. Never throws -
+ *  tracing must not be able to break the CLI. */
+export function installOutputTrace(label) {
+    if (process.env.GIPITY_TRACE_OUTPUT !== '1')
+        return;
+    try {
+        const g = globalThis;
+        const existing = g[TRACE_KEY];
+        if (existing) {
+            existing.emit({ event: 'reenter', label });
+            return;
+        }
+        const dir = join(process.env.GIPITY_DIR || join(homedir(), '.gipity'), 'trace');
+        mkdirSync(dir, { recursive: true });
+        const stamp = new Date().toISOString().slice(0, 19).replace('T', '_').replace(/:/g, '-');
+        const fd = openSync(join(dir, `${stamp}-pid${process.pid}.jsonl`), 'a');
+        const emit = (rec) => {
+            try {
+                writeSync(fd, JSON.stringify({ t: new Date().toISOString(), ...rec }) + '\n');
+            }
+            catch { /* trace write failure must never surface */ }
+        };
+        g[TRACE_KEY] = { emit };
+        emit({
+            event: 'start',
+            label,
+            pid: process.pid,
+            ppid: process.ppid,
+            argv: process.argv,
+            cwd: process.cwd(),
+            tty: { stdout: !!process.stdout.isTTY, stderr: !!process.stderr.isTTY },
+        });
+        for (const name of ['stdout', 'stderr']) {
+            const stream = process[name];
+            const original = stream.write.bind(stream);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            stream.write = ((chunk, encoding, cb) => {
+                emit({
+                    stream: name,
+                    data: typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString('utf8'),
+                });
+                return original(chunk, encoding, cb);
+            });
+        }
+        process.on('exit', (code) => emit({ event: 'exit', code }));
+    }
+    catch { /* tracing is best-effort only */ }
+}
+//# sourceMappingURL=trace.js.map

package/dist/updater/check.js

@@ -1,101 +1,176 @@
 #!/usr/bin/env node
-// Background updater. Invoked detached by the shim; can also be invoked
-// directly by `gipity update --force`.
-import { appendFileSync, existsSync } from 'fs';
-import { LOCAL_DIR, LOCAL_ENTRY, UPDATE_LOG, readState, writeState, updatesDisabled } from './state.js';
-import { resolveCommand, spawnSyncCommand } from '../platform.js';
-const CHECK_INTERVAL_MS = 4 * 60 * 60 * 1000; // 4 hours
+import { createRequire as __cliCreateRequire } from 'module';
+const require = __cliCreateRequire(import.meta.url);
+
+// src/updater/check.ts
+import { appendFileSync, existsSync as existsSync2 } from "fs";
+
+// src/updater/state.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var GIPITY_DIR = join(homedir(), ".gipity");
+var LOCAL_DIR = join(GIPITY_DIR, "local");
+var LOCAL_PKG_DIR = join(LOCAL_DIR, "node_modules", "gipity");
+var LOCAL_ENTRY = join(LOCAL_PKG_DIR, "dist", "index.js");
+var STATE_FILE = join(GIPITY_DIR, "update-state.json");
+var SETTINGS_FILE = join(GIPITY_DIR, "settings.json");
+var UPDATE_LOG = join(GIPITY_DIR, "update.log");
+var DEFAULT_STATE = {
+  installedVersion: null,
+  lastCheckAt: 0,
+  lastError: null,
+  updateChannel: "stable"
+};
+var DEFAULT_SETTINGS = {
+  autoUpdates: true
+};
+function ensureDir() {
+  mkdirSync(GIPITY_DIR, { recursive: true });
+}
+function readState() {
+  if (!existsSync(STATE_FILE)) return { ...DEFAULT_STATE };
+  try {
+    return { ...DEFAULT_STATE, ...JSON.parse(readFileSync(STATE_FILE, "utf-8")) };
+  } catch {
+    return { ...DEFAULT_STATE };
+  }
+}
+function writeState(state) {
+  ensureDir();
+  writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+}
+function readSettings() {
+  if (!existsSync(SETTINGS_FILE)) return { ...DEFAULT_SETTINGS };
+  try {
+    return { ...DEFAULT_SETTINGS, ...JSON.parse(readFileSync(SETTINGS_FILE, "utf-8")) };
+  } catch {
+    return { ...DEFAULT_SETTINGS };
+  }
+}
+function updatesDisabled() {
+  if (process.env["DISABLE_AUTOUPDATER"] === "1") return { disabled: true, reason: "DISABLE_AUTOUPDATER=1" };
+  if (process.env["CI"]) return { disabled: true, reason: "CI environment" };
+  if (!readSettings().autoUpdates) return { disabled: true, reason: "autoUpdates: false in settings.json" };
+  return { disabled: false };
+}
+
+// src/platform.ts
+import { execSync, spawn, spawnSync } from "child_process";
+function resolveCommand(cmd) {
+  if (process.platform !== "win32") return cmd;
+  try {
+    const lines = execSync(`where ${cmd}`, { encoding: "utf-8", windowsHide: true }).split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+    return lines.find((l) => l.endsWith(".exe")) || lines.find((l) => l.endsWith(".cmd")) || cmd;
+  } catch {
+    return `${cmd}.cmd`;
+  }
+}
+function isBatchShim(cmd) {
+  return process.platform === "win32" && /\.(cmd|bat)$/i.test(cmd);
+}
+function winBatchInvocation(cmd, args) {
+  const comspec = process.env.ComSpec || "cmd.exe";
+  const quote = (t) => `"${String(t).replace(/"/g, '""')}"`;
+  const line = [cmd, ...args].map(quote).join(" ");
+  return { file: comspec, args: ["/d", "/s", "/c", `"${line}"`] };
+}
+function spawnSyncCommand(cmd, args = [], options = {}) {
+  if (isBatchShim(cmd)) {
+    const inv = winBatchInvocation(cmd, args);
+    return spawnSync(inv.file, inv.args, { windowsHide: true, ...options, windowsVerbatimArguments: true });
+  }
+  return spawnSync(cmd, [...args], { windowsHide: true, ...options });
+}
+
+// src/updater/check.ts
+var CHECK_INTERVAL_MS = 4 * 60 * 60 * 1e3;
 function log(line) {
-    try {
-        appendFileSync(UPDATE_LOG, `[${new Date().toISOString()}] ${line}\n`);
-    }
-    catch { /* ignore */ }
+  try {
+    appendFileSync(UPDATE_LOG, `[${(/* @__PURE__ */ new Date()).toISOString()}] ${line}
+`);
+  } catch {
+  }
 }
-export function compareSemver(a, b) {
-    const pa = a.split('.').map(Number);
-    const pb = b.split('.').map(Number);
-    for (let i = 0; i < 3; i++) {
-        const da = pa[i] ?? 0;
-        const db = pb[i] ?? 0;
-        if (da !== db)
-            return da - db;
-    }
-    return 0;
+function compareSemver(a, b) {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    const da = pa[i] ?? 0;
+    const db = pb[i] ?? 0;
+    if (da !== db) return da - db;
+  }
+  return 0;
 }
 async function fetchLatestVersion() {
-    const res = await fetch('https://registry.npmjs.org/gipity/latest', {
-        headers: { accept: 'application/json' },
-    });
-    if (!res.ok)
-        throw new Error(`registry HTTP ${res.status}`);
-    const json = await res.json();
-    if (!json.version)
-        throw new Error('no version in registry response');
-    return json.version;
+  const res = await fetch("https://registry.npmjs.org/gipity/latest", {
+    headers: { accept: "application/json" }
+  });
+  if (!res.ok) throw new Error(`registry HTTP ${res.status}`);
+  const json = await res.json();
+  if (!json.version) throw new Error("no version in registry response");
+  return json.version;
 }
 function installVersion(version) {
-    // --ignore-scripts: this runs 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.
-    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 && existsSync(LOCAL_ENTRY);
+  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);
 }
-export async function runCheck(opts = {}) {
-    const state = readState();
-    if (!opts.force) {
-        const dis = updatesDisabled();
-        if (dis.disabled) {
-            log(`skipped: ${dis.reason}`);
-            return { updated: false, reason: dis.reason };
-        }
-        if (Date.now() - state.lastCheckAt < CHECK_INTERVAL_MS) {
-            return { updated: false, reason: 'cache-fresh' };
-        }
-    }
-    let latest;
-    try {
-        latest = await fetchLatestVersion();
-    }
-    catch (e) {
-        const msg = e instanceof Error ? e.message : String(e);
-        state.lastError = `fetch failed: ${msg}`;
-        state.lastCheckAt = Date.now();
-        writeState(state);
-        log(state.lastError);
-        return { updated: false, reason: state.lastError };
+async function runCheck(opts = {}) {
+  const state = readState();
+  if (!opts.force) {
+    const dis = updatesDisabled();
+    if (dis.disabled) {
+      log(`skipped: ${dis.reason}`);
+      return { updated: false, reason: dis.reason };
     }
-    const current = state.installedVersion ?? '0.0.0';
-    if (compareSemver(latest, current) <= 0) {
-        state.lastError = null;
-        state.lastCheckAt = Date.now();
-        writeState(state);
-        log(`up-to-date (current=${current}, latest=${latest})`);
-        return { updated: false, reason: 'up-to-date' };
+    if (Date.now() - state.lastCheckAt < CHECK_INTERVAL_MS) {
+      return { updated: false, reason: "cache-fresh" };
     }
-    log(`upgrading ${current} → ${latest}`);
-    const ok = installVersion(latest);
+  }
+  let latest;
+  try {
+    latest = await fetchLatestVersion();
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    state.lastError = `fetch failed: ${msg}`;
     state.lastCheckAt = Date.now();
-    if (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`;
     writeState(state);
     log(state.lastError);
     return { updated: false, reason: state.lastError };
+  }
+  const current = state.installedVersion ?? "0.0.0";
+  if (compareSemver(latest, current) <= 0) {
+    state.lastError = null;
+    state.lastCheckAt = Date.now();
+    writeState(state);
+    log(`up-to-date (current=${current}, latest=${latest})`);
+    return { updated: false, reason: "up-to-date" };
+  }
+  log(`upgrading ${current} \u2192 ${latest}`);
+  const ok = installVersion(latest);
+  state.lastCheckAt = Date.now();
+  if (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`;
+  writeState(state);
+  log(state.lastError);
+  return { updated: false, reason: state.lastError };
 }
-// Direct invocation (detached background)
-const isDirect = import.meta.url === `file://${process.argv[1]}`;
+var isDirect = import.meta.url === `file://${process.argv[1]}`;
 if (isDirect) {
-    const force = process.argv.includes('--force');
-    runCheck({ force }).catch((e) => log(`unhandled: ${e instanceof Error ? e.message : String(e)}`));
+  const force = process.argv.includes("--force");
+  runCheck({ force }).catch((e) => log(`unhandled: ${e instanceof Error ? e.message : String(e)}`));
 }
-//# sourceMappingURL=check.js.map
+export {
+  compareSemver,
+  runCheck
+};