@myapihq/cli 1.1.0-wip.3 → 1.1.0-wip.4

package/dist/commands/image.d.ts

@@ -1,4 +1,4 @@
-export declare function generate(flags: Record<string, string | boolean>): Promise<void>;
-export declare function list(flags: Record<string, string | boolean>): Promise<void>;
-export declare function del(id: string, flags: Record<string, string | boolean>): Promise<void>;
-export declare function run(subcommand: string | undefined, args: string[], flags: Record<string, string | boolean>): Promise<void>;
+import type { FlagSchema } from '../flags.js';
+import { type Flags } from '../helpers.js';
+export declare const SCHEMA: FlagSchema;
+export declare function run(subcommand: string | undefined, args: string[], flags: Flags): Promise<void>;

package/dist/commands/image.js

@@ -1,70 +1,157 @@
 import { image as sdkImage } from '@myapihq/sdk';
 import { requireConfig } from '../config.js';
-import { success, error, printTable, info, printJson } from '../output.js';
-import { sleep } from '../utils.js';
-export async function generate(flags) {
+import { success, error, printTable, info, printJson, banner } from '../output.js';
+import { formatDate, pollJob } from '../utils.js';
+import { requireOrg, requireArg } from '../helpers.js';
+export const SCHEMA = {
+    org: 'string',
+    prompt: 'string',
+    ratio: 'string',
+    style: 'string',
+    colors: 'string',
+    text: 'boolean',
+};
+const VALID_RATIOS = new Set(['1:1', '16:9', '9:16', '4:3', '3:4']);
+// Hex list: optional leading #, 3 or 6 hex digits, comma-separated.
+const HEX_LIST_RE = /^#?[0-9a-fA-F]{3}(?:[0-9a-fA-F]{3})?(?:\s*,\s*#?[0-9a-fA-F]{3}(?:[0-9a-fA-F]{3})?)*$/;
+const PRICE_USD = 0.05;
+function summarizeImage(j) {
+    const prompt = (j.prompt || '');
+    const truncated = prompt.length > 60 ? prompt.slice(0, 60) + '...' : prompt;
+    return {
+        job_id: j.job_id,
+        status: j.status,
+        aspect_ratio: j.aspect_ratio,
+        prompt: truncated,
+        url: j.url || '',
+        created_at: j.created_at ? formatDate(j.created_at) : '',
+    };
+}
+async function generate(promptArg, flags) {
     const config = requireConfig();
-    const orgId = flags.org || config.default_org;
-    if (!orgId || !flags.prompt) {
-        error("Missing required arguments.\nUsage: myapi image generate --prompt <text> --org <id>\n(Or set defaults via: myapi config set-org <id>)");
+    const orgId = requireOrg(flags, config, 'myapi image generate <prompt> [--ratio 1:1|16:9|9:16|4:3|3:4] [--style <s>] [--colors <hex,hex>] [--text] [--org <id>]');
+    // Convention: first required arg is positional. --prompt still works for back-compat.
+    const prompt = promptArg || flags.prompt;
+    if (!prompt) {
+        error('Missing required arguments.\nUsage: myapi image generate <prompt> [--ratio <ratio>] [--style <s>] [--colors <c>] [--text] [--org <id>]\n   or: myapi image generate --prompt "<text>" ...');
+    }
+    // Client-side validation: catch typos before they round-trip.
+    if (flags.ratio && !VALID_RATIOS.has(flags.ratio)) {
+        error(`Invalid --ratio "${flags.ratio}". Allowed: ${[...VALID_RATIOS].join(', ')}`);
     }
-    const payload = { prompt: flags.prompt };
+    if (flags.colors && !HEX_LIST_RE.test(flags.colors)) {
+        error(`Invalid --colors "${flags.colors}". Expected comma-separated hex like "#ff6600,#003366" (3- or 6-digit, # optional).`);
+    }
+    const payload = { prompt };
     if (flags.ratio)
         payload.aspect_ratio = flags.ratio;
     if (flags.style)
         payload.style = flags.style;
     if (flags.colors)
         payload.colors = flags.colors;
-    const res = await sdkImage.generateImage(config.api_key, orgId, payload);
-    process.stdout.write("Generating image ");
-    const chars = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-    let i = 0;
-    let elapsed = 0;
-    while (elapsed < 60000) {
-        const job = await sdkImage.getImageJob(config.api_key, orgId, res.job_id);
-        if (job.status === 'completed') {
-            process.stdout.write('\r\x1b[K');
-            if (flags.json)
-                printJson(job);
-            else
-                success(`Image generated!\nURL: ${job.url}`);
-            return;
-        }
-        if (job.status === 'failed') {
-            process.stdout.write('\r\x1b[K');
-            error(`Image generation failed: ${job.error || 'Unknown error'}`);
-        }
-        process.stdout.write(`\rGenerating image ${chars[i++ % chars.length]}`);
-        await sleep(3000);
-        elapsed += 3000;
+    if (flags.text)
+        payload.has_text = true;
+    // Cost preview before kickoff. Goes to stderr (banner) so --json output
+    // stays clean for piping.
+    banner(`› Charging $${PRICE_USD.toFixed(2)} for this image generation…`);
+    const job = await sdkImage.generateImage(config.api_key, orgId, payload);
+    const final = await pollJob({
+        label: 'Generating image',
+        timeoutMs: 90_000,
+        intervalMs: 3000,
+        check: () => sdkImage.getImageJob(config.api_key, orgId, job.job_id),
+        isDone: s => s.status === 'completed',
+        isFailed: s => s.status === 'failed',
+        failedMessage: 'Image generation failed',
+        timeoutMessage: 'Image generation timed out — re-run "myapi image get <id>" to check later.',
+    });
+    if (flags.json) {
+        printJson(final);
+        return;
     }
-    process.stdout.write('\r\x1b[K');
-    error("Image generation timed out");
+    success(`Image generated!\nID:  ${final.job_id}\nURL: ${final.url}`);
 }
-export async function list(flags) {
+async function list(flags) {
     const config = requireConfig();
-    const orgId = flags.org || config.default_org;
-    if (!orgId)
-        error("Missing required arguments.\nUsage: myapi image list --org <id>\n(Or set defaults via: myapi config set-org <id>)");
+    const orgId = requireOrg(flags, config, 'myapi image list [--org <id>]');
     const images = await sdkImage.listImages(config.api_key, orgId);
-    if (flags.json)
+    if (flags.json) {
         printJson(images);
-    else
-        printTable(images);
+        return;
+    }
+    printTable(images.map(summarizeImage), {
+        flags,
+        empty: 'No images yet. Generate one: myapi image generate "<prompt>"',
+    });
 }
-export async function del(id, flags) {
+async function get(id, flags) {
     const config = requireConfig();
-    const orgId = flags.org || config.default_org;
-    if (!orgId || !id) {
-        error("Missing required arguments.\nUsage: myapi image delete <job_id> --org <id>\n(Or set defaults via: myapi config set-org <id>)");
+    const orgId = requireOrg(flags, config, 'myapi image get <job_id> [--org <id>] [--json]');
+    requireArg(id, 'job_id', 'myapi image get <job_id> [--org <id>] [--json]');
+    const job = await sdkImage.getImageJob(config.api_key, orgId, id);
+    if (flags.json) {
+        printJson(job);
+        return;
     }
+    info(`ID:           ${job.job_id}`);
+    info(`Status:       ${job.status}`);
+    info(`Aspect ratio: ${job.aspect_ratio}`);
+    if (job.prompt)
+        info(`Prompt:       ${job.prompt}`);
+    if (job.url)
+        info(`URL:          ${job.url}`);
+    if (job.error)
+        info(`Error:        ${job.error}`);
+    if (job.created_at)
+        info(`Created:      ${formatDate(job.created_at)}`);
+}
+// `get-url`: just the URL string, nothing else. Curl-friendly. Errors if
+// the job isn't completed (no URL to print).
+async function getUrl(id, _flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(_flags, config, 'myapi image get-url <job_id> [--org <id>]');
+    requireArg(id, 'job_id', 'myapi image get-url <job_id> [--org <id>]');
+    const job = await sdkImage.getImageJob(config.api_key, orgId, id);
+    if (!job.url) {
+        error(`Image ${id} has no URL yet (status: ${job.status}). Re-check with: myapi image get ${id}`);
+    }
+    console.log(job.url);
+}
+async function del(id, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi image delete <job_id> [--org <id>]');
+    requireArg(id, 'job_id', 'myapi image delete <job_id> [--org <id>]');
     await sdkImage.deleteImage(config.api_key, orgId, id);
-    success(`Image deleted! (Job ${id} history retained, URL nullified)`);
+    success(`Image ${id} deleted (job history retained, URL nullified)`);
 }
 // ── Dispatcher ───────────────────────────────────────────────────────────────
 const SUBCOMMAND_USAGE = {
     'list': 'myapi image list [--org <id>] [--json]',
-    'generate': 'myapi image generate --prompt "<text>" [--ratio <1:1|16:9>] [--style <style>] [--colors <hex_list>] [--org <id>]',
+    'generate': `myapi image generate <prompt> [--ratio 1:1|16:9|9:16|4:3|3:4] [--style <s>] [--colors <hex,hex>] [--text] [--org <id>]
+       myapi image generate --prompt "<text>" ...
+
+Either form works; the positional prompt is the recommended shape.
+
+Generation is asynchronous — the CLI polls for up to 90s. If it times out
+the job keeps running server-side; re-fetch with:
+  myapi image get <job_id>
+
+Cost: $${PRICE_USD.toFixed(2)} per generation. Failed jobs aren't charged.
+
+Flags:
+  --ratio   Aspect ratio (allowed: ${[...VALID_RATIOS].join(', ')}; default 1:1)
+  --style   Free-form style hint (e.g. "watercolor", "cyberpunk neon")
+  --colors  Hex colors comma-separated (e.g. "#ff6600,#003366")
+  --text    Allow text in the image (off by default — text rarely renders well)`,
+    'get': `myapi image get <job_id> [--org <id>] [--json]
+
+Round-trips the API to fetch the full job: status, URL, prompt, aspect ratio,
+created_at. JSON output via --json; otherwise human-readable block.`,
+    'get-url': `myapi image get-url <job_id> [--org <id>]
+
+Prints just the asset URL. Errors if the job hasn't completed yet.
+Curl-friendly:
+  curl -O "$(myapi image get-url <id>)"`,
     'delete': 'myapi image delete <job_id> [--org <id>]',
 };
 export async function run(subcommand, args, flags) {
@@ -72,11 +159,14 @@ export async function run(subcommand, args, flags) {
         info(`Usage: myapi image <subcommand>
 
 Subcommands:
-  list       List all your generated images
-  generate   Generate a new AI image from a prompt ($0.05 per generation)
-  delete     Delete the physical image file for a job (history retained, URL nullified)
+  list                List all your generated images
+  generate <prompt>   Generate a new AI image (async, polls up to 90s, $${PRICE_USD.toFixed(2)})
+  get <job_id>        Fetch full job metadata (JSON or human-readable)
+  get-url <job_id>    Print just the asset URL (curl-friendly)
+  delete <job_id>     Delete the asset (job history retained)
 
-All commands accept --org <id> (or set default: myapi config set-org <id>).`);
+All commands accept --org <id> (or set default: myapi config set-org <id>).
+The asset lands in your org's storage and is also visible via "myapi storage list".`);
         return;
     }
     if (flags.help) {
@@ -84,13 +174,15 @@ All commands accept --org <id> (or set default: myapi config set-org <id>).`);
         if (usage)
             info(`Usage: ${usage}`);
         else
-            info(`Unknown subcommand: ${subcommand}. Run "myapi image --help" for the list.`);
+            error(`Unknown subcommand: ${subcommand}. Run "myapi image --help" for the list.`);
         return;
     }
     switch (subcommand) {
         case 'list': return list(flags);
-        case 'generate': return generate(flags);
+        case 'generate': return generate(args[0], flags);
+        case 'get': return get(args[0], flags);
+        case 'get-url': return getUrl(args[0], flags);
         case 'delete': return del(args[0], flags);
-        default: error(`Unknown subcommand: ${subcommand}. Run "myapi image --help" for a list of valid subcommands.`);
+        default: error(`Unknown subcommand: ${subcommand}. Run "myapi image --help" for available subcommands.`);
     }
 }

package/dist/commands/storage.d.ts

@@ -1,4 +1,4 @@
-export declare function list(flags: Record<string, string | boolean>): Promise<void>;
-export declare function ingest(url: string, flags: Record<string, string | boolean>): Promise<void>;
-export declare function del(id: string, flags: Record<string, string | boolean>): Promise<void>;
-export declare function run(subcommand: string | undefined, args: string[], flags: Record<string, string | boolean>): Promise<void>;
+import type { FlagSchema } from '../flags.js';
+import { type Flags } from '../helpers.js';
+export declare const SCHEMA: FlagSchema;
+export declare function run(subcommand: string | undefined, args: string[], flags: Flags): Promise<void>;

package/dist/commands/storage.js

@@ -1,39 +1,127 @@
-import { storage as sdkStorage } from '@myapihq/sdk';
+import { readFile } from 'fs/promises';
+import { extname, basename } from 'path';
+import { storage as sdkStorage, STORAGE_BASE } from '@myapihq/sdk';
 import { requireConfig } from '../config.js';
 import { success, error, printTable, info, printJson } from '../output.js';
-export async function list(flags) {
+import { formatDate } from '../utils.js';
+import { requireOrg, requireArg } from '../helpers.js';
+export const SCHEMA = {
+    org: 'string',
+    name: 'string',
+};
+// Mirrors UploadContentType in @myapihq/sdk + backend allowlist.
+const EXT_TO_CT = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+};
+function summarizeAsset(a) {
+    return {
+        asset_id: a.asset_id,
+        name: a.name || '(unnamed)',
+        url: a.url,
+        created_at: a.created_at ? formatDate(a.created_at) : '',
+    };
+}
+async function list(flags) {
     const config = requireConfig();
-    const orgId = flags.org || config.default_org;
-    if (!orgId)
-        error("Missing required arguments.\nUsage: myapi storage list --org <id>\n(Or set defaults via: myapi config set-org <id>)");
+    const orgId = requireOrg(flags, config, 'myapi storage list [--org <id>]');
     const assets = await sdkStorage.listAssets(config.api_key, orgId);
-    if (flags.json)
+    if (flags.json) {
         printJson(assets);
-    else
-        printTable(assets);
+        return;
+    }
+    printTable(assets.map(summarizeAsset), {
+        flags,
+        empty: 'No assets yet. Upload one: myapi storage upload <file>  ·  Or ingest from URL: myapi storage ingest <url>',
+    });
 }
-export async function ingest(url, flags) {
+async function ingest(url, flags) {
     const config = requireConfig();
-    const orgId = flags.org || config.default_org;
-    if (!orgId || !url) {
-        error("Missing required arguments.\nUsage: myapi storage ingest <url> [--name <name>] --org <id>\n(Or set defaults via: myapi config set-org <id>)");
-    }
+    const orgId = requireOrg(flags, config, 'myapi storage ingest <url> [--name <name>] [--org <id>]');
+    requireArg(url, 'url', 'myapi storage ingest <url> [--name <name>] [--org <id>]');
     const res = await sdkStorage.ingestAsset(config.api_key, orgId, url, flags.name);
     success(`Asset ingested! ID: ${res.asset_id}\nHosted URL: ${res.url}`);
 }
-export async function del(id, flags) {
+async function upload(filePath, flags) {
     const config = requireConfig();
-    const orgId = flags.org || config.default_org;
-    if (!orgId || !id) {
-        error("Missing required arguments.\nUsage: myapi storage delete <id> --org <id>\n(Or set defaults via: myapi config set-org <id>)");
+    const orgId = requireOrg(flags, config, 'myapi storage upload <file> [--name <name>] [--org <id>]');
+    requireArg(filePath, 'file', 'myapi storage upload <file> [--name <name>] [--org <id>]');
+    const ext = extname(filePath).toLowerCase();
+    const contentType = EXT_TO_CT[ext];
+    if (!contentType) {
+        error(`Unsupported file extension "${ext}". Supported: ${Object.keys(EXT_TO_CT).join(', ')}.\n(SVG and non-image types — pdf/mp4/webm — go through "myapi storage ingest <url>" today.)`);
+    }
+    let data;
+    try {
+        data = await readFile(filePath);
+    }
+    catch (e) {
+        if (e?.code === 'ENOENT')
+            error(`File not found: ${filePath}`);
+        if (e?.code === 'EACCES')
+            error(`Permission denied: ${filePath}`);
+        error(`Could not read ${filePath}: ${e?.message ?? e}`);
     }
+    const name = flags.name || basename(filePath);
+    const res = await sdkStorage.uploadAsset(config.api_key, orgId, data, contentType, name);
+    success(`Asset uploaded! ID: ${res.asset_id}\nHosted URL: ${res.url}`);
+}
+// `get`: round-trip metadata for one asset. Backend has no single-asset
+// GET endpoint today, so we list + filter locally. Switch to a direct
+// call once the backend exposes one.
+async function get(id, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi storage get <asset_id> [--org <id>]');
+    requireArg(id, 'asset_id', 'myapi storage get <asset_id> [--org <id>]');
+    const all = await sdkStorage.listAssets(config.api_key, orgId);
+    const asset = all.find(a => a.asset_id === id);
+    if (!asset)
+        error(`Asset ${id} not found in this org. List with: myapi storage list`);
+    if (flags.json) {
+        printJson(asset);
+        return;
+    }
+    info(`ID:      ${asset.asset_id}`);
+    info(`Name:    ${asset.name || '(unnamed)'}`);
+    info(`URL:     ${asset.url}`);
+    if (asset.created_at)
+        info(`Created: ${formatDate(asset.created_at)}`);
+}
+// `get-url`: cheapest possible — print the public URL pattern. No API
+// call. Curl-friendly. Doesn't even verify the asset exists; that's a
+// trade-off for being a pure local URL constructor.
+async function getUrl(id, _flags) {
+    requireArg(id, 'asset_id', 'myapi storage get-url <asset_id>');
+    console.log(`${STORAGE_BASE}/storage/${encodeURIComponent(id)}`);
+}
+async function del(id, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi storage delete <asset_id> [--org <id>]');
+    requireArg(id, 'asset_id', 'myapi storage delete <asset_id> [--org <id>]');
     await sdkStorage.deleteAsset(config.api_key, orgId, id);
     success(`Asset ${id} deleted`);
 }
 // ── Dispatcher ───────────────────────────────────────────────────────────────
 const SUBCOMMAND_USAGE = {
     'list': 'myapi storage list [--org <id>] [--json]',
-    'ingest': 'myapi storage ingest <url> [--name <name>] [--org <id>]',
+    'ingest': `myapi storage ingest <url> [--name <name>] [--org <id>]
+
+Server fetches the URL and stores the file. Useful for migrating assets that
+already live on a public URL (e.g. importing brand assets from another host).`,
+    'upload': `myapi storage upload <file> [--name <name>] [--org <id>]
+
+Direct multipart upload of a local file. Supported: ${Object.keys(EXT_TO_CT).join(', ')}.
+The display name defaults to the file's basename — override with --name.`,
+    'get': `myapi storage get <asset_id> [--org <id>] [--json]
+
+Round-trips the API to fetch the asset's metadata (name, URL, created_at).`,
+    'get-url': `myapi storage get-url <asset_id>
+
+Prints the public CDN URL with no API call. Curl-friendly:
+  curl -O "$(myapi storage get-url <id>)"`,
     'delete': 'myapi storage delete <asset_id> [--org <id>]',
 };
 export async function run(subcommand, args, flags) {
@@ -41,9 +129,12 @@ export async function run(subcommand, args, flags) {
         info(`Usage: myapi storage <subcommand>
 
 Subcommands:
-  list       List all your uploaded assets
-  ingest     Ingest a public image URL into your edge storage
-  delete     Delete a stored asset
+  list                List all your stored assets
+  ingest <url>        Server pulls a public URL into storage
+  upload <file>       Direct upload of a local file
+  get <asset_id>      Fetch asset metadata (name, URL, created_at)
+  get-url <asset_id>  Print the public CDN URL (no API call)
+  delete <asset_id>   Permanently delete a stored asset
 
 All commands accept --org <id> (or set default: myapi config set-org <id>).`);
         return;
@@ -53,13 +144,16 @@ All commands accept --org <id> (or set default: myapi config set-org <id>).`);
         if (usage)
             info(`Usage: ${usage}`);
         else
-            info(`Unknown subcommand: ${subcommand}. Run "myapi storage --help" for the list.`);
+            error(`Unknown subcommand: ${subcommand}. Run "myapi storage --help" for the list.`);
         return;
     }
     switch (subcommand) {
         case 'list': return list(flags);
         case 'ingest': return ingest(args[0], flags);
+        case 'upload': return upload(args[0], flags);
+        case 'get': return get(args[0], flags);
+        case 'get-url': return getUrl(args[0], flags);
         case 'delete': return del(args[0], flags);
-        default: error(`Unknown subcommand: ${subcommand}. Run "myapi storage --help" for a list of valid subcommands.`);
+        default: error(`Unknown subcommand: ${subcommand}. Run "myapi storage --help" for available subcommands.`);
     }
 }

package/dist/index.js

@@ -16,6 +16,8 @@ import * as funnelCmd from './commands/funnel.js';
 import * as webhookCmd from './commands/webhook.js';
 import * as workflowCmd from './commands/workflow.js';
 import * as emailCmd from './commands/email/index.js';
+import * as imageCmd from './commands/image.js';
+import * as storageCmd from './commands/storage.js';
 import * as authCmd from './commands/auth.js';
 import * as configCmd from './commands/config.js';
 // Each command file declares the value flags it understands. We union them
@@ -28,8 +30,10 @@ const COMBINED_SCHEMA = {
     ...domainCmd.SCHEMA,
     ...emailCmd.SCHEMA,
     ...funnelCmd.SCHEMA,
+    ...imageCmd.SCHEMA,
     ...keysCmd.SCHEMA,
     ...orgCmd.SCHEMA,
+    ...storageCmd.SCHEMA,
     ...webhookCmd.SCHEMA,
     ...workflowCmd.SCHEMA,
     // Top-level flags
@@ -120,6 +124,12 @@ async function main() {
             case 'email':
                 await emailCmd.run(subcommand, restArgs, flags);
                 break;
+            case 'image':
+                await imageCmd.run(subcommand, restArgs, flags);
+                break;
+            case 'storage':
+                await storageCmd.run(subcommand, restArgs, flags);
+                break;
             // Convenience aliases
             case 'setup':
                 await setupCmd.setup(flags);
@@ -202,6 +212,8 @@ const HELP_TARGETS = {
     webhook: f => webhookCmd.run(undefined, [], f),
     workflow: f => workflowCmd.run(undefined, [], f),
     email: f => emailCmd.run(undefined, [], f),
+    image: f => imageCmd.run(undefined, [], f),
+    storage: f => storageCmd.run(undefined, [], f),
     org: f => orgCmd.run(undefined, [], f),
     billing: f => billingCmd.run(undefined, [], f),
     keys: f => keysCmd.run(undefined, [], f),
@@ -244,6 +256,8 @@ Commands:
   webhook      Manage inbound webhook endpoints and inspect deliveries
   email        Manage mailboxes, send/read email, templates, and campaigns
   workflow     Run actions (send email, post to Slack) when a webhook fires
+  image        Generate AI images and manage them in storage
+  storage      Upload, ingest, list, and serve assets from edge storage
 
 Aliases:
   whoami          → myapi auth whoami

package/dist/output.d.ts

@@ -7,6 +7,7 @@ export declare function info(message: string): void;
 export declare function banner(message: string): void;
 export declare function printJson(data: unknown): void;
 export declare function spinnerFrame(i: number): string;
+export declare function spinnerWrite(s: string): void;
 export declare function clearLine(): void;
 export interface PrintTableOptions {
     /** Pass `flags` so `--json` (any truthy form) routes to JSON output. */

package/dist/output.js

@@ -17,12 +17,19 @@ export function printJson(data) {
 }
 // Spinner / line-clear primitives. Used by polling helpers (utils.pollJob)
 // and any handler that wants its own progress UI.
+//
+// Spinner writes go to STDERR — keeping stdout clean for whatever the
+// command's actual output is (JSON, an id, a URL). Otherwise spinner bytes
+// pollute `--json` parsing or piped output.
 const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
 export function spinnerFrame(i) {
     return SPINNER_FRAMES[i % SPINNER_FRAMES.length];
 }
+export function spinnerWrite(s) {
+    process.stderr.write(s);
+}
 export function clearLine() {
-    process.stdout.write('\r\x1b[K');
+    process.stderr.write('\r\x1b[K');
 }
 // Generic so callers don't need `as unknown as Record<string, unknown>[]`.
 // Field names come from the first row; if SDK renames a field, the projector

package/dist/skills/my-image-api/README.md

@@ -0,0 +1,32 @@
+---
+# my-image-api
+
+Generate AI images from a text prompt. Async — submit, poll, get a public CDN URL. Asset auto-saved to your org's storage.
+
+## What it does
+
+- Text-to-image generation with prompt, aspect ratio, style, colors, optional text
+- Async pipeline (~10–30s typical, 90s timeout)
+- Output stored in mystorageapi automatically
+- Public CDN URL for embedding in funnels, emails, anywhere
+
+## Quickstart
+
+```bash
+myapi image generate "A clean flat-color logo for a sustainable jam company"
+# → polls, then prints the asset URL
+```
+
+## Authentication
+
+```bash
+export MYAPI_KEY=mak_...
+```
+
+Requires `api_key` and `org_id` from **myapihq**. ~$0.05 per generation.
+
+## Documentation
+
+Full command reference, flags, and async semantics: see `SKILL.md`.
+
+Run `myapi image --help` for inline reference.

package/dist/skills/my-image-api/SKILL.md

@@ -0,0 +1,74 @@
+---
+name: my-image-api
+description: >
+  Generate AI images from a text prompt. Async — submit a prompt, the CLI polls until the image is ready, then returns a public CDN URL. Image lands automatically in your org's storage.
+---
+
+# MyImageAPI
+
+Text-to-image generation. Submit a prompt with optional aspect ratio, style, color palette, and "allow text" hint. The job is asynchronous — the CLI polls until completion (typically 10–30s, capped at 90s).
+
+## How It Fits Together
+
+- Requires `api_key` and `org_id` from **myapihq**.
+- Each generation costs ~$0.05 (deducted from your balance).
+- The output asset is stored in your org's **mystorageapi** bucket — `myapi storage list` and `myapi storage get` can fetch it later by id.
+- Generated images can be referenced from a **myfunnelapi** page or embedded in a **myemailapi** template.
+
+## Quick Start
+
+```bash
+# Generate (positional prompt is the recommended shape)
+myapi image generate "A clean flat-color logo for a sustainable jam company"
+
+# Same with options
+myapi image generate "Hero image, 16:9, mountains at dawn" \
+  --ratio 16:9 --style "watercolor" --colors "#ff6600,#003366"
+
+# List your generations
+myapi image list
+
+# Inspect or fetch a specific job
+myapi image get <job_id>
+
+# Delete the asset (the job history record stays)
+myapi image delete <job_id>
+```
+
+## All Commands
+
+| Command | What it does |
+|---|---|
+| `myapi image generate <prompt>` | Async generate, polls up to 90s, returns id + URL |
+| `myapi image list` | List all generated images for the org |
+| `myapi image get <job_id>` | Get full job details (status, URL, prompt, aspect ratio) |
+| `myapi image delete <job_id>` | Delete the asset (job record kept for history) |
+
+## Generate Flags
+
+| Flag | Allowed | Default | Notes |
+|---|---|---|---|
+| `--ratio` | `1:1`, `16:9`, `9:16`, `4:3`, `3:4` | `1:1` | Aspect ratio of the output |
+| `--style` | free-form string | none | Style hint, e.g. `"watercolor"`, `"cyberpunk neon"` |
+| `--colors` | hex list, comma-separated | none | e.g. `"#ff6600,#003366"` — the model will bias toward these |
+| `--text` | flag (no value) | off | Allow text in the image. Off by default — text rarely renders well, use only when you specifically want a logo or sign |
+
+## Async Behavior
+
+Generation is async. The CLI:
+1. Submits the prompt → gets a `job_id` immediately.
+2. Polls `GET /image/orgs/<org>/jobs/<job_id>` every 3 seconds.
+3. Returns when status is `completed` (success) or `failed` (errors out).
+4. If 90 seconds elapse without completion, the CLI prints a timeout message but **the job keeps running server-side**. Check back with:
+   ```
+   myapi image get <job_id>
+   ```
+
+## Notes
+
+- Generations cost $0.05 each. Failed jobs aren't charged.
+- The asset URL is public (anyone with the URL can view) — don't generate sensitive content.
+- Prompts with explicit text usually fail; for branded text use a separate text overlay step or a real designer.
+- Delete is permanent for the asset; the job's prompt + metadata stays for your history (`image list` will still show it with an empty URL).
+
+Run `myapi image --help` or `myapi image <subcommand> --help` for full flag reference.

package/dist/skills/my-image-api/claude/.claude-plugin/plugin.json

@@ -0,0 +1,6 @@
+{
+  "name": "my-image-api",
+  "description": "Generate AI images from a text prompt. Async, polls until ready, returns a public CDN URL.",
+  "version": "1.0.0",
+  "published": true
+}

package/dist/skills/my-storage-api/README.md

@@ -0,0 +1,35 @@
+---
+# my-storage-api
+
+Edge-hosted asset storage. Upload local files or ingest from URLs. Each asset gets a stable public CDN URL.
+
+## What it does
+
+- Direct multipart upload of `.png` / `.jpg` files
+- Ingest from any public URL (server pulls)
+- Public CDN delivery — stable URL until deletion
+- Used automatically by my-image-api for generated images
+
+## Quickstart
+
+```bash
+myapi storage upload ./logo.png
+# → asset uploaded! URL: https://api.mystorageapi.com/storage/<id>
+
+# Or fetch via curl
+curl -O "$(myapi storage get <asset_id>)"
+```
+
+## Authentication
+
+```bash
+export MYAPI_KEY=mak_...
+```
+
+Requires `api_key` and `org_id` from **myapihq**.
+
+## Documentation
+
+Full command reference, upload-vs-ingest tradeoffs, and naming conventions: see `SKILL.md`.
+
+Run `myapi storage --help` for inline reference.

package/dist/skills/my-storage-api/SKILL.md

@@ -0,0 +1,88 @@
+---
+name: my-storage-api
+description: >
+  Edge-hosted asset storage. Upload local files (.png/.jpg) directly, or have the server fetch from a public URL. Each asset gets a stable public CDN URL.
+---
+
+# MyStorageAPI
+
+Per-org asset storage with edge CDN delivery. Two ways in:
+- **Direct upload** — push a local file (multipart upload)
+- **Ingest from URL** — server fetches a public URL and stores the file
+
+Both produce a stable public URL like `https://api.mystorageapi.com/storage/<id>`.
+
+## How It Fits Together
+
+- Requires `api_key` and `org_id` from **myapihq**.
+- Upload supports `.png`, `.jpg`, `.jpeg` today. (Add more via `mystorageapi`'s backend if you need them.)
+- Assets are public — anyone with the URL can fetch.
+- **myimageapi** automatically uses storage for generated images, so generated images appear in `myapi storage list` too.
+
+## Quick Start
+
+```bash
+# Direct upload
+myapi storage upload ./logo.png --name "brand-logo"
+
+# Ingest a public URL (server pulls)
+myapi storage ingest https://example.com/hero.jpg --name "hero"
+
+# List
+myapi storage list
+
+# Get the public URL (curl-friendly)
+curl -O "$(myapi storage get <asset_id>)"
+
+# Delete
+myapi storage delete <asset_id>
+```
+
+## All Commands
+
+| Command | What it does |
+|---|---|
+| `myapi storage list` | List all stored assets |
+| `myapi storage upload <file>` | Direct multipart upload of a local file |
+| `myapi storage ingest <url>` | Server fetches a public URL into storage |
+| `myapi storage get <asset_id>` | Print the public CDN URL (no API call) |
+| `myapi storage delete <asset_id>` | Permanently delete the asset |
+
+## Upload vs Ingest
+
+Pick based on where the file is:
+
+- **`upload`** — file is on your machine. Multipart POST. Constraint: `.png` / `.jpg` / `.jpeg` only today.
+- **`ingest`** — file is at a public HTTP(S) URL. Server downloads and stores. Useful for migrating assets from another host or pulling in third-party images you have rights to.
+
+Both produce identical asset records — `list` doesn't distinguish them.
+
+## Naming
+
+Both `upload` and `ingest` accept `--name <display>` for a human-friendly label. If omitted:
+- `upload` defaults to the filename's basename.
+- `ingest` defaults to the URL path's filename or empty.
+
+The display name is for your reference only — the public URL uses the auto-generated id.
+
+## Public URLs
+
+`myapi storage get <id>` is a pure-local URL constructor — no API call, no auth, no rate limit. The output is exactly:
+```
+https://api.mystorageapi.com/storage/<id>
+```
+(or whatever `MYAPI_STORAGE_URL` is set to). Pipe it directly into curl:
+```bash
+curl -O "$(myapi storage get abc123)"
+```
+
+The URL itself is permanent until you `myapi storage delete <id>` — embed it freely in your funnels, emails, or anywhere else.
+
+## Notes
+
+- Assets are public by default. Don't store sensitive files.
+- Delete is immediate and unrecoverable.
+- Generated images from **myimageapi** show up in `storage list` under their job id.
+- If you need a non-image format (PDF, video, etc.), `ingest` works as long as the server-side storage accepts it; `upload` is restricted to image types.
+
+Run `myapi storage --help` for full flag reference.

package/dist/skills/my-storage-api/claude/.claude-plugin/plugin.json

@@ -0,0 +1,6 @@
+{
+  "name": "my-storage-api",
+  "description": "Edge-hosted asset storage. Upload local files or ingest from URLs, each gets a stable public CDN URL.",
+  "version": "1.0.0",
+  "published": true
+}

package/dist/utils.js

@@ -1,4 +1,4 @@
-import { spinnerFrame, clearLine, error } from './output.js';
+import { spinnerFrame, spinnerWrite, clearLine, error } from './output.js';
 export function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
@@ -23,7 +23,7 @@ export function formatDate(str) {
 export async function pollJob(opts) {
     const timeoutMs = opts.timeoutMs ?? 90_000;
     const intervalMs = opts.intervalMs ?? 3_000;
-    process.stdout.write(`${opts.label} `);
+    spinnerWrite(`${opts.label} `);
     let i = 0;
     let elapsed = 0;
     while (elapsed < timeoutMs) {
@@ -36,7 +36,7 @@ export async function pollJob(opts) {
             clearLine();
             error(opts.failedMessage ?? `${opts.label} failed`);
         }
-        process.stdout.write(`\r${opts.label} ${spinnerFrame(i++)}`);
+        spinnerWrite(`\r${opts.label} ${spinnerFrame(i++)}`);
         await sleep(intervalMs);
         elapsed += intervalMs;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myapihq/cli",
-  "version": "1.1.0-wip.3",
+  "version": "1.1.0-wip.4",
   "description": "MyAPI command-line interface",
   "type": "module",
   "files": [