gipity 1.0.347 → 1.0.356

package/README.md

@@ -141,7 +141,7 @@ gipity sync down     # Pull remote changes
 | `gipity add <template>` | Add a template (web-simple, 2d-game, 3d-world, web-fullstack, api) |
 | `gipity test` | Run project tests in sandboxed containers |
 | `gipity logs fn <name>` | View function execution logs |
-| `gipity page-inspect <url>` | Inspect a URL: console errors, performance, failed resources |
+| `gipity page inspect <url>` | Inspect a URL: console errors, performance, failed resources |
 | `gipity records` | Query and manage Records API tables |
 | `gipity fn` | Manage and call serverless functions |
 | `gipity rbac` | Manage RBAC policies |

package/dist/adopt-cwd.js

@@ -241,6 +241,7 @@ export async function adoptCurrentDir(opts) {
         dir: opts.cwd,
         projectGuid: project.short_guid,
         projectSlug: project.slug,
+        projectName: project.name,
         accountSlug: opts.accountSlug,
         agentGuid,
         sync: 'strict',

package/dist/commands/add.js

@@ -1,3 +1,6 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
 import { Command } from 'commander';
 import { post } from '../api.js';
 import { requireConfig } from '../config.js';
@@ -27,12 +30,113 @@ function printCatalog() {
     for (const k of KITS)
         console.log(`  ${k.key}  ${muted('- ' + k.hint)}`);
     console.log('');
-    console.log(muted('Usage: gipity add <name> [--title <t>] [--description <d>] [--force]'));
+    console.log(`${bold('Local path')}  ${muted('- install from a directory on disk (template or kit)')}`);
+    console.log(`  ${muted('gipity add ./path/to/template  (or ~/path, /abs/path)')}`);
+    console.log(`  ${muted('gipity add ./path/to/kit       (auto-detected via package.json gipity.install)')}`);
     console.log('');
+    console.log(muted('Usage: gipity add <name|path> [--title <t>] [--description <d>] [--force]'));
+    console.log('');
+}
+// ─── Local-path payload mode ────────────────────────────────────────────────
+//
+// `gipity add ./path/to/template` walks a directory and ships the contents to
+// the server as a JSON payload, instead of asking the server to look the name
+// up in its bundled catalog. This is the dev loop for template authors: you
+// can iterate on `registry/templates/<name>/` and push to a real app without
+// having to redeploy the server.
+//
+// The server-side wire shape this builds matches addSchema.files in
+// platform/server/src/routes/projects/add.ts (same field names, same encoding
+// discriminator).
+const TEXT_EXTENSIONS = new Set([
+    '.html', '.htm', '.css', '.js', '.mjs', '.ts', '.tsx', '.jsx',
+    '.json', '.yaml', '.yml', '.toml',
+    '.md', '.markdown', '.txt', '.csv', '.xml', '.svg',
+    '.py', '.sh', '.bash', '.sql',
+    '.env', '.gitignore', '.dockerignore',
+]);
+// Anything not in TEXT_EXTENSIONS gets base64 - safer than guessing. The
+// server-side BINARY_MIME table maps the extension back to a content-type.
+const SKIP_DIR_NAMES = new Set([
+    'node_modules', '.git', 'dist', 'build', '__pycache__', '.next', '.vite',
+    '.gipity', // local project state dir - never belongs in a template payload
+]);
+const SKIP_FILE_NAMES = new Set(['.DS_Store', 'Thumbs.db']);
+const MAX_PAYLOAD_BYTES = 25 * 1024 * 1024; // 25 MB (server caps body at 30 MB)
+const MAX_FILES = 500;
+function looksLikePath(name) {
+    // ./ or ../ or absolute / or ~/ - and any string that already contains a
+    // separator (cross-platform: forward or back slash). Bare catalog keys like
+    // "web-simple" or "karaoke-captions" hit the server lookup path; anything
+    // that walks a filesystem hits payload mode.
+    return /^[./~]/.test(name) || name.includes('/') || name.includes('\\');
+}
+function resolveLocalPath(input) {
+    if (input.startsWith('~'))
+        return path.resolve(os.homedir() + input.slice(1));
+    return path.resolve(input);
+}
+/** Sniff whether a local-path payload is a kit or a template, mirroring the
+ *  server-side sniff in routes/projects/add.ts. Templates ship `gipity.yaml`
+ *  at the root; kits ship `package.json` with a `gipity.install` block. The
+ *  CLI sends the result as a `kind` hint so the server doesn't have to
+ *  re-do the sniff on the encoded payload. */
+function sniffPayloadKind(files) {
+    const pkg = files.find(f => f.path === 'package.json');
+    if (!pkg)
+        return 'template';
+    if (pkg.encoding !== 'utf8')
+        return 'template'; // base64'd package.json would be weird; default to template
+    try {
+        const manifest = JSON.parse(pkg.content);
+        if (manifest?.gipity?.install)
+            return 'kit';
+    }
+    catch { /* fall through */ }
+    return 'template';
+}
+function buildLocalPayload(rootDir) {
+    const stat = fs.statSync(rootDir);
+    if (!stat.isDirectory()) {
+        throw new Error(`Not a directory: ${rootDir}`);
+    }
+    const files = [];
+    let totalBytes = 0;
+    function walk(dir, prefix) {
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            if (entry.isDirectory()) {
+                if (SKIP_DIR_NAMES.has(entry.name))
+                    continue;
+                walk(path.join(dir, entry.name), prefix ? `${prefix}/${entry.name}` : entry.name);
+                continue;
+            }
+            if (!entry.isFile())
+                continue; // skip symlinks, sockets, etc.
+            if (SKIP_FILE_NAMES.has(entry.name))
+                continue;
+            if (files.length >= MAX_FILES) {
+                throw new Error(`Too many files (>${MAX_FILES}). Trim the template or raise the server cap.`);
+            }
+            const fullPath = path.join(dir, entry.name);
+            const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
+            const ext = path.extname(entry.name).toLowerCase();
+            const buf = fs.readFileSync(fullPath);
+            const isText = TEXT_EXTENSIONS.has(ext);
+            const content = isText ? buf.toString('utf8') : buf.toString('base64');
+            const encoding = isText ? 'utf8' : 'base64';
+            totalBytes += content.length;
+            if (totalBytes > MAX_PAYLOAD_BYTES) {
+                throw new Error(`Payload exceeds ${Math.round(MAX_PAYLOAD_BYTES / 1024 / 1024)} MB cap.`);
+            }
+            files.push({ path: relPath, content, encoding });
+        }
+    }
+    walk(rootDir, '');
+    return { name: path.basename(rootDir), files };
 }
 export const addCommand = new Command('add')
-    .description('Add a template (scaffold an app) or a kit (reusable building block) to the project')
-    .argument('[name]', 'Template or kit key - omit to list the catalog')
+    .description('Add a template (scaffold an app) or a kit (reusable building block) to the project. Pass ./path/to/dir to install a local template directly.')
+    .argument('[name]', 'Template/kit key, OR a local directory path (./, ~/, or /abs). Omit to list the catalog.')
     .option('--title <title>', 'App title - templates only (defaults to project name)')
     .option('--description <desc>', 'App description for meta tags - templates only')
     .option('--force', 'Templates only: overwrite any colliding files')
@@ -43,12 +147,35 @@ export const addCommand = new Command('add')
         return;
     }
     const config = requireConfig();
-    const res = await post(`/projects/${config.projectGuid}/add`, {
-        name,
-        title: opts.title,
-        description: opts.description,
-        force: opts.force,
-    });
+    // Local-path payload mode kicks in when `name` looks like a path - bare
+    // names still go through the server's bundled catalog like before.
+    let body;
+    if (looksLikePath(name)) {
+        const resolved = resolveLocalPath(name);
+        if (!fs.existsSync(resolved)) {
+            throw new Error(`Local template/kit not found: ${resolved}`);
+        }
+        const { name: labelName, files } = buildLocalPayload(resolved);
+        const kind = sniffPayloadKind(files);
+        console.log(muted(`Uploading ${files.length} file(s) from ${resolved} (${kind}) ...`));
+        body = {
+            name: labelName,
+            title: opts.title,
+            description: opts.description,
+            force: opts.force,
+            files,
+            kind,
+        };
+    }
+    else {
+        body = {
+            name,
+            title: opts.title,
+            description: opts.description,
+            force: opts.force,
+        };
+    }
+    const res = await post(`/projects/${config.projectGuid}/add`, body);
     // Pull the created/installed files down to local.
     const syncResult = await sync({ interactive: false });
     const data = res.data;

package/dist/commands/logs.js

@@ -33,4 +33,83 @@ logsCommand
         console.log(`  ${muted(time)}  ${status} ${dur} ${trigger}${err}`);
     }
 }));
+logsCommand
+    .command('app')
+    .description('Unified recent activity for this app — JS errors, failed function calls, failed services, network failures. Designed for agents debugging a deployed app.')
+    .option('--since <window>', "Window: 5m / 10m / 30m / 1h / 6h / 24h / 7d", '10m')
+    .option('--severity <level>', 'error | warn | network | all', 'all')
+    .option('--type <list>', "Comma-separated: errors,functions,services,traffic. Default excludes traffic (high volume).")
+    .option('--filter <pattern>', 'Substring match against message / fn name / path (case-insensitive)')
+    .option('--limit <n>', 'Max entries', '100')
+    .option('--json', 'Output as JSON (parseable by agents / pipes)')
+    .addHelpText('after', `
+Examples:
+  $ gipity logs app                              Last 10 min of errors + fn failures
+  $ gipity logs app --since 1h                   Last hour
+  $ gipity logs app --severity network           Only fetch/XHR failures
+  $ gipity logs app --filter song-create         Anything mentioning song-create
+  $ gipity logs app --type errors                Only JS errors
+  $ gipity logs app --json | jq .data.entries[0] Pipe-friendly
+`)
+    .action((opts) => run('App logs', async () => {
+    const config = requireConfig();
+    const limit = parseInt(opts.limit, 10) || 100;
+    const qs = new URLSearchParams();
+    qs.set('since', String(opts.since));
+    qs.set('severity', String(opts.severity));
+    if (opts.type)
+        qs.set('type', String(opts.type));
+    if (opts.filter)
+        qs.set('filter', String(opts.filter));
+    qs.set('limit', String(limit));
+    const res = await get(`/projects/${config.projectGuid}/logs/app?${qs.toString()}`);
+    if (opts.json) {
+        console.log(JSON.stringify(res.data));
+        return;
+    }
+    const { entries, since, types, severity, truncated } = res.data;
+    if (entries.length === 0) {
+        console.log(`No activity in the last ${since} ${muted(`(severity=${severity} types=${types.join(',')})`)}.`);
+        return;
+    }
+    console.log(`${bold(`Recent activity`)} ${muted(`(last ${since}, ${entries.length}${truncated ? '+' : ''} entries, severity=${severity})`)}\n`);
+    for (const e of entries) {
+        const time = new Date(e.at).toLocaleTimeString('en-US', { hour12: false, hour: '2-digit', minute: '2-digit', second: '2-digit' });
+        const kindColor = e.kind === 'error' ? clrError : e.kind === 'function' ? warning : e.kind === 'service' ? warning : muted;
+        const kindTag = kindColor(`[${e.kind.padEnd(8)}]`);
+        console.log(`${muted(time)} ${kindTag} ${e.summary}`);
+        // Per-kind drilldown lines — what an agent most often needs without
+        // having to re-fetch the row.
+        const d = e.detail;
+        if (e.kind === 'error') {
+            const capturedBy = d.captured_by;
+            const url = d.network_url;
+            const status = d.network_status;
+            if (url)
+                console.log(`             ${muted(`${capturedBy} → ${d.network_method || 'GET'} ${url} (${status ?? 'failed'})`)}`);
+            if (d.network_response_snippet)
+                console.log(`             ${muted(`resp: ${String(d.network_response_snippet).slice(0, 160)}`)}`);
+            const corr = d.correlated_function_log;
+            if (corr) {
+                console.log(`             ${muted(`└─ server fn ${corr.function_name} → ${corr.status}${corr.error_message ? ': ' + String(corr.error_message).slice(0, 100) : ''}`)}`);
+            }
+            const breadcrumbs = d.breadcrumbs;
+            if (breadcrumbs && breadcrumbs.length > 0) {
+                const lastFew = breadcrumbs.slice(-3).map(b => `${b.kind}${b.detail?.selector || b.detail?.url || b.detail?.path ? `:${b.detail.selector || b.detail.url || b.detail.path}` : ''}`).join(' → ');
+                console.log(`             ${muted(`crumbs: ${lastFew}`)}`);
+            }
+        }
+        if (e.kind === 'function') {
+            const dur = d.duration_ms;
+            console.log(`             ${muted(`${d.trigger_type} • ${dur ?? '?'}ms`)}${d.error_message ? muted(' • ') + clrError(String(d.error_message).slice(0, 200)) : ''}`);
+        }
+        if (e.kind === 'service') {
+            const dur = d.latency_ms;
+            console.log(`             ${muted(`${d.service} (${d.provider ?? '?'}/${d.model ?? '?'}) • ${dur ?? '?'}ms`)}${d.error_message ? muted(' • ') + clrError(String(d.error_message).slice(0, 200)) : ''}`);
+        }
+    }
+    if (truncated) {
+        console.log(`\n${muted(`(truncated at ${limit} entries — bump --limit or narrow --filter)`)}`);
+    }
+}));
 //# sourceMappingURL=logs.js.map

package/dist/commands/page-eval.js

@@ -0,0 +1,31 @@
+import { Command } from 'commander';
+import { post } from '../api.js';
+import { brand, bold, muted } from '../colors.js';
+import { run } from '../helpers/index.js';
+// The long-tail escape hatch alongside `page inspect`'s fixed bundle: when the
+// curated metrics don't cover what you need (computed styles, element rects,
+// visibility, z-index stacks), eval an expression in page context and get the
+// serialized result back. Runs in the same browser sandbox as inspect.
+export const pageEvalCommand = new Command('eval')
+    .description('Evaluate a JS expression in a real browser on a page (DOM, computed styles, element rects)')
+    .argument('<url>', 'URL to load')
+    .argument('<expr>', 'JavaScript expression to evaluate in page context (result is JSON-serialized)')
+    .option('--wait <ms>', 'Sleep this many ms after DOMContentLoaded before evaluating (lets late async work settle)', '500')
+    .option('--json', 'Output as JSON')
+    .action((url, expr, opts) => run('Page eval', async () => {
+    const parsedWait = parseInt(opts.wait, 10);
+    const waitMs = Number.isFinite(parsedWait) && parsedWait >= 0 ? parsedWait : 500;
+    const res = await post('/tools/browser/eval', { url, expr, waitMs });
+    const d = res.data;
+    if (opts.json) {
+        console.log(JSON.stringify(d));
+        return;
+    }
+    console.log(`\n${brand('Eval')} ${bold(d.url || url)}`);
+    console.log(`  ${muted('Expression:')} ${expr}`);
+    console.log(`\n${d.result || muted('(empty result)')}`);
+    if (d.truncated)
+        console.log(muted('\n(result truncated to fit context - narrow the expression for the full value)'));
+    console.log('');
+}));
+//# sourceMappingURL=page-eval.js.map

package/dist/commands/page-inspect.js

@@ -1,4 +1,4 @@
-import { Command } from 'commander';
+import { Command, Option } from 'commander';
 import { post } from '../api.js';
 import { formatSize } from '../utils.js';
 import { brand, bold, error as clrError, warning, muted, info } from '../colors.js';
@@ -19,78 +19,107 @@ function shortUrl(url, truncate = true, maxLen = 100) {
     const tailLen = Math.floor(keep / 2);
     return result.slice(0, headLen) + '…' + result.slice(-tailLen);
 }
-export const pageInspectCommand = new Command('page-inspect')
-    .description('Inspect a web page')
+export const pageInspectCommand = new Command('inspect')
+    .description('Inspect a web page (console, failed resources, timing, layout overflow)')
     .argument('<url>', 'URL to inspect')
     .option('--wait <ms>', 'Sleep this many ms after DOMContentLoaded before capturing (lets late async/LCP work settle)', '500')
     .option('--json', 'Output as JSON')
     .option('--no-truncate', 'Show full URLs instead of truncating long ones with middle-ellipsis')
-    .option('--all', 'Include render-blocking, large resources, oversized images, and LCP detail')
-    .action((url, opts) => run('Page inspect', async () => {
-    const parsedWait = parseInt(opts.wait, 10);
-    const waitMs = Number.isFinite(parsedWait) && parsedWait >= 0 ? parsedWait : 500;
-    const truncate = opts.truncate !== false;
-    const showAll = opts.all === true;
-    const res = await post(`/tools/browser/inspect`, { url, waitMs });
-    const b = res.data;
-    if (opts.json) {
-        console.log(JSON.stringify(b));
-        return;
+    .option('--all', 'Include render-blocking, large resources, oversized images, overflow culprits, and LCP detail')
+    // Hidden redirect: agents reach for `page inspect --screenshot`. We don't take
+    // an image here (`page screenshot` is the single path for that) — just point there.
+    .addOption(new Option('--screenshot [path]', 'Capture a screenshot').hideHelp())
+    .action((url, opts) => {
+    if (opts.screenshot !== undefined) {
+        console.error(clrError('page inspect does not capture screenshots. Use page screenshot:'));
+        console.error(`  gipity page screenshot ${url}${typeof opts.screenshot === 'string' ? ` -o ${opts.screenshot}` : ''}`);
+        process.exit(1);
     }
-    const timing = b.timing || { ttfb: 0, domReady: 0, load: 0 };
-    // ── Page Info ──
-    console.log(`\n${brand('Inspecting')} ${bold(b.url || url)}`);
-    console.log(`  ${muted('Title:')} ${b.title || '(none)'}`);
-    console.log(`  ${muted('Elements:')} ${b.elementCount || 0}`);
-    console.log(`  ${muted('Page weight:')} ${info(formatSize(b.totalBytes || 0))}`);
-    // ── Timing ──
-    console.log(`\n  ${bold('Timing:')}`);
-    console.log(`    ${muted('TTFB:')} ${timing.ttfb}ms`);
-    console.log(`    ${muted('DOM ready:')} ${timing.domReady}ms`);
-    console.log(`    ${muted('Load:')} ${timing.load}ms`);
-    if (showAll && b.lcp) {
-        console.log(`    LCP: ${b.lcp.time}ms (${b.lcp.element}${b.lcp.url ? ' ' + shortUrl(b.lcp.url, truncate) : ''})`);
-    }
-    // ── Console ──
-    if (b.console?.length > 0) {
-        console.log(`\n  ${bold('Console')} ${muted(`(${b.console.length})`)}:`);
-        for (const line of b.console) {
-            console.log(`    ${warning(line)}`);
+    return run('Page inspect', async () => {
+        const parsedWait = parseInt(opts.wait, 10);
+        const waitMs = Number.isFinite(parsedWait) && parsedWait >= 0 ? parsedWait : 500;
+        const truncate = opts.truncate !== false;
+        const showAll = opts.all === true;
+        const res = await post(`/tools/browser/inspect`, { url, waitMs });
+        const b = res.data;
+        if (opts.json) {
+            console.log(JSON.stringify(b));
+            return;
         }
-    }
-    else {
-        console.log(`\n  ${bold('Console:')} ${muted('(clean)')}`);
-    }
-    // ── Failed Resources ──
-    if (b.failedResources?.length > 0) {
-        console.log(`\n  ${clrError(`Failed resources (${b.failedResources.length}):`)}`);
-        for (const r of b.failedResources) {
-            console.log(`    ${clrError(r)}`);
+        const timing = b.timing || { ttfb: 0, domReady: 0, load: 0 };
+        // ── Page Info ──
+        console.log(`\n${brand('Inspecting')} ${bold(b.url || url)}`);
+        console.log(`  ${muted('Title:')} ${b.title || '(none)'}`);
+        console.log(`  ${muted('Elements:')} ${b.elementCount || 0}`);
+        console.log(`  ${muted('Page weight:')} ${info(formatSize(b.totalBytes || 0))}`);
+        // ── Timing ──
+        console.log(`\n  ${bold('Timing:')}`);
+        console.log(`    ${muted('TTFB:')} ${timing.ttfb}ms`);
+        console.log(`    ${muted('DOM ready:')} ${timing.domReady}ms`);
+        console.log(`    ${muted('Load:')} ${timing.load}ms`);
+        if (showAll && b.lcp) {
+            console.log(`    LCP: ${b.lcp.time}ms (${b.lcp.element}${b.lcp.url ? ' ' + shortUrl(b.lcp.url, truncate) : ''})`);
         }
-    }
-    if (showAll) {
-        // ── Render Blocking ──
-        if (b.renderBlocking?.length > 0) {
-            console.log(`\n  ${warning(`Render-blocking (${b.renderBlocking.length}):`)}`);
-            for (const r of b.renderBlocking) {
-                console.log(`    ${shortUrl(r, truncate)}`);
+        // ── Console ──
+        if (b.console?.length > 0) {
+            console.log(`\n  ${bold('Console')} ${muted(`(${b.console.length})`)}:`);
+            for (const line of b.console) {
+                console.log(`    ${warning(line)}`);
             }
         }
-        // ── Large Resources ──
-        if (b.largeResources?.length > 0) {
-            console.log(`\n  ${warning(`Large resources >100KB (${b.largeResources.length}):`)}`);
-            for (const r of b.largeResources) {
-                console.log(`    ${info(formatSize(r.size).padEnd(10))} ${muted(r.type.padEnd(8))} ${shortUrl(r.url, truncate)}`);
+        else {
+            console.log(`\n  ${bold('Console:')} ${muted('(clean)')}`);
+        }
+        // ── Failed Resources ──
+        if (b.failedResources?.length > 0) {
+            console.log(`\n  ${clrError(`Failed resources (${b.failedResources.length}):`)}`);
+            for (const r of b.failedResources) {
+                console.log(`    ${clrError(r)}`);
             }
         }
-        // ── Oversized Images ──
-        if (b.oversizedImages?.length > 0) {
-            console.log(`\n  ${warning(`Oversized images (${b.oversizedImages.length}):`)}`);
-            for (const img of b.oversizedImages) {
-                console.log(`    ${img.natural} served, ${img.displayed} displayed - ${shortUrl(img.src, truncate)}`);
+        // ── Layout (horizontal overflow) ──
+        if (b.overflow) {
+            if (b.overflow.overflowX) {
+                console.log(`\n  ${clrError(`Horizontal overflow: +${b.overflow.amount}px`)} ${muted(`(content ${b.overflow.scrollWidth}px vs viewport ${b.overflow.clientWidth}px)`)}`);
+                if (showAll && b.overflow.culprits.length > 0) {
+                    console.log(`  ${muted('Overflowing elements:')}`);
+                    for (const c of b.overflow.culprits) {
+                        const sel = c.cls ? `${c.tag}.${c.cls.split(/\s+/)[0]}` : c.tag;
+                        console.log(`    ${sel} ${muted(`(right ${c.right}px, width ${c.width}px)`)}`);
+                    }
+                }
+                else if (b.overflow.culprits.length > 0) {
+                    console.log(`    ${muted(`${b.overflow.culprits.length} overflowing element(s) - use --all to list`)}`);
+                }
+            }
+            else {
+                console.log(`\n  ${bold('Layout:')} ${muted('no horizontal overflow')}`);
             }
         }
-    }
-    console.log('');
-}));
+        if (showAll) {
+            // ── Render Blocking ──
+            if (b.renderBlocking?.length > 0) {
+                console.log(`\n  ${warning(`Render-blocking (${b.renderBlocking.length}):`)}`);
+                for (const r of b.renderBlocking) {
+                    console.log(`    ${shortUrl(r, truncate)}`);
+                }
+            }
+            // ── Large Resources ──
+            if (b.largeResources?.length > 0) {
+                console.log(`\n  ${warning(`Large resources >100KB (${b.largeResources.length}):`)}`);
+                for (const r of b.largeResources) {
+                    console.log(`    ${info(formatSize(r.size).padEnd(10))} ${muted(r.type.padEnd(8))} ${shortUrl(r.url, truncate)}`);
+                }
+            }
+            // ── Oversized Images ──
+            if (b.oversizedImages?.length > 0) {
+                console.log(`\n  ${warning(`Oversized images (${b.oversizedImages.length}):`)}`);
+                for (const img of b.oversizedImages) {
+                    console.log(`    ${img.natural} served, ${img.displayed} displayed - ${shortUrl(img.src, truncate)}`);
+                }
+            }
+        }
+        console.log('');
+    });
+});
 //# sourceMappingURL=page-inspect.js.map

package/dist/commands/page-screenshot.js

@@ -91,7 +91,7 @@ function splitCsv(values) {
 function appendOption(value, previous = []) {
     return [...previous, value];
 }
-export const pageScreenshotCommand = new Command('page-screenshot')
+export const pageScreenshotCommand = new Command('screenshot')
     .description('Screenshot a web page')
     .argument('<url>', 'URL to screenshot')
     .option('--post-load-delay <ms>', 'Delay after DOMContentLoaded before capture, in ms', '1000')

package/dist/commands/page.js

@@ -0,0 +1,18 @@
+import { Command } from 'commander';
+import { pageInspectCommand } from './page-inspect.js';
+import { pageScreenshotCommand } from './page-screenshot.js';
+import { pageEvalCommand } from './page-eval.js';
+// Parent namespace grouping the page/browser diagnostics under one command:
+//   gipity page inspect | eval | screenshot
+// Each subcommand is canonical for its capability; the namespace keeps the
+// top-level surface lean and makes the siblings discoverable via `page --help`.
+export const pageCommand = new Command('page')
+    .description('Inspect, evaluate, and screenshot web pages (page inspect | eval | screenshot)')
+    .addCommand(pageInspectCommand)
+    .addCommand(pageEvalCommand)
+    .addCommand(pageScreenshotCommand);
+// No subcommand → show help instead of commander's terse error.
+pageCommand.action(() => {
+    pageCommand.help();
+});
+//# sourceMappingURL=page.js.map

package/dist/commands/project.js

@@ -85,6 +85,7 @@ projectCommand
         dir,
         projectGuid: project.short_guid,
         projectSlug: project.slug,
+        projectName: project.name,
         accountSlug,
         agentGuid,
         sync: 'soft',

package/dist/commands/workflow.js

@@ -3,10 +3,7 @@ import { get, post, put, del } from '../api.js';
 import { requireConfig } from '../config.js';
 import { success, error as clrError, muted, bold } from '../colors.js';
 import { run, printList, printResult } from '../helpers/index.js';
-export const workflowCommand = new Command('workflow')
-    .description('Manage workflows')
-    .option('--json', 'Output as JSON')
-    .action((opts) => run('Workflow', async () => {
+async function listWorkflows(opts) {
     const res = await get('/workflows');
     if (opts.json) {
         console.log(JSON.stringify(res));
@@ -23,7 +20,16 @@ export const workflowCommand = new Command('workflow')
         const line = `${bold(w.name)}  [${statusText}]  ${muted(w.trigger_type)}${cron}${proj}`;
         return w.description ? `${line}\n  ${muted(w.description)}` : line;
     });
-}));
+}
+export const workflowCommand = new Command('workflow')
+    .description('Manage workflows')
+    .option('--json', 'Output as JSON')
+    .action((opts) => run('Workflow', () => listWorkflows(opts)));
+workflowCommand
+    .command('list')
+    .description('List workflows')
+    .option('--json', 'Output as JSON')
+    .action((opts) => run('List', () => listWorkflows(opts)));
 workflowCommand
     .command('info <name>')
     .description('Show workflow details')
@@ -71,7 +77,9 @@ workflowCommand
             ? `${((new Date(r.completed_at).getTime() - new Date(r.started_at).getTime()) / 1000).toFixed(1)}s`
             : 'running';
         const statusColor = r.status === 'completed' ? success : r.status === 'failed' ? clrError : muted;
-        return `${muted(r.short_guid)}  ${statusColor(r.status)}  ${dur}  ${r.total_tokens} tokens  ${muted(new Date(r.started_at).toLocaleString())}`;
+        const line = `${muted(r.short_guid)}  ${statusColor(r.status)}  ${dur}  ${r.total_tokens} tokens  ${muted(new Date(r.started_at).toLocaleString())}`;
+        // Surface why a run failed inline so you don't have to hit the REST API.
+        return r.error_message ? `${line}\n  ${clrError(r.error_message)}` : line;
     });
 }));
 workflowCommand
@@ -80,8 +88,12 @@ workflowCommand
     .option('--json', 'Output as JSON')
     .action((name, opts) => run('Enable', async () => {
     const wf = await resolveWorkflow(name);
-    await put(`/workflows/${wf.short_guid}`, { is_active: true });
-    printResult(`Enabled "${wf.name}".`, opts, { enabled: wf.name });
+    const res = await put(`/workflows/${wf.short_guid}`, { is_active: true });
+    if (!res.data?.is_active) {
+        console.error(clrError(`Workflow "${wf.name}" is still inactive after enable — not enabled.`));
+        process.exit(1);
+    }
+    printResult(`Enabled "${wf.name}".`, opts, { enabled: wf.name, is_active: true });
 }));
 workflowCommand
     .command('disable <name>')
@@ -89,8 +101,12 @@ workflowCommand
     .option('--json', 'Output as JSON')
     .action((name, opts) => run('Disable', async () => {
     const wf = await resolveWorkflow(name);
-    await put(`/workflows/${wf.short_guid}`, { is_active: false });
-    printResult(`Disabled "${wf.name}".`, opts, { disabled: wf.name });
+    const res = await put(`/workflows/${wf.short_guid}`, { is_active: false });
+    if (res.data?.is_active) {
+        console.error(clrError(`Workflow "${wf.name}" is still active after disable — not disabled.`));
+        process.exit(1);
+    }
+    printResult(`Disabled "${wf.name}".`, opts, { disabled: wf.name, is_active: false });
 }));
 workflowCommand
     .command('create')
@@ -132,15 +148,46 @@ workflowCommand
     .action((name, opts) => run('Delete', async () => {
     const wf = await resolveWorkflow(name);
     await del(`/workflows/${wf.short_guid}`);
-    printResult(`Deleted "${wf.name}".`, opts, { deleted: wf.name });
+    // Delete is a soft-delete (is_active → 0). Verify the targeted record
+    // actually went inactive rather than trusting the request was accepted.
+    const after = await get(`/workflows/${wf.short_guid}`);
+    if (after.data?.is_active) {
+        console.error(clrError(`Workflow "${wf.name}" (${wf.short_guid}) is still active — delete had no effect.`));
+        process.exit(1);
+    }
+    printResult(`Deleted "${wf.name}".`, opts, { deleted: wf.name, short_guid: wf.short_guid });
 }));
+// Resolve a workflow by name within the linked project (like `gipity fn`), or
+// by short_guid anywhere. Names are unique per active project workflow (DB
+// constraint), so a bare name in this project is unambiguous; the same name in
+// another project is a different workflow and simply isn't matched here.
 async function resolveWorkflow(name) {
-    const res = await get('/workflows');
-    const match = res.data.find(w => w.name === name || w.short_guid === name);
-    if (!match) {
-        console.error(clrError(`Workflow "${name}" not found.`));
+    const { projectGuid } = requireConfig();
+    const res = await get(`/projects/${projectGuid}/workflows`);
+    const list = res.data ?? [];
+    // Exact short_guid match wins — unambiguous override.
+    const byGuid = list.find(w => w.short_guid === name);
+    if (byGuid)
+        return byGuid;
+    const byName = list.filter(w => w.name === name);
+    if (byName.length === 0) {
+        // Fall back to a global short_guid lookup (e.g. account-level workflows).
+        const all = await get('/workflows');
+        const global = (all.data ?? []).find(w => w.short_guid === name);
+        if (global)
+            return global;
+        console.error(clrError(`Workflow "${name}" not found in this project.`));
         process.exit(1);
     }
-    return match;
+    if (byName.length === 1)
+        return byName[0];
+    // More than one (an active + soft-deleted carrying the same name): prefer the
+    // active one; refuse if still ambiguous.
+    const active = byName.filter(w => w.is_active);
+    if (active.length === 1)
+        return active[0];
+    console.error(clrError(`${byName.length} workflows named "${name}" in this project — pass a short_guid:\n` +
+        byName.map(w => `  ${w.short_guid}${w.is_active ? '' : ' (inactive)'}`).join('\n')));
+    process.exit(1);
 }
 //# sourceMappingURL=workflow.js.map