gipity 1.0.428 → 1.1.1

package/dist/commands/chat.js

@@ -50,9 +50,15 @@ export const chatCommand = new Command('chat')
                 ...(a.remoteSize != null ? { size: a.remoteSize } : {}),
             }));
         }
+        // The server's cost-consent gate stops the agentic loop on big-build
+        // requests: content comes back empty with an explicit costWarning.
+        // Surface it - before this the CLI printed a blank line and the request
+        // silently did nothing. Re-running the command consents via chat reply.
+        const displayContent = res.data.content || res.data.costWarning?.message || '';
         if (opts.json) {
             console.log(JSON.stringify({
-                content: res.data.content,
+                content: displayContent,
+                costWarning: res.data.costWarning ?? null,
                 toolsUsed: res.data.toolsUsed?.map(t => ({
                     tool: t.toolName,
                     success: t.success,
@@ -67,8 +73,8 @@ export const chatCommand = new Command('chat')
             }));
         }
         else {
-            // Show agent response
-            console.log(res.data.content);
+            // Show agent response (or the cost warning when the gate stopped the loop)
+            console.log(displayContent);
             // Show tools used
             if (res.data.toolsUsed && res.data.toolsUsed.length > 0) {
                 const toolNames = [...new Set(res.data.toolsUsed.map(t => t.toolName))];

package/dist/commands/claude.js

@@ -9,7 +9,7 @@ import { get, post, ApiError, getAccountSlug } from '../api.js';
 import { interactiveLogin } from '../login-flow.js';
 import { getConfig, saveConfigAt, clearConfigCache, getApiBaseOverride, DEFAULT_API_BASE, getConfigPath } from '../config.js';
 import { sync } from '../sync.js';
-import { slugify, setupClaudeHooks, ensureGipityPluginInstalled, setupClaudeMd, setupAgentsMd, setupGitignore, DEFAULT_SYNC_IGNORE, isSyncIgnored } from '../setup.js';
+import { slugify, ensureGipityPluginInstalled, setupProjectTools, DEFAULT_SYNC_IGNORE, isSyncIgnored } from '../setup.js';
 import { buildProjectContextBlock as buildProjectContextBlockText, buildNewProjectPrompt, buildResumeWrap, buildFreshWrap, } from '../prompts.js';
 import * as relayState from '../relay/state.js';
 import { maybeOfferRelayOn, ensureDaemonRunning } from '../relay/onboarding.js';
@@ -481,10 +481,7 @@ export const claudeCommand = new Command('claude')
             catch (err) {
                 console.log(`  ${warning('Could not sync files (will retry on next prompt):')} ${err.message}`);
             }
-            setupClaudeHooks();
-            setupClaudeMd();
-            setupAgentsMd();
-            setupGitignore();
+            setupProjectTools();
             if (nonInteractive) {
                 // Headless: the -p message is wrapped later (Step 3). Just record
                 // whether to use the new-project framing for that wrap.
@@ -503,10 +500,7 @@ export const claudeCommand = new Command('claude')
             // cwd already has (or inherits) a .gipity.json - run inside it.
             console.log(`  Project: ${brand(existing.projectSlug)} ${muted(`(${existing.projectGuid})`)}`);
             console.log(`  ${success('Already set up.')}\n`);
-            setupClaudeHooks();
-            setupClaudeMd();
-            setupAgentsMd();
-            setupGitignore();
+            setupProjectTools();
             // Warn before syncing a very large project tree. An oversized root
             // (or a config accidentally rooted high up, e.g. at $HOME) makes the
             // sync slow, and a silent multi-GB walk reads as a hang.
@@ -658,10 +652,7 @@ export const claudeCommand = new Command('claude')
             // of done, and a welcome banner prints before launch - the user tells
             // Claude directly what they want to build or do.
             initialPrompt = '';
-            setupClaudeHooks();
-            setupClaudeMd();
-            setupAgentsMd();
-            setupGitignore();
+            setupProjectTools();
             console.log(`  ${success(`Project "${project.name}" ready.`)}\n`);
         }
         // ── Step 3: Launch Claude Code ────────────────────────────────────

package/dist/commands/db.js

@@ -1,5 +1,5 @@
 import { Command } from 'commander';
-import { get, post, sendMessage } from '../api.js';
+import { get, post } from '../api.js';
 import { requireConfig } from '../config.js';
 import { error as clrError, success } from '../colors.js';
 import { run, printList, emitField } from '../helpers/index.js';
@@ -106,13 +106,20 @@ dbCommand
     .description('Create a database')
     .option('--json', 'Output as JSON')
     .action((name, opts) => run('Create', async () => {
-    // DDL delegates to agent (needs confirmation flow)
-    const response = await sendMessage(`Create a new database called "${name}" for this project. Confirm when done, no explanation.`);
+    // Direct REST create - same endpoint `db drop` uses. This used to delegate
+    // to agent chat, which burned LLM tokens and, after the cost-consent gate
+    // landed server-side, could return an empty response having created
+    // nothing. Creating a database isn't destructive, so no confirmation.
+    const config = requireConfig();
+    await post(`/projects/${config.projectGuid}/db/manage`, {
+        action: 'create',
+        name,
+    });
     if (opts.json) {
-        console.log(JSON.stringify({ response }));
+        console.log(JSON.stringify({ success: true, name }));
     }
     else {
-        console.log(response);
+        console.log(success(`Created database '${name}'.`));
     }
 }));
 dbCommand

package/dist/commands/deploy.js

@@ -28,11 +28,24 @@ export const deployCommand = new Command('deploy')
     .option('--no-optimize', 'Skip build optimization and upload files as-is - the escape hatch for plain-HTML apps whose <script src> tags are not type="module"')
     .option('--json', 'Output as JSON')
     .option('--inspect [path]', 'After a successful deploy, run `page inspect` on the deployed URL (or URL + path) in the same command - one build-loop step instead of two. With --json, emits two JSON lines: deploy, then inspect.')
+    // The settle knobs `page inspect` already has. An app whose first paint is behind
+    // a model load / async boot inspects as an empty page without them, so a caller
+    // that reaches for `--inspect` on such an app needs them HERE - it should not have
+    // to abandon the combined command and re-run inspect standalone just to wait.
+    .option('--wait <ms>', 'With --inspect: sleep this many ms before capturing (max 30000)')
+    .option('--wait-for <selector>', "With --inspect: wait until this CSS selector appears before capturing (deterministic; the app's own ready signal)")
+    .option('--wait-timeout <ms>', 'With --inspect: max ms to wait for --wait-for before giving up', '5000')
     .action((target, opts) => run('Deploy', async () => {
     if (target !== 'dev' && target !== 'prod') {
         console.error(clrError('Target must be "dev" or "prod"'));
         process.exit(1);
     }
+    // A settle flag only means one thing on a deploy: "verify the page once it's
+    // up, and give it time to come up." Asking for it without --inspect is not an
+    // error to bounce back — it's the intent, so honour it.
+    if (!opts.inspect && (opts.waitFor || deployCommand.getOptionValueSource('wait') !== undefined)) {
+        opts.inspect = true;
+    }
     const config = requireConfig();
     await syncBeforeAction(opts);
     const doDeploy = () => post(`/projects/${config.projectGuid}/deploy`, {
@@ -61,7 +74,12 @@ export const deployCommand = new Command('deploy')
         if (!opts.json)
             console.log('');
         try {
-            await inspectPage(url, { json: opts.json });
+            await inspectPage(url, {
+                json: opts.json,
+                wait: opts.wait,
+                waitFor: opts.waitFor,
+                waitTimeout: opts.waitTimeout,
+            });
         }
         catch (err) {
             console.error(warning(`Inspect failed (deploy itself succeeded): ${err?.message ?? err}`));

package/dist/commands/doctor.js

@@ -1,6 +1,6 @@
 import { Command } from 'commander';
 import { existsSync, readFileSync, statSync } from 'fs';
-import { join } from 'path';
+import { join, resolve } from 'path';
 import { homedir } from 'os';
 import { LOCAL_PKG_DIR, LOCAL_ENTRY, STATE_FILE, SETTINGS_FILE, UPDATE_LOG, readState, readSettings, updatesDisabled } from '../updater/state.js';
 import { bold, dim, success, warning, error as clrError, muted } from '../colors.js';
@@ -162,7 +162,13 @@ export const doctorCommand = new Command('doctor')
     console.log(`${muted('claude code     ')} installed ${yn(env.claude.installed)} · authenticated ${yn(env.claude.authenticated)}`);
     const autostartLabel = env.relay.autostart === null ? muted('n/a') : yn(env.relay.autostart);
     console.log(`${muted('relay           ')} paired ${yn(env.relay.paired)} · running ${yn(env.relay.running)} · autostart ${autostartLabel}${env.relay.paused ? warning(' · paused') : ''}${env.relay.device ? muted(`  (${env.relay.device.name})`) : ''}`);
-    console.log(`${muted('ready           ')} ${env.ready ? success('yes') : warning('no - run `gipity claude` (or the desktop app) to finish setup')}`);
+    // Codex approves project hooks interactively and stores the decision in
+    // its own opaque state - we can't verify it from here, so surface the
+    // one manual step whenever this project ships Codex hooks.
+    if (existsSync(resolve(process.cwd(), '.codex', 'hooks.json'))) {
+        console.log(`${muted('codex hooks     ')} ${warning('written')} - session capture needs a one-time approval: run /hooks inside Codex in this project`);
+    }
+    console.log(`${muted('ready           ')} ${env.ready ? success('yes') : warning('no - run `gipity build` (or the desktop app) to finish setup')}`);
     // ── CLI install / update health ────────────────────────────────────
     const state = readState();
     const settings = readSettings();

package/dist/commands/generate.js

@@ -25,12 +25,66 @@ async function downloadFile(url, filename) {
     if (!res.ok)
         throw new Error(`Download failed: ${res.status}`);
     const buffer = Buffer.from(await res.arrayBuffer());
-    ensureOutputDir(filename);
-    writeFileSync(filename, buffer);
-    const savedPath = resolvePath(filename);
+    const outPath = correctExtension(filename, buffer);
+    ensureOutputDir(outPath);
+    writeFileSync(outPath, buffer);
+    const savedPath = resolvePath(outPath);
     await pushGenerated(savedPath);
     return savedPath;
 }
+/** What these bytes ACTUALLY are, by magic number — the only trustworthy source.
+ *  A provider hands back whatever its model produced (BFL's "png" request comes
+ *  back as JPEG), so neither the caller's -o extension nor the response's
+ *  content_type describes the file on disk. */
+function sniffExt(buf) {
+    // subarray past the end yields a short string, so every compare below is
+    // length-safe on its own — no blanket minimum (which would skip the check
+    // entirely on a small file and hand back the misnamed path).
+    const ascii = (start, end) => buf.subarray(start, end).toString('latin1');
+    if (buf.length < 4)
+        return undefined;
+    if (buf[0] === 0xff && buf[1] === 0xd8 && buf[2] === 0xff)
+        return 'jpg';
+    if (ascii(0, 8) === '\x89PNG\r\n\x1a\n')
+        return 'png';
+    if (ascii(0, 4) === 'RIFF' && ascii(8, 12) === 'WEBP')
+        return 'webp';
+    if (ascii(0, 4) === 'RIFF' && ascii(8, 12) === 'WAVE')
+        return 'wav';
+    if (ascii(0, 3) === 'GIF')
+        return 'gif';
+    if (ascii(4, 8) === 'ftyp')
+        return 'mp4';
+    if (buf[0] === 0x1a && buf[1] === 0x45 && buf[2] === 0xdf && buf[3] === 0xa3)
+        return 'webm';
+    if (ascii(0, 3) === 'ID3' || (buf[0] === 0xff && (buf[1] & 0xe0) === 0xe0))
+        return 'mp3';
+    return undefined;
+}
+/** Extensions that name the same format, so a .jpeg holding JPEG bytes is right. */
+const EXT_ALIASES = { jpeg: 'jpg', htm: 'html', yml: 'yaml' };
+const canonicalExt = (ext) => EXT_ALIASES[ext] ?? ext;
+/** The format's name, for the note — "JPEG", not the "JPG" of its extension. */
+const formatName = (ext) => (canonicalExt(ext) === 'jpg' ? 'JPEG' : ext.toUpperCase());
+/** Save under an extension that matches the bytes. A file whose extension lies
+ *  about its format is not a cosmetic problem: `page eval --camera` validates and
+ *  dispatches on the extension, image tools and browsers sniff it, and an agent
+ *  that Reads a "*.png" full of JPEG bytes has to stop and work out which one is
+ *  lying. The caller's -o path is a request, not a fact — honour its directory and
+ *  stem, and let the bytes name the format. */
+function correctExtension(filename, buf) {
+    const actual = sniffExt(buf);
+    if (!actual)
+        return filename; // unrecognized bytes — nothing better to say
+    const dot = filename.lastIndexOf('.');
+    const asked = dot > 0 ? filename.slice(dot + 1).toLowerCase() : '';
+    if (canonicalExt(asked) === actual)
+        return filename;
+    const corrected = `${dot > 0 ? filename.slice(0, dot) : filename}.${actual}`;
+    console.error(muted(`Note: the model returned ${formatName(actual)}, not ${asked ? formatName(asked) : 'the requested format'} — `
+        + `saving as ${corrected} so the extension matches the actual bytes.`));
+    return corrected;
+}
 /** Create the parent directory of an -o path, so `-o src/audio/ding.mp3` works
  *  in a tree that has no `src/audio/` yet instead of dying on a raw ENOENT.
  *
@@ -114,10 +168,13 @@ Examples:
         else {
             const sizeKb = Math.round(result.size_bytes / 1024);
             console.log(`${muted(`Generated with ${result.provider}/${result.model} (${sizeKb}KB)`)}`);
-            console.log(success(`Saved to ${savedPath}`));
             if (result.seed !== undefined) {
                 console.log(muted(`Seed ${result.seed} — pass --seed ${result.seed} to keep the next image coherent`));
             }
+            // Saved-path last: a caller reading a truncated tail of this output (an
+            // agent batching several generates in one shell call) must still see
+            // WHERE the bytes landed - that is the one line the next command needs.
+            console.log(success(`Saved to ${savedPath}`));
         }
     }
     catch (err) {

package/dist/commands/init.js

@@ -4,7 +4,7 @@ import { existsSync, readFileSync } from 'fs';
 import { getAccountSlug } from '../api.js';
 import { getConfig, getConfigPath, saveConfigAt } from '../config.js';
 import { getAuth } from '../auth.js';
-import { slugify, setupClaudeHooks, setupGitignore, SUPPORTED_TOOLS, DEFAULT_TOOLS, DEFAULT_SYNC_IGNORE } from '../setup.js';
+import { slugify, setupProjectTools, SUPPORTED_TOOLS, DEFAULT_TOOLS, DEFAULT_SYNC_IGNORE } from '../setup.js';
 import { success, error as clrError, info, muted, bold } from '../colors.js';
 import { confirm } from '../utils.js';
 import { scanForAdoption, adoptCurrentDir, canAdoptCwd, formatBytes, formatCwdLabel, ADOPT_THRESHOLDS, } from '../adopt-cwd.js';
@@ -23,7 +23,7 @@ function resolveTools(forFlag) {
 }
 export const initCommand = new Command('init')
     .description('Link this directory to a project')
-    .addHelpText('after', '\nWrites CLAUDE.md/AGENTS.md primer files so your AI coding tool understands Gipity.')
+    .addHelpText('after', '\nWrites CLAUDE.md/AGENTS.md primer files so your AI coding tool understands Gipity, and installs the Gipity skills + file-sync hooks into the agent CLIs found on this machine (Claude Code, Codex, Grok).')
     .argument('[name]', 'Project name/slug (defaults to current directory name)')
     .option('--agent <guid>', 'Agent GUID to use')
     .option('--no-capture', 'Don\'t record Claude Code sessions in this directory to your Gipity project (sets captureHooks: false in .gipity.json)')
@@ -32,7 +32,8 @@ export const initCommand = new Command('init')
 Examples:
   $ gipity init                          Link cwd as a new project (slug = dir name).
   $ gipity init my-app                   Link cwd with an explicit slug.
-  $ gipity init --for codex              Write only AGENTS.md (skip Claude/Cursor/etc).
+  $ gipity init --for codex              AGENTS.md + Codex skills/sync hooks only.
+  $ gipity init --for grok               AGENTS.md + the Gipity plugin in Grok only.
   $ gipity init --for cursor,gemini      Write only the Cursor + Gemini primers.
   $ gipity init --for aider              AGENTS.md + a read: entry in .aider.conf.yml
                                          (aider auto-reads nothing, so it's opt-in).
@@ -57,10 +58,6 @@ Working with an existing Gipity project:
         process.exit(1);
     }
     const wantsClaude = tools.some(t => t.key === 'claude');
-    const writeAllPrimers = () => {
-        for (const t of tools)
-            t.setup();
-    };
     const primerSummary = tools.map(t => t.label).join(', ');
     try {
         // Check auth
@@ -77,12 +74,9 @@ Working with an existing Gipity project:
         if (existsSync(resolve(cwd, '.gipity.json'))) {
             const existing = getConfig();
             console.log(`Already linked to ${info(`"${existing?.projectSlug ?? ''}"`)} ${muted(`(${existing?.projectGuid ?? ''})`)}`);
-            // Re-run setup in case hooks/skills are missing. Claude Code hooks
-            // only matter when the Claude primer is being written.
-            if (wantsClaude)
-                setupClaudeHooks();
-            writeAllPrimers();
-            setupGitignore();
+            // Re-run setup in case primers/hooks/skills are missing - each tool's
+            // integration self-gates on its binary and current-version state.
+            setupProjectTools(tools);
             // The config's ignore list was frozen at link time, so a workstation
             // artifact introduced by a newer CLI (e.g. aider's .aider.conf.yml)
             // would sync up as project content. Union in the current defaults.
@@ -143,7 +137,7 @@ Working with an existing Gipity project:
             const sizeStr = scan.truncated ? `>${formatBytes(ADOPT_THRESHOLDS.REFUSE_BYTES)}` : formatBytes(scan.bytes);
             const fileStr = scan.truncated ? `>${ADOPT_THRESHOLDS.REFUSE_FILES}` : `${scan.files}`;
             console.error(clrError(`Directory has ${fileStr} files (${sizeStr}) - too large to adopt as a Gipity project.`));
-            console.error(muted('Move into a subdirectory, or use `gipity claude` and pick "Create new project".'));
+            console.error(muted('Move into a subdirectory, or use `gipity build` and pick "Create new project".'));
             process.exit(1);
         }
         if (scan.tier === 'moderate') {
@@ -183,7 +177,7 @@ Working with an existing Gipity project:
         }
         console.log(success(`Wrote primer files: ${primerSummary}.`));
         if (wantsClaude) {
-            console.log(success('Ready! Run `gipity claude` for Claude Code, or open this directory in your other AI coding tool.'));
+            console.log(success('Ready! Run your coding agent here (claude, codex, grok), or `gipity build` to launch one with a picker.'));
             // Recording happens by default (however Claude Code is launched), so
             // say so up front - consent should be explicit, not discovered later.
             if (opts.capture === false) {