@myapihq/cli 1.1.0-wip.4 → 1.2.0

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

@@ -1,69 +1,73 @@
 ---
 name: my-funnel-api
+version: 1.0.0
 description: >
   Create and publish websites (funnels) to the edge. Push raw HTML to any slug and it goes live instantly on your org's domain or preview subdomain.
+triggers: [funnel, landing page, website, page, publish, push, slug, html, edge, preview subdomain, makeautonomous]
+checksum: sha256-pending
 ---
 
 # MyFunnelAPI
 
-A funnel is a website tied to an org. You push raw HTML pages to slugs and they are served from the edge immediately — no build pipeline, no deploy queue.
+A funnel is a website tied to an org. Push raw HTML pages to slugs and they're served from the edge immediately — no build pipeline, no deploy queue.
 
-## How It Fits Together
+## Capabilities
+<!-- llm:start -->
+Funnels are the publishing surface. You create a funnel under an org (one command), then `funnel push` raw HTML to any slug (`/`, `/about`, `/pricing`, etc.). The edge serves the page within seconds — no CI/CD, no build, no deploy queue.
 
-- Requires `api_key` and `org_id` from **myapihq**.
-- Works out of the box on the free preview subdomain (`*.makeautonomous.com`).
-- To serve on a custom domain, register and assign a domain via **mydomainapi** first.
+By default, your funnel lives on a free preview subdomain (`*.makeautonomous.com`) you get with every org. To serve on a custom domain, register and assign one via **mydomainapi** first.
 
-## Typical Flow
-
-```bash
-myapi funnel create                      # creates a funnel under your default org
-echo '<h1>Hello</h1>' | myapi funnel push /   # pushes HTML to /
-myapi funnel list                        # see all funnels and their preview URLs
-```
-
-After `funnel create`, the CLI prints a preview URL. After `push`, the page is immediately live.
-
-## All Commands
+Every funnel includes two public proxy endpoints your HTML can call directly (no API key needed): a **form submit** endpoint that forwards POSTs to your org's webhook, and an **analytics/event ingest** for pageviews and click tracking.
+<!-- llm:end -->
 
+## Commands
+<!-- generated:start -->
 | Command | What it does |
 |---|---|
-| `myapi funnel create` | Create a new funnel in the default org |
-| `myapi funnel list` | List all funnels with their preview/domain URLs |
-| `myapi funnel get <id>` | Inspect a funnel's metadata and preview URL |
-| `myapi funnel delete <id>` | Delete funnel and purge all its edge pages |
-| `myapi funnel push [slug]` | Push HTML from stdin to a slug path |
-
-## Pushing Pages
-
-The `push` command reads HTML from stdin and deploys it to a slug. The funnel is resolved from your saved default (`myapi auth config set-funnel <id>`) or `--funnel <id>`.
-
+| `myapi funnel create` | Create a funnel in the default org |
+| `myapi funnel list` | List all funnels with preview/domain URLs |
+| `myapi funnel get <id>` | Inspect a funnel's metadata + preview URL |
+| `myapi funnel delete <id>` | Delete the funnel and purge its edge pages |
+| `myapi funnel push [slug]` | Push HTML from stdin to a slug (default: `/`) |
+| `myapi funnel pages [funnel_id]` | List the pages currently published to a funnel |
+| `myapi funnel verify [slug]` | Verify a published page is reachable + check links/webhooks |
+<!-- generated:end -->
+
+## Examples
+<!-- llm:start -->
 ```bash
-# push to /
-cat index.html | myapi funnel push /
+# Create a funnel + push a homepage
+myapi funnel create
+echo '<h1>Hello</h1>' | myapi funnel push /
+
+# Push multiple pages
+cat about.html    | myapi funnel push /about
+cat pricing.html  | myapi funnel push /pricing
 
-# push to /contact
-cat contact.html | myapi funnel push /contact
+# Pipe directly from a generator
+my-html-gen        | myapi funnel push /landing
 
-# push to / using explicit funnel
-cat index.html | myapi funnel push / --funnel <funnel_id>
+# Inspect what's published
+myapi funnel pages
+myapi funnel verify /pricing
 
-# pipe from a generator
-my-html-gen | myapi funnel push /landing
+# Clean up
+myapi funnel delete <funnel_id>
 ```
 
-Omitting `[slug]` defaults to `/`.
+Omitting `[slug]` defaults to `/`. The funnel id is resolved from `--funnel`, the saved default funnel, or — only if the org has exactly one funnel — auto-picked.
+<!-- llm:end -->
 
 ## Form Submissions & Analytics
 
-Funnels include two public proxy endpoints your HTML can call directly (no API key needed):
+Funnels expose two public proxy endpoints your published HTML can hit directly (no API key needed):
 
 - **Form submit:** `POST /funnel/funnels/{id}/submit/{slug}` — validates payload and forwards to your org's configured webhook.
 - **Analytics/tracking:** `POST /funnel/funnels/{id}/event` — proxies pageviews, clicks, and pixel events to your webhook. Rate-limited to 60 req/min per funnel.
 
 ## Notes
 
-- Default org and funnel are stored in config. Set them once with `myapi auth config set-org <id>` to skip `--org` on every command.
+- Set defaults with `myapi config set-org <id>` and `myapi config set-funnel <id>` to skip flags on every command.
 - Deleting a funnel purges all its edge pages immediately.
 - `402` errors mean insufficient credits — run `myapi billing topup <amount>`.
 

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

@@ -1,74 +1,78 @@
 ---
 name: my-image-api
+version: 1.0.0
 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.
+triggers: [image, generate image, ai image, hero image, logo, illustration, watercolor, prompt, cyberpunk, ratio, aspect ratio]
+checksum: sha256-pending
 ---
 
 # 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
+## Capabilities
+<!-- llm:start -->
+Generation is async. Submit a prompt → get a `job_id` immediately. The CLI polls every 3 seconds and returns when the job completes (or times out at 90s — the job continues server-side; check back with `image get <job_id>`).
 
-- 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.
+Cost is per-image at the selected model's catalog rate (today $0.039 for the default flash model, $0.10 for the pro model). Run `myapi image models` for the live catalog. Failed jobs aren't charged. Generated images land automatically in your org's **mystorageapi** bucket — they show up in `myapi storage list` and 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
+The output URL is public — anyone with it can view. Don't generate sensitive content.
+<!-- llm:end -->
 
+## Commands
+<!-- generated:start -->
 | 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 get <job_id>` | Get full job details (status, URL, prompt, ratio) |
+| `myapi image models` | List available image models with per-image pricing |
 | `myapi image delete <job_id>` | Delete the asset (job record kept for history) |
 
-## Generate Flags
+### Generate flags
 
 | Flag | Allowed | Default | Notes |
 |---|---|---|---|
+| `--model` | id from `image models` | `gemini-2.5-flash-image` | Override the default model (e.g. `gemini-3-pro-image-preview` for higher quality) |
 | `--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 |
+| `--style` | free-form | none | e.g. `"watercolor"`, `"cyberpunk neon"` |
+| `--colors` | hex list | none | e.g. `"#ff6600,#003366"` — the model biases toward these |
+| `--text` | flag (no value) | off | Allow text in the image. Off by default — text rarely renders well |
+<!-- generated:end -->
+
+## Examples
+<!-- llm:start -->
+```bash
+# Plain generation
+myapi image generate "A clean flat-color logo for a sustainable jam company"
+
+# With styling
+myapi image generate "Hero image, mountains at dawn" \
+  --ratio 16:9 --style "watercolor" --colors "#ff6600,#003366"
 
-## Async Behavior
+# Higher-quality pro model
+myapi image generate "Editorial portrait, soft natural light" \
+  --model gemini-3-pro-image-preview --ratio 4:3
+
+# History
+myapi image list
+myapi image get <job_id>
+myapi image delete <job_id>
+
+# Catalog — see which models are available and what they cost per image
+myapi image models
+```
 
-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>
-   ```
+Tips for agents:
+- Prompts with explicit text usually fail — for branded text use a separate text overlay step.
+- For non-square layouts, set `--ratio` rather than describing dimensions in the prompt.
+<!-- llm:end -->
 
 ## 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).
+- Cost is per-image at the selected model's catalog rate (`myapi image models`). Failed jobs aren't charged.
+- The asset URL is public — don't generate sensitive content.
+- `delete` is permanent for the asset; the job record (prompt + metadata) stays for history.
 
 Run `myapi image --help` or `myapi image <subcommand> --help` for full flag reference.

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

@@ -0,0 +1,35 @@
+# my-llm-api
+
+Provider-agnostic LLM completions and embeddings, billed at upstream cost. Today routes to Gemini; the model id is just a string, so additional providers land without breaking callers.
+
+## What it does
+
+- **Chat completion** — messages array (role/content), get reply + usage + cost
+- **Embeddings** — single string or batch, returns vector(s) + usage
+- **Model catalog** — list available models with per-1M-token pricing
+
+## Quickstart
+
+```bash
+myapi llm models
+myapi llm complete "explain HMAC in two sentences"   # defaults to gemini-3.1-flash-lite-preview
+myapi llm embed "the quick brown fox" --model gemini-embedding-001
+```
+
+## Authentication
+
+```bash
+export MYAPI_KEY=mak_...
+```
+
+Requires `api_key` and `org_id` from **myapihq**. Inference cost is debited from your MyAPI balance — top up via `myapi billing topup`.
+
+## When to use
+
+This is the **workflow-step LLM** — use it inside scripted pipelines (summarize a doc, classify an email, embed text for similarity). It is **not** a replacement for your own reasoning if you're an agent; you already have a model.
+
+## Documentation
+
+Model catalog, message shapes, and cost semantics: see `SKILL.md`.
+
+Run `myapi llm --help` for inline reference.

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

@@ -0,0 +1,125 @@
+---
+name: my-llm-api
+version: 1.0.0
+description: >
+  Provider-agnostic LLM completions and embeddings, billed at upstream cost.
+  The model id is just a string — today routes to Gemini, more providers land
+  without breaking callers. Use this inside workflow steps and scripted
+  pipelines, not as a replacement for your own reasoning.
+triggers: [llm, completion, chat, embed, embedding, gemini, inference, summarize, classify, vector]
+checksum: sha256-pending
+---
+
+# MyLLMAPI
+
+A thin, OpenAI-compatible-shape LLM gateway. Three endpoints: `complete` (chat), `embed` (vectors), `models` (catalog). Pricing is per-1M tokens at the upstream rate while we build our own inference; cost is debited from your MyAPI balance.
+
+## Capabilities
+<!-- llm:start -->
+Use this for workflow tasks — summarize a doc, classify an inbound email, embed text for similarity, expand a one-line prompt into structured copy. The reply goes to stdout; a one-line usage footer (tokens + cost + finish reason) goes to stderr, so `myapi llm complete ... | jq` and similar pipelines work as expected.
+
+**Don't use this as your own model.** If you're an agent reading this, you already have a more capable model than what's exposed here. Reach for `llm complete` when you're scripting a recurring step where a small/cheap model is the right tool — not for one-shot reasoning that you can just do yourself.
+
+### Messages shape
+```json
+{
+  "model": "gemini-3.1-flash-lite-preview",
+  "messages": [
+    { "role": "system", "content": "You are a terse editor." },
+    { "role": "user",   "content": "Tighten this paragraph: ..." }
+  ],
+  "max_tokens": 200,
+  "temperature": 0.2,
+  "stop": ["\n\n"]
+}
+```
+
+Roles: `system | user | assistant`. Multiple system messages collapse to one instruction. `max_tokens`, `temperature`, and `stop` are optional — per-model defaults apply.
+
+### Complete response
+```json
+{
+  "model": "gemini-3.1-flash-lite-preview",
+  "content": "...assistant reply...",
+  "finish_reason": "stop",
+  "usage": { "input_tokens": 42, "output_tokens": 87, "cost_usd": 0.000029 }
+}
+```
+
+`finish_reason` is typically `stop` (model returned naturally), `length` (hit max_tokens — increase if you need more), or `safety` (blocked).
+
+### Embed response
+```json
+{
+  "model": "gemini-embedding-001",
+  "embeddings": [[-0.0226, 0.0118, ...]],
+  "usage": { "input_tokens": 5, "cost_usd": 0.0000007 }
+}
+```
+
+`embeddings` is always `number[][]` — even a single-string input returns a one-element array of vectors. Embed-only usage has no `output_tokens`.
+
+### Model catalog
+- Chat models: `id`, `kind: 'chat'`, `context` (token window), `input_per_1m`, `output_per_1m`
+- Embed models: `id`, `kind: 'embed'`, `dimensions`, `input_per_1m`
+
+Today: `gemini-3.1-pro-preview`, `gemini-3.1-flash-lite-preview`, `gemini-embedding-001`. Catalog is live — always query `models` rather than hard-coding ids.
+<!-- llm:end -->
+
+## Commands
+<!-- generated:start -->
+| Command | What it does |
+|---|---|
+| `myapi llm models [--kind chat\|embed] [--json]` | List available models with pricing |
+| `myapi llm complete "<prompt>" [--model <id>] [--system "<s>"] [--max-tokens N] [--temperature 0..1] [--stop <csv>] [--file <path>] [--json]` | Chat completion; reply to stdout, usage to stderr. Default model: `gemini-3.1-flash-lite-preview` |
+| `myapi llm embed "<text>" --model <id> [--file <path>] [--json]` | Embed a string; default render shows model + dim + first 5 values |
+<!-- generated:end -->
+
+Pass `-` as the prompt to read from stdin. Pass `--file <path>` to read a longer prompt from disk.
+
+## Examples
+<!-- llm:start -->
+```bash
+# List the catalog
+myapi llm models
+# Filter to embed-only
+myapi llm models --kind embed --json | jq '.models[].id'
+
+# One-shot completion (default model = gemini-3.1-flash-lite-preview)
+myapi llm complete "Summarize in 12 words: $(cat README.md)"
+
+# Override the model (e.g. when you need pro-tier quality)
+myapi llm complete "Polish this draft: ..." \
+  --model gemini-3.1-pro-preview \
+  --system "You are a terse copy editor" \
+  --max-tokens 300
+
+# Read from stdin (useful in pipelines)
+cat email.txt | myapi llm complete - \
+  --system "Classify intent: support | sales | spam"
+
+# Embed and save the vector
+myapi llm embed --file doc.txt --model gemini-embedding-001 --json \
+  > doc.vec.json
+```
+
+### End-to-end recipe — classify inbound webhooks
+```bash
+# Pull the last delivery body, classify with a tiny model, route accordingly
+BODY=$(myapi webhook delivery <delivery_id> --json | jq -r '.body')
+INTENT=$(printf '%s' "$BODY" | myapi llm complete - \
+  --system 'Respond with one word: support, sales, or spam.' \
+  --max-tokens 5)
+echo "Routing $INTENT"
+```
+<!-- llm:end -->
+
+## Notes
+
+- **No upstream tokens involved.** MyAPI never holds your Gemini/OpenAI/Anthropic credentials — we hold ours, you pay us at-cost while we build our own inference. The model id is just a string; routing happens server-side.
+- **Latency.** Flash-lite ≈ 200–800ms first token. Pro ≈ 600ms–2s. Embeddings sub-second.
+- **Cost.** `usage.cost_usd` is the authoritative number — debited at upstream rate (no MyAPI markup today). Use this for cost-accounting in workflows.
+- **Streaming.** Not exposed yet — `complete` returns the full reply. Add streaming support when there's a use case that requires it.
+- **Bring-your-own-key.** Not supported by design. MyAPI's value here is unified billing + a stable API across providers; managing your upstream keys would defeat both.
+
+Run `myapi llm --help` for inline reference.

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

@@ -0,0 +1,6 @@
+{
+  "name": "my-llm-api",
+  "description": "Provider-agnostic LLM completions + embeddings via MyAPI. Routes to managed models (Gemini today, more soon) at upstream cost. Use in workflow steps, not for your own reasoning.",
+  "version": "1.0.0",
+  "published": true
+}

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

@@ -17,7 +17,7 @@ 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>)"
+curl -O "$(myapi storage get-url <asset_id>)"
 ```
 
 ## Authentication

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

@@ -1,88 +1,78 @@
 ---
 name: my-storage-api
+version: 1.0.0
 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.
+  Edge-hosted asset storage. Upload local files (.png/.jpg/.gif/.webp) directly, or have the server fetch from a public URL. Each asset gets a stable public CDN URL.
+triggers: [storage, upload, ingest, asset, cdn, image hosting, file upload, get-url, download, public url]
+checksum: sha256-pending
 ---
 
 # 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
+Per-org asset storage with edge CDN delivery. Two ways in: direct upload (local file → multipart) or ingest (server fetches a public URL). Both produce a stable public URL like `https://api.mystorageapi.com/storage/<id>`.
 
-Both produce a stable public URL like `https://api.mystorageapi.com/storage/<id>`.
+## Capabilities
+<!-- llm:start -->
+Storage is the asset layer. Anything you upload or ingest is served from the edge under a permanent public URL — embed it in funnel pages, email templates, anywhere.
 
-## How It Fits Together
+`upload` accepts `.png`, `.jpg`, `.jpeg`, `.gif`, `.webp` from the local filesystem. For other formats (PDF, mp4, webm, svg) host the file somewhere public and use `ingest` instead — the server fetches it for you.
 
-- 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.
+Generated images from **myimageapi** automatically land here; they appear in `storage list` under their job id.
 
-## Quick Start
+Use `get` for a round-trip metadata fetch. Use `get-url` when you just need the URL — it's a pure local URL constructor (no API call, no auth, no rate limit), perfect for piping to curl or embedding into HTML.
+<!-- llm:end -->
 
+## Commands
+<!-- generated:start -->
+| Command | What it does |
+|---|---|
+| `myapi storage list` | List all stored assets |
+| `myapi storage upload <file>` | Direct multipart upload of a local image |
+| `myapi storage ingest <url>` | Server fetches a public URL into storage |
+| `myapi storage get <asset_id>` | Round-trip the API for full metadata (`--json` or human block) |
+| `myapi storage get-url <asset_id>` | Pure local URL constructor — no API call, no auth |
+| `myapi storage delete <asset_id>` | Permanently delete the asset |
+<!-- generated:end -->
+
+## Examples
+<!-- llm:start -->
 ```bash
-# Direct upload
+# Direct upload of a local image
 myapi storage upload ./logo.png --name "brand-logo"
 
-# Ingest a public URL (server pulls)
+# Ingest a remote file (server pulls it down)
 myapi storage ingest https://example.com/hero.jpg --name "hero"
 
-# List
+# Inspect
 myapi storage list
+myapi storage get <asset_id>
 
-# Get the public URL (curl-friendly)
-curl -O "$(myapi storage get <asset_id>)"
+# Embed the URL — no API call, perfect for scripts
+URL=$(myapi storage get-url <asset_id>)
+echo "<img src=\"$URL\" />"
+curl -O "$URL"
 
-# Delete
+# Clean up
 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 |
+<!-- llm:end -->
 
 ## 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.
+- **`upload`** — file is on your machine. Multipart POST. Image types only: `.png`, `.jpg`, `.jpeg`, `.gif`, `.webp`.
+- **`ingest`** — file is at a public HTTP(S) URL. Server downloads and stores. Useful for migrating assets, pulling in third-party images you have rights to, or for non-image types (`image/svg+xml`, `application/pdf`, `video/mp4`, `video/webm`).
 
-The display name is for your reference only — the public URL uses the auto-generated id.
+Both produce identical asset records — `list` doesn't distinguish.
 
-## 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)"
-```
+## `get` vs `get-url`
 
-The URL itself is permanent until you `myapi storage delete <id>` — embed it freely in your funnels, emails, or anywhere else.
+- **`get <id>`** — round-trips the API. Returns name, URL, created_at. Honors `--json`. Use when you want metadata.
+- **`get-url <id>`** — local URL constructor. No API call, no auth, no rate limit. Output is exactly `https://api.mystorageapi.com/storage/<id>` (or whatever `MYAPI_STORAGE_URL` is set to). Use to embed URLs into HTML, pipe to curl, or build download links cheaply.
 
 ## Notes
 
-- Assets are public by default. Don't store sensitive files.
+- 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.
+- The URL is permanent until you `myapi storage delete <id>` — embed it freely.
 
 Run `myapi storage --help` for full flag reference.

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

@@ -15,7 +15,7 @@ Inbound HTTP endpoints that receive POSTs from third-party services and store ev
 ```bash
 # Create an endpoint
 myapi webhook create "stripe-events"
-# → prints: Inbound URL: https://api.myapihq.com/webhook/in/<slug>
+# → prints: Inbound URL: https://api.mywebhookapi.com/webhook/in/<slug>
 
 # POST to it from anywhere
 curl -X POST <inbound-url> -d '{"event":"x"}'