gipity 1.1.2 → 1.1.4

package/dist/commands/test.js

@@ -31,6 +31,27 @@ function printSkippedCandidates(skipped) {
         console.log(muted(`  ... and ${skipped.length - 10} more`));
     console.log(muted('Run frontend/kit module tests in the sandbox: gipity sandbox run bash "node <file>"'));
 }
+/** Tests call functions over REST (`ctx.fn.call`), which resolves against the
+ *  DEPLOYED functions — a function that's only been written locally isn't
+ *  registered yet, so its call 404s with `Function 'name' not found`. Running
+ *  `gipity test` right after writing a function (before deploying) is a natural
+ *  instinct, and the bare 404 gives no hint that a deploy is the missing step.
+ *  Detect that exact failure shape and name the fix. Returns the distinct
+ *  function names that 404'd, or [] when no failure looks like this. */
+function undeployedFunctionsFromFailures(results) {
+    const names = new Set();
+    for (const r of results) {
+        if (r.status !== 'failed' || !r.error)
+            continue;
+        // Shape: "Function <name> failed: 404 NOT_FOUND - Function '<name>' not found"
+        if (!/404\b/.test(r.error) || !/not\s+found/i.test(r.error))
+            continue;
+        const m = r.error.match(/Function ['"]?([\w-]+)['"]? (?:not found|failed)/i);
+        if (m)
+            names.add(m[1]);
+    }
+    return [...names];
+}
 // Long-run hint for non-TTY runs: after this, print a one-time "not hung" + faster-path hint.
 const LONG_RUN_MS = 60000;
 async function pollTestStatus(projectGuid, runGuid, opts) {
@@ -226,6 +247,17 @@ export const testCommand = new Command('test')
         }
         console.log('');
     }
+    // Tests call functions against the DEPLOYED build, so a function written
+    // but not yet deployed 404s. That ordering (deploy → test) is invisible in
+    // a bare 404, so when we see that failure shape, name the fix once.
+    const undeployed = undeployedFunctionsFromFailures(data.results);
+    if (undeployed.length > 0) {
+        const list = undeployed.map((n) => `'${n}'`).join(', ');
+        console.log(warning(`${undeployed.length === 1 ? 'Function' : 'Functions'} ${list} 404'd: tests call functions against the ` +
+            `DEPLOYED build, and ${undeployed.length === 1 ? 'this one is' : 'these are'} not deployed yet.`));
+        console.log(muted('Deploy first, then re-run: gipity deploy dev && gipity test'));
+        console.log('');
+    }
     // Summary
     const parts = [];
     if (data.passed > 0)

package/dist/commands/update.js

@@ -16,6 +16,10 @@ export const updateCommand = new Command('update')
     }
     else {
         console.log(warning(`No update applied: ${result.reason}`));
+        if (result.reason?.startsWith('npm install')) {
+            console.log(dim('Full npm output: ~/.gipity/update.log'));
+            console.log(dim('If it keeps failing, delete ~/.gipity/local and run any gipity command to reinstall.'));
+        }
     }
 });
 //# sourceMappingURL=update.js.map

package/dist/commands/upload.js

@@ -1,130 +1,78 @@
 import { Command } from 'commander';
-import { statSync, readdirSync } from 'fs';
-import { join, basename, posix, resolve, dirname } from 'path';
+import { statSync } from 'fs';
+import { basename } from 'path';
+import { post } from '../api.js';
 import { resolveProjectContext } from '../config.js';
-import { uploadOneFile, UPLOAD_CONCURRENCY } from '../upload.js';
+import { transferToS3, guessMime } from '../upload.js';
 import { formatSize } from '../utils.js';
-import { error as clrError, dim } from '../colors.js';
-/** Walk a directory recursively, returning every file's absolute path. */
-function walkFiles(root) {
-    const out = [];
-    const stack = [root];
-    while (stack.length) {
-        const dir = stack.pop();
-        for (const entry of readdirSync(dir, { withFileTypes: true })) {
-            const full = join(dir, entry.name);
-            if (entry.isDirectory())
-                stack.push(full);
-            else if (entry.isFile())
-                out.push(full);
-        }
-    }
-    return out;
-}
-/** Compose the destination virtual path for a given source file under a recursive walk. */
-function destFor(localFile, srcRoot, destRoot) {
-    // POSIX-style virtual paths regardless of host OS.
-    const rel = localFile.slice(srcRoot.length).replace(/\\/g, '/').replace(/^\/+/, '');
-    return posix.join(destRoot.replace(/\\/g, '/').replace(/\/$/, ''), rel);
-}
+import { success, muted, brand } from '../colors.js';
+import { withSpinner } from '../progress.js';
+import { run } from '../helpers/index.js';
+// The app-uploads store (`/api/<guid>/uploads/*`) mints a DURABLE, worker-reachable
+// URL the instant the file lands - no `gipity deploy` needed. That is the whole
+// point of this command: it removes the deploy-a-fixture-then-delete-it dance an
+// agent otherwise has to do to hand a job/function a real input file to fetch.
+// (Uploading into the project tree with `gipity push` does NOT give a public URL
+// until you deploy; this does.)
 export const uploadCommand = new Command('upload')
-    .description('Upload files')
-    .argument('<src>', 'Local source file or directory')
-    .argument('[dest]', 'Destination path in the project (defaults to /)')
-    .option('-r, --recursive', 'Upload a directory recursively')
-    .option('--mime <type>', 'Override the content-type (default: detect from extension)')
-    .option('--concurrency <n>', `Parallel files (default ${UPLOAD_CONCURRENCY})`)
-    .option('--dry-run', 'Print what would be uploaded; do not call the network')
-    .option('--project <guid-or-slug>', 'Target a specific project instead of cwd / Home')
-    .action(async (src, destArg, opts) => {
+    .description(`Upload a local file and print a durable, worker-reachable URL for it.
+
+The URL works immediately - no \`gipity deploy\` - and any job or function can
+fetch it. Use it to hand a GPU/CPU job a real input file when testing end-to-end:
+
+  gipity upload song.mp3
+  gipity job submit split-stems --data '{"audio_url":"<printed url>"}'
+
+By default the file is PUBLIC: a plain \`media.gipity.ai\` CDN url that resolves
+from anywhere, so a cloud worker can always fetch it. Pass --private for a
+token-signed serve url instead (reachable only by holders of the url).`)
+    .argument('<file>', 'Local file to upload')
+    .option('--private', 'Store as a private token-signed serve URL instead of a public CDN url')
+    .option('--content-type <mime>', 'Override the content type (default: detected from the file extension)')
+    .option('--json', 'Output as JSON')
+    .action((file, opts) => run('Upload', async () => {
+    const { config } = await resolveProjectContext();
+    let size;
     try {
-        const { config } = await resolveProjectContext({ projectOverride: opts.project });
-        const dest = destArg ?? '/';
-        const srcStat = statSync(src);
-        // Collect the work plan.
-        const planned = [];
-        if (srcStat.isDirectory()) {
-            if (!opts.recursive) {
-                throw new Error(`${src} is a directory - pass -r/--recursive to upload it`);
-            }
-            // Slice from the parent of src so the directory name itself is preserved
-            // in the virtual path (e.g. `hooks/a.sh` → `hooks/a.sh`, not `a.sh`).
-            const srcAbs = resolve(src);
-            const sliceRoot = dirname(srcAbs);
-            for (const file of walkFiles(src)) {
-                planned.push({
-                    localPath: file,
-                    virtualPath: destFor(resolve(file), sliceRoot, dest),
-                    size: statSync(file).size,
-                });
-            }
-        }
-        else if (srcStat.isFile()) {
-            // If dest looks like a directory (ends in / or no extension on a file path), append basename.
-            const looksLikeDir = dest.endsWith('/') || (opts.recursive === true);
-            const virtualPath = looksLikeDir
-                ? posix.join(dest.replace(/\/$/, ''), basename(src))
-                : dest;
-            planned.push({ localPath: src, virtualPath, size: srcStat.size });
-        }
-        else {
-            throw new Error(`${src} is neither a regular file nor a directory`);
-        }
-        if (planned.length === 0) {
-            console.log('Nothing to upload (0 files).');
-            return;
-        }
-        const totalBytes = planned.reduce((s, f) => s + f.size, 0);
-        console.log(`Plan: ${planned.length} file${planned.length > 1 ? 's' : ''}, ${formatSize(totalBytes)}`);
-        for (const f of planned) {
-            console.log(`${f.localPath} ${dim('→')} ${f.virtualPath} (${formatSize(f.size)})`);
-        }
-        if (opts.dryRun) {
-            console.log('\n--dry-run: skipping all network calls.');
-            return;
-        }
-        const concurrency = Math.max(1, parseInt(opts.concurrency ?? String(UPLOAD_CONCURRENCY), 10));
-        const uploadOpts = { mime: opts.mime };
-        let cursor = 0;
-        let uploaded = 0, skipped = 0, resumed = 0, failed = 0;
-        const workers = [];
-        for (let w = 0; w < Math.min(concurrency, planned.length); w++) {
-            workers.push((async () => {
-                while (true) {
-                    const idx = cursor++;
-                    if (idx >= planned.length)
-                        return;
-                    const f = planned[idx];
-                    try {
-                        const result = await uploadOneFile(config.projectGuid, f.localPath, f.virtualPath, uploadOpts);
-                        if (result.status === 'skipped') {
-                            skipped++;
-                            console.log(`${dim('skip')} ${f.virtualPath} (already current)`);
-                        }
-                        else if (result.status === 'resumed') {
-                            resumed++;
-                            console.log(`${dim('resumed')} ${f.virtualPath} v${result.version}`);
-                        }
-                        else {
-                            uploaded++;
-                            console.log(`${dim('uploaded')} ${f.virtualPath} v${result.version}`);
-                        }
-                    }
-                    catch (err) {
-                        failed++;
-                        console.error(clrError(`  fail ${f.virtualPath}: ${err.message}`));
-                    }
-                }
-            })());
-        }
-        await Promise.all(workers);
-        console.log(`\nUploaded: ${uploaded}, Resumed: ${resumed}, Skipped: ${skipped}, Failed: ${failed}`);
-        if (failed > 0)
-            process.exit(1);
+        const st = statSync(file);
+        if (!st.isFile())
+            throw new Error('not a regular file');
+        size = st.size;
     }
     catch (err) {
-        console.error(clrError(`Upload failed: ${err.message}`));
-        process.exit(1);
+        throw new Error(`can't read ${file}: ${err.message}`);
+    }
+    if (size === 0)
+        throw new Error(`${file} is empty - nothing to upload.`);
+    const filename = basename(file);
+    const contentType = opts.contentType || guessMime(file);
+    const doUpload = async () => {
+        const init = await post(`/api/${config.projectGuid}/uploads/init`, {
+            filename,
+            content_type: contentType,
+            size,
+            public: !opts.private,
+        });
+        const fields = await transferToS3(file, size, contentType, init.data);
+        const completeBody = {
+            upload_guid: init.data.upload_guid,
+        };
+        // Multipart completion needs the part etags; a single presigned PUT does not.
+        if ('parts' in fields)
+            completeBody.parts = fields.parts;
+        const comp = await post(`/api/${config.projectGuid}/uploads/complete`, completeBody);
+        return comp.data;
+    };
+    const data = opts.json
+        ? await doUpload()
+        : await withSpinner(`Uploading ${filename} (${formatSize(size)})…`, doUpload, { done: null });
+    if (opts.json) {
+        console.log(JSON.stringify(data));
+        return;
     }
-});
+    console.log(success(`Uploaded ${data.name} (${formatSize(data.size)})`));
+    console.log(`  ${brand(data.url)}`);
+    console.log(muted(`  Durable, worker-reachable URL - pass it straight to a job/function as an input URL.`));
+    console.log(muted(`  ${data.is_public ? 'public (CDN)' : 'private (token-signed)'} · guid: ${data.guid}`));
+}));
 //# sourceMappingURL=upload.js.map

package/dist/helpers/body.js

@@ -0,0 +1,117 @@
+/**
+ * Resolve a JSON request/input body from the CLI.
+ *
+ * A body can be given three ways, so large payloads (images, audio, docs -
+ * the common case for jobs) don't have to fit in a shell argument:
+ *   - inline JSON:   '{"foo":1}'
+ *   - a file:        @path/to/body.json   (reads and parses the file)
+ *   - stdin:         @-  or  -            (reads and parses stdin)
+ *
+ * The `@file` / stdin forms exist because a base64 image easily blows past
+ * ARG_MAX ("Argument list too long") when passed inline. `readFileSync` on the
+ * path sidesteps the shell argument entirely.
+ */
+import { readFileSync } from 'node:fs';
+import { guessMime } from '../upload.js';
+/** Read all of stdin synchronously (fd 0). Returns '' if stdin is a TTY. */
+function readStdin() {
+    if (process.stdin.isTTY)
+        return '';
+    try {
+        return readFileSync(0, 'utf-8');
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * Read a `--file field=@path` (or `field=path`) spec and return
+ * `[field, { data, media_type }]`. This is the ergonomic path for calling an
+ * image / audio / document function end-to-end: instead of a manual
+ * `base64 | grep | python json.dumps` dance to stuff a photo into a JSON body,
+ * the CLI reads the file itself, base64-encodes it, and wraps it in the
+ * `{ data, media_type }` envelope every Gipity vision/media service and the
+ * browser SDK expect (see the `image` field in app-llm). A bare base64 string
+ * would mismatch that shape, so attachments always carry their media type
+ * (detected from the file extension). The leading `@` is optional (accepted
+ * for symmetry with `--data @file`).
+ */
+export function readFileField(spec) {
+    const eq = spec.indexOf('=');
+    if (eq === -1) {
+        throw new Error(`Invalid --file '${spec}': expected field=@path (e.g. --file image=@receipt.png).`);
+    }
+    const field = spec.slice(0, eq).trim();
+    let path = spec.slice(eq + 1);
+    if (path.startsWith('@'))
+        path = path.slice(1);
+    if (!field)
+        throw new Error(`Invalid --file '${spec}': missing field name before '='.`);
+    if (!path)
+        throw new Error(`Invalid --file '${spec}': missing file path after '='.`);
+    try {
+        return [field, { data: readFileSync(path).toString('base64'), media_type: guessMime(path) }];
+    }
+    catch (e) {
+        throw new Error(`Cannot read --file '${path}': ${e.message}`);
+    }
+}
+/**
+ * Resolve a JSON body and merge in any `--file field=@path` attachments, each
+ * attached as `{ data, media_type }` under its field. `fileSpecs` is the
+ * repeatable `--file` list. File attachments require an object body (they can't
+ * merge into an array or scalar), which is the normal case for a function/job
+ * request.
+ */
+export function resolveBody(raw, fileSpecs) {
+    const body = resolveJsonBody(raw);
+    if (!fileSpecs || fileSpecs.length === 0)
+        return body;
+    if (typeof body !== 'object' || body === null || Array.isArray(body)) {
+        throw new Error('--file needs an object body to attach into (got a non-object JSON body).');
+    }
+    const obj = body;
+    for (const spec of fileSpecs) {
+        const [field, attachment] = readFileField(spec);
+        obj[field] = attachment;
+    }
+    return obj;
+}
+/**
+ * Turn a raw body argument into a parsed JSON value.
+ * `raw` is the positional body or the `--data` value; undefined => `{}`.
+ */
+export function resolveJsonBody(raw) {
+    if (raw == null || raw === '')
+        return {};
+    let source;
+    let origin;
+    if (raw === '-' || raw === '@-') {
+        source = readStdin();
+        origin = 'stdin';
+        if (source.trim() === '') {
+            throw new Error('No JSON on stdin (pipe a body in, e.g. `cat body.json | gipity fn call foo -d -`).');
+        }
+    }
+    else if (raw.startsWith('@')) {
+        const path = raw.slice(1);
+        try {
+            source = readFileSync(path, 'utf-8');
+        }
+        catch (e) {
+            throw new Error(`Cannot read body file '${path}': ${e.message}`);
+        }
+        origin = `file '${path}'`;
+    }
+    else {
+        source = raw;
+        origin = 'inline JSON';
+    }
+    try {
+        return JSON.parse(source);
+    }
+    catch (e) {
+        throw new Error(`Invalid JSON in ${origin}: ${e.message}`);
+    }
+}
+//# sourceMappingURL=body.js.map

package/dist/helpers/duration.js

@@ -0,0 +1,34 @@
+/**
+ * Duration parsing shared by the sibling `--timeout` flags.
+ *
+ * `sandbox run --timeout` is native SECONDS and `page eval --timeout` is native
+ * MILLISECONDS — the same flag name, two units, which reliably trips an agent
+ * carrying a value from one command to the other. The reconciliation is an
+ * explicit unit suffix that means the SAME thing everywhere: `--timeout 90s` is
+ * 90 seconds on both, `--timeout 1500ms` is 1.5s on both. A bare number keeps
+ * each command's native unit (so nothing about existing invocations changes),
+ * but the portable, unambiguous form now works and the help teaches it.
+ */
+const UNIT_TO_MS = { ms: 1, s: 1_000, m: 60_000 };
+/** Parse a duration that MAY carry a `ms`/`s`/`m` suffix, returning it in `unit`
+ *  (the caller's native unit). A bare number is taken as already being in `unit`
+ *  and returned unchanged with `hadSuffix:false`, so the caller's own bare-number
+ *  handling (defaults, unit-mixup guards) still runs. Returns null only when the
+ *  input is not a number at all — the caller then falls back to its prior parse. */
+export function parseDuration(raw, unit) {
+    if (raw === undefined)
+        return null;
+    const m = raw.trim().match(/^(\d+(?:\.\d+)?)\s*(ms|s|m)?$/i);
+    if (!m)
+        return null;
+    const n = parseFloat(m[1]);
+    if (!Number.isFinite(n))
+        return null;
+    const suffix = m[2]?.toLowerCase();
+    if (!suffix)
+        return { value: n, hadSuffix: false };
+    const ms = n * UNIT_TO_MS[suffix];
+    const value = unit === 'ms' ? ms : ms / 1_000;
+    return { value, hadSuffix: true };
+}
+//# sourceMappingURL=duration.js.map

package/dist/helpers/index.js

@@ -4,4 +4,6 @@
 export { run } from './command.js';
 export { printOutput, printList, printResult, pluckField, emitField } from './output.js';
 export { syncBeforeAction } from './sync.js';
+export { resolveJsonBody, resolveBody } from './body.js';
+export { parseDuration } from './duration.js';
 //# sourceMappingURL=index.js.map