@hitslop/slurp 0.0.0-stage → 0.1.1

package/.gitignore

@@ -0,0 +1,2 @@
+/node_modules
+

package/CHANGELOG.md

@@ -0,0 +1,40 @@
+# Changelog
+
+## 0.1.1
+
+Run `slurp cloud upgrade` to put the fixes below on an existing Worker (your data and settings are kept).
+
+- **RevenueCat webhooks (Preview)**: `slurp project webhook PROJECT revenuecat` gives the URL and the Authorization header value to paste into RevenueCat. Purchases, renewals, cancellations and refunds arrive as `revenuecat.<type>` events (retries are one row), and a `revenue` view in SQL lists them. RevenueCat's optional HMAC signing is not supported yet.
+- **Fixed: a redelivered webhook could stop `slurp sync`.** A webhook with no time of its own was stamped with its arrival time, so a redelivery had the same id and a different time, which the importer treats as a conflict. Such a delivery now keeps the time it first arrived. A generic POST with no `Idempotency-Key` and no body `timestamp` is its own event each time. See [webhooks](docs/webhooks.md).
+- **Fixed: archives stay unpublished after a long R2 outage.** Cloudflare retries a failing alarm six times and then stops. Publishing now schedules its own retries with backoff until R2 answers, so a quiet project publishes by itself once R2 is back (`ARCHIVE_RETRY_MS`).
+- **Fixed: oversized bodies were buffered before being refused.** `/v1/events` now reads its body as a capped stream and stops at the limit, even with no `Content-Length`.
+- **Fixed: an impossible timestamp such as `1e300` failed a whole Sentry envelope.** Sentry and Segment events with a time that is not a real date now fall back to `sent_at`, then the arrival time.
+- Archive listings sign every URL with one key and one expiry, and report that expiry.
+- **slurp.run measures itself with Slurp** (see `dogfood/`): page views, the feedback widget and two clicks go to a Worker in the maintainers' account, and the report that reads them is committed as an example. The site also got a mobile pass.
+
+## 0.1.0
+
+The first release.
+
+- **Self-hosted event capture** in your own Cloudflare account: a Worker with one Durable Object per project (its keys, group commit, sealing alarm) and an R2 bucket of sealed gzip NDJSON archives, deployed with one command (`slurp cloud init`) or the Deploy to Cloudflare button.
+- **Projects and senders**: a project is one event stream; a website, an app and a webhook can all send into it with their own publishable keys (`slurp project key create PROJECT --scope publishable --name ios`), and every event is stamped with its key's name as `sender` (a column in your local `events` table). A key names its project (`slurp_pk_<project>_<random>`), so a request never waits on a global lookup, a revoked key stops on the next request, and the SDKs need no project id. `slurp init` is idempotent: asking for a name that exists joins that project and never changes a key.
+- **Python**: the Segment and Sentry Python SDKs (`segment-analytics-python`, `sentry-sdk`) work unmodified by changing the host or the DSN, verified against a real Worker on Python 3.9, 3.12 and 3.14. There is no native Python SDK.
+- **Webhooks (Preview)**: GitHub, Stripe or any tool that can POST sends events to `/hooks/<provider>` on your Worker, each with its own named key (so events carry `sender = 'github'`), checked against the provider's signature and stored whole. `slurp project webhook PROJECT github` prints the URL, the secret and the steps; a `releases` view in SQL lists GitHub releases and deployments. Tested against the providers' documented signature examples, not yet live deliveries. See [webhooks](docs/webhooks.md).
+- **`slurp` CLI** (macOS and Linux): `cloud init|status|doctor|upgrade|destroy`, `connect`, `setup`, `init`, `send`, `identify`, `sync` into a local DuckDB file, `sql`, `health`, `report` and agent skills. Install with `curl -LsSf https://slurp.run/install | sh` or `npm install -g @hitslop/slurp`.
+- **JavaScript SDK**, `@hitslop/slurp-sdk`: browser and Node capture with a durable queue, batching and byte-identical retries (0.1.1 also runs on React Native).
+- **Reports**: Markdown with named SQL, charts, metrics and tables, rendered to a self-contained HTML file (with hover details), PNG and PDF; themes and templates you can write yourself; DuckDB's behavioral functions for retention, funnels and sessions.
+- **SQL helpers** in every project database: `events_with_person`, `calendar()`, `session_start()`, `pct()` and more.
+- **React Native / Expo SDK**, `@hitslop/slurp-react-native`: events kept in AsyncStorage so they survive the app being killed, sent when the app goes to the background or the network returns, with device and app context. Preview: tested against fakes, not yet on a device.
+- **Swift SDK** (iOS, macOS, tvOS, watchOS): Foundation only, file-backed durable queue, byte-identical retries, lifecycle flush. Add `https://github.com/hitSlop/slurp` in Xcode. Preview: unit tested and run against a local Worker, not yet in an app on a device.
+- **Use your Segment SDK**: change its host to your Worker (`/v1/t|i|p|s|g|a`, `/v1/b`, `/v1/batch` and the settings document). Verified with analytics-node, analytics-next and analytics-swift.
+- **Use your Sentry SDK**: change the DSN (the public key is your publishable key in hex). Errors are stored whole as `error` events and read with the new `errors` view. No symbolication or issue UI. Verified with `@sentry/node` and `@sentry/browser`.
+- **Records up to 1 MiB**, stored whole and never truncated (was 32 KiB); a larger record is refused with `413`.
+- **Sharper report PNGs**: drawn at 2x (1680 px wide for the 840 px layout), so text and charts stay crisp on high-density screens and when shared in chat or email.
+- **`slurp mcp`**: an MCP server over stdio so Claude Code, Claude Desktop, Cursor, Codex and Windsurf can read your events (`describe_schema`, read-only `sql` in a sandbox with no local file access, `sync`, `health`, reports). `--allow-send` adds `send_event` and `identify`, tagged `context.source = "mcp"`.
+- **`slurp notify slack|discord`**: post a message and a report image from the command line (Slack bot token or webhook, Discord webhook), for scheduled reports.
+- **A small public API**: every method of the Worker's webrpc schema is tagged `@public` (a client outside this repo may use it) or `@internal` (CLI and control plane), so a client for third parties can be generated from the public methods only.
+- **Link previews**: a social card (`og.png`) and Open Graph and Twitter tags on every page of the site.
+- **Feedback widget** in the JS SDK (`@hitslop/slurp-sdk/feedback`): a drop-in "Feedback" button and form that sends a `feedback` event with the message, an optional rating and email.
+- **One set of delivery rules in every SDK**, checked by the shared scenarios in `sdks/conformance/delivery.json`: any 2xx acknowledges a batch; 408, 429, 5xx, network errors and requests with no answer are retried with the identical bytes; 413 splits a batch and drops only a single oversized event; 401 and 403 stop the client; the queue is bounded in bytes as well as events (`maxQueueBytes`); damaged saved lines are dropped rather than sent; a replaced key starts sending again. React Native stores its queue in 256 KB pieces to stay under AsyncStorage's per-value limit, and Swift reports errors on a queue of its own so handlers can safely call back into the client.
+- **One saved connection**: the CLI keeps one plain token per Worker (no logins, sessions or refresh), and `slurp whoami` (the `Auth.Whoami` RPC) says what any key is (admin, secret or publishable, and its project and name), so a bot can verify its own read key. `slurp connect` accepts only the admin token and says why. See [How the connection works](docs/connection.md).
+

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Longtail Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,230 @@
-# Temporary Holding Version
+<p align="center">
+  <img src="docs/assets/slurp-mascot.png" width="300" alt="The Slurp anteater sipping a blue and red slushie through its long snout">
+</p>
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+<h1 align="center"><img src="docs/assets/slurp-logo.png" width="170" alt="Slurp"></h1>
+
+<p align="center"><a href="https://deploy.workers.cloudflare.com/?url=https%3A%2F%2Fgithub.com%2FhitSlop%2Fslurp%2Ftree%2Fmaster%2Fbackend"><img src="https://deploy.workers.cloudflare.com/button" alt="Deploy to Cloudflare"></a></p>
+
+<p align="center"><b>Product analytics for coding agents, in your own Cloudflare account.</b></p>
+<p align="center">Events in your Cloudflare account &nbsp;→&nbsp; <a href="https://duckdb.org"><img src="docs/assets/duckdb.jpeg" height="20" align="top" alt="DuckDB"></a> <a href="https://duckdb.org"><b>DuckDB</b></a> on your machine &nbsp;→&nbsp; your coding agent</p>
+<p align="center">
+  <a href="https://github.com/hitSlop/slurp/actions/workflows/check.yml"><img src="https://github.com/hitSlop/slurp/actions/workflows/check.yml/badge.svg?branch=master" alt="CI status"></a>
+  <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-e8002a" alt="MIT license"></a>
+  <a href="https://github.com/hitSlop/slurp/stargazers"><img src="https://img.shields.io/github/stars/hitSlop/slurp?style=flat&color=e8002a" alt="GitHub stars"></a>
+  <a href="https://discord.gg/jprRVWSRdn"><img src="https://img.shields.io/badge/Discord-join%20the%20chat-5865F2?logo=discord&logoColor=white" alt="Join the Discord"></a>
+</p>
+<!-- sdk-badges:start (generated by apps/site/scripts/readme-badges.mjs) -->
+<p align="center">
+  <b>Capture from</b>&nbsp; <img src="https://img.shields.io/badge/JavaScript-SDK-F7DF1E?style=flat-square&labelColor=1f2327&logo=javascript&logoColor=white" alt="JavaScript: SDK">
+  <img src="https://img.shields.io/badge/TypeScript-types%20included-3178C6?style=flat-square&labelColor=1f2327&logo=typescript&logoColor=white" alt="TypeScript: types included">
+  <img src="https://img.shields.io/badge/Web-browser%20SDK-4285F4?style=flat-square&labelColor=1f2327&logo=googlechrome&logoColor=white" alt="Web: browser SDK">
+  <img src="https://img.shields.io/badge/Node.js-SDK-5FA04E?style=flat-square&labelColor=1f2327&logo=nodedotjs&logoColor=white" alt="Node.js: SDK">
+  <img src="https://img.shields.io/badge/React%20Native-preview%20SDK-61DAFB?style=flat-square&labelColor=1f2327&logo=react&logoColor=white" alt="React Native: preview SDK">
+  <img src="https://img.shields.io/badge/Swift-preview%20SDK-F05138?style=flat-square&labelColor=1f2327&logo=swift&logoColor=white" alt="Swift: preview SDK">
+  <img src="https://img.shields.io/badge/HTTP%20API-any%20language-073551?style=flat-square&labelColor=1f2327&logo=curl&logoColor=white" alt="HTTP API: any language"><br>
+  <b>Keep using</b>&nbsp; <img src="https://img.shields.io/badge/Segment-change%20the%20host-52BD94?style=flat-square&labelColor=1f2327&logo=data%3Aimage%2Fsvg%2Bxml%3Bbase64%2CPHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIwLjk3ZW0iIGhlaWdodD0iMWVtIiB2aWV3Qm94PSIwIDAgMjU2IDI2NSI%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%3D%3D" alt="Segment: change the host">
+  <img src="https://img.shields.io/badge/Sentry-change%20the%20DSN-362D59?style=flat-square&labelColor=1f2327&logo=sentry&logoColor=white" alt="Sentry: change the DSN">
+  <img src="https://img.shields.io/badge/Python-via%20Segment%20or%20Sentry-3776AB?style=flat-square&labelColor=1f2327&logo=python&logoColor=white" alt="Python: via Segment or Sentry"><br>
+  <b>Coming</b>&nbsp; <img src="https://img.shields.io/badge/Rust-coming%20soon-9CA3AF?style=flat-square&labelColor=1f2327&logo=rust&logoColor=white" alt="Rust: coming soon">
+  <img src="https://img.shields.io/badge/Kotlin-coming%20soon-9CA3AF?style=flat-square&labelColor=1f2327&logo=kotlin&logoColor=white" alt="Kotlin: coming soon">
+</p>
+<p align="center"><sub>Logos are trademarks of their owners, used only to show compatibility.</sub></p>
+<!-- sdk-badges:end -->
+
+Bring your events home. Capture application events into **your own Cloudflare account**, sync them into a local DuckDB file, and give your coding agent raw data for product analysis and reports.
+
+```
+your app ──► Worker + Durable Objects ──► R2 archives      (in your Cloudflare account)
+                                              │
+                              slurp sync ◄────┘   (verified, idempotent)
+                                   │
+                                   ▼
+            DuckDB on your machine ──► SQL, reports, your coding agent
+```
+
+No servers to run, no data leaving your account. The Cloudflare Free plan is enough to start.
+
+## From user signal to shipped fix
+
+<p align="center">
+  <img src="docs/assets/slurp-workbench.png" width="900" alt="Diagram: connections send events to Cloudflare R2; your coding agent syncs them into a local DuckDB file, runs SQL analysis, generates a report, ships a product fix and updates the tracking, which collects new signals.">
+</p>
+
+Your coding agent owns the whole span: it pulls the data, analyzes it with SQL, writes the report, ships the fix and updates the tracking so the next round of signals arrives. Today the JavaScript SDK and HTTP capture work; the other inputs in the picture (bug reports, chat, crashes, analytics tools, more SDKs) are on the roadmap, see [Connections](https://slurp.run/connections/).
+
+## What it costs
+
+<!-- pricing:start (generated by apps/site/scripts/readme-pricing.mjs) -->
+| Monthly USD, by events per month | 1M | 10M | 50M | 100M | 1B | 10B |
+|---|--:|--:|--:|--:|--:|--:|
+| [**Slurp, self-hosted on Cloudflare**](docs/self-hosting.md#costs-and-limits) | **Free** | **$0.43** | **$7.96** | **$11.21** | **$42 to $280** | **$420 to $3,200** |
+| [PostHog · Product Analytics](https://posthog.com/docs/product-analytics/pricing) | Free | $324.40 | $1,528.40 | $2,618.40 | $11,618.40 | $92,618.40 |
+| [Mixpanel · Growth (yearly billing)](https://mixpanel.com/pricing/) | Free | $840 | Contact sales | Contact sales | Contact sales | Contact sales |
+| [Amplitude · Plus](https://amplitude.com/pricing) | Free | Not published | Not published | Not published | Not published | Not published |
+| [OpenPanel · Cloud (monthly)](https://openpanel.dev/pricing) | $90 | $350 | $900 | Custom plan | Custom plan | Custom plan |
+
+*Vendor prices read from their public pricing pages on November 6, 2026; they change, so check before deciding. Mixpanel is yearly billing. Amplitude does not publish paid event prices, and Mixpanel and OpenPanel direct high volumes to sales.*
+
+The Slurp row is the Cloudflare bill for running your own Worker, not a Slurp fee: 20 events per request, about 320 bytes stored per event, 12 months of archives kept, at Cloudflare's list prices (the Workers Free plan covers you until about 50K requests a day). The 1B and 10B figures are ranges, extrapolated from load tests of about 5,000 events a second per source, not months of running those volumes; about two thirds of the bill is R2 storage, so event size and retention matter most. Details: [docs/self-hosting.md](docs/self-hosting.md#costs-and-limits).
+<!-- pricing:end -->
+
+## Quickstart
+
+[![Deploy to Cloudflare](https://deploy.workers.cloudflare.com/button)](https://deploy.workers.cloudflare.com/?url=https%3A%2F%2Fgithub.com%2FhitSlop%2Fslurp%2Ftree%2Fmaster%2Fbackend)
+
+One click deploys the Worker, Durable Objects and R2 bucket to your Cloudflare account (you choose an `ADMIN_TOKEN`). Then open the Worker's address: it shows the command that connects the CLI. Or do it all from a terminal (to build the CLI from source instead, see [Development](#development)):
+
+```sh
+# 1. Install the CLI (macOS or Linux), then deploy your Worker (needs a Cloudflare account and Node 20+)
+curl -LsSf https://slurp.run/install | sh
+# or: npm install -g @hitslop/slurp
+slurp cloud init             # logs in, creates the bucket, deploys the Worker, connects this computer
+slurp setup                  # once per computer: library folder and DuckDB
+
+# 2. In your app (npm install @hitslop/slurp-sdk to capture from code, or send from the CLI)
+cd /path/to/your/app
+slurp init --name "My app"   # connects this app, opens its quickstart page with your keys
+slurp send signed_up --user-id demo_alice --data '{"demo":true}'
+slurp sync                   # archives are sealed about every 10 minutes
+slurp sql 'SELECT event, count(*) AS n FROM events GROUP BY event'
+```
+
+Each project is one event stream on your Worker (many senders can write to it: a website, an app, a webhook) bound to one DuckDB file, stored locally or on an external drive. SQL, report definitions and project metadata stay with your app. No daemon is required. DuckDB 2.x is used for analysis.
+
+## Send events
+
+Every way lands in the same place: your Worker accepts the event durably, and `slurp sync` can read it after the next archive seal (about 10 minutes by default). You do not make the endpoint or the key by hand: `slurp init` creates your project on the Worker together with its first publishable key, and prints your ingest URL and that key. Those two values are all an SDK needs. A publishable key can only send events, so it is safe in a web page or an app. `slurp project setup PROJECT` shows them again, and `slurp project key create PROJECT --scope publishable --name ios` makes one key per sender. [Where they come from](docs/sdks.md#where-the-endpoint-and-key-come-from).
+
+| Send from | Install | Status |
+|---|---|---|
+| **JavaScript / TypeScript** (browser, Node) | `npm install @hitslop/slurp-sdk` | Published |
+| **React Native / Expo** | `npm install @hitslop/slurp-react-native @react-native-async-storage/async-storage` | Tested against fakes; not yet run on a device |
+| **Swift** (iOS, macOS, tvOS, watchOS) | Xcode: add the package `https://github.com/hitSlop/slurp` | Unit tested and run against a local Worker; not yet in an app on a device |
+| **Segment SDKs** you already use | Change the host to your Worker (below) | Verified with analytics-node, analytics-next, analytics-swift and `segment-analytics-python` |
+| **Sentry SDKs** you already use | Change the DSN to your Worker (below) | Verified with `@sentry/node`, `@sentry/browser` and `sentry-sdk` for Python |
+| **Python** | `pip install segment-analytics-python` or `sentry-sdk`, then change the host or DSN | Both run unmodified against a Worker on Python 3.9, 3.12 and 3.14; there is no native Python SDK |
+| **HTTP**, any language | `POST /v1/events` | Tested |
+| **The CLI** | `slurp send`, `slurp identify` | Tested |
+
+Coming, with no dates: first-party **Rust** and **Kotlin (Android)** SDKs, and local symbolication of Sentry stack traces in the CLI. Other Segment and Sentry SDKs (Kotlin, Go, Cocoa, Android...) speak the same protocols and should work with the same URL change, but are untested, so they are not claimed. Full recipes and limits: [docs/sdks.md](docs/sdks.md).
+
+**JavaScript SDK** (browser and Node, with a durable queue, batching and retries):
+
+```js
+import { init, track, identify, flush } from '@hitslop/slurp-sdk';
+
+init({
+  endpoint: 'https://slurp.YOUR-SUBDOMAIN.workers.dev/v1/events',
+  key: 'slurp_pk_…',
+});
+
+identify('user_42', { plan: 'pro' });
+track('signed_up', { plan: 'pro' });
+track('feedback', { message: 'Exporting a 4K video fails at 90%', rating: 2 }); // feedback is just another event (or mount the drop-in widget: @hitslop/slurp-sdk/feedback)
+await flush(); // in scripts, send queued events before exiting
+```
+
+**React Native / Expo**: events are kept in AsyncStorage, so they survive the app being killed, and are sent when the app goes to the background:
+
+```ts
+import { init, track, screen } from '@hitslop/slurp-react-native';
+
+init({ endpoint: 'https://slurp.YOUR-SUBDOMAIN.workers.dev/v1/events', key: 'slurp_pk_…' });
+screen('Home');
+track('purchase_completed', { total: 49 });
+```
+
+**Swift**: events are written to disk before they are sent:
+
+```swift
+import Slurp
+
+SlurpClient.configure(.init(key: "slurp_pk_…", endpoint: URL(string: "https://slurp.YOUR-SUBDOMAIN.workers.dev/v1/events")!))
+SlurpClient.shared.screen("Home")
+SlurpClient.shared.track("purchase_completed", ["total": 49])
+```
+
+**GitHub, Stripe, RevenueCat or any webhook?** `slurp project webhook PROJECT github` prints a URL and a secret to paste into the provider. Releases, deployments, payments and app purchases then arrive as events (named for the sender, stored whole), a `releases` view lists GitHub releases and deployments so a metric change can be lined up with the release behind it, and a `revenue` view lists RevenueCat purchases and renewals. Preview: [docs/webhooks.md](docs/webhooks.md).
+
+**Already using Segment?** Keep the SDK and point it at your Worker. Your publishable key is the write key; `page`, `screen`, `group` and `alias` are stored as `track` events with those names:
+
+```js
+// Node (@segment/analytics-node)
+const analytics = new Analytics({ writeKey: 'slurp_pk_…', host: 'https://slurp.YOUR-SUBDOMAIN.workers.dev', path: '/v1/batch' });
+// Browser (@segment/analytics-next)
+const [analytics] = await AnalyticsBrowser.load({ writeKey: 'slurp_pk_…', cdnURL: 'https://slurp.YOUR-SUBDOMAIN.workers.dev' });
+// Swift (analytics-swift)
+let config = Configuration(writeKey: "slurp_pk_…").apiHost("slurp.YOUR-SUBDOMAIN.workers.dev/v1").cdnHost("slurp.YOUR-SUBDOMAIN.workers.dev/v1")
+```
+
+**Already using Sentry?** Change the DSN. Errors are stored whole as `error` events and read with the `errors` view; there is no symbolication or issue UI. The DSN's public key is your publishable key as is (the setup page shows the finished DSN):
+
+```js
+Sentry.init({ dsn: 'https://slurp_pk_…@slurp.YOUR-SUBDOMAIN.workers.dev/1' });
+```
+
+```sql
+SELECT group_key, any_value(exception_type) AS type, count(*) AS n FROM errors GROUP BY group_key ORDER BY n DESC;
+```
+
+**The CLI**, from your app's folder, with the project's saved key (handy for testing, scripts and cron jobs):
+
+```sh
+slurp send signed_up --user-id user_42 --data '{"plan":"pro"}'
+slurp identify user_42 --data '{"plan":"pro"}'
+slurp send --stdin < events.ndjson        # NDJSON records from a file or a pipeline
+```
+
+**HTTP from any language**: POST newline-delimited JSON to `/v1/events`:
+
+```sh
+curl -X POST "https://slurp.YOUR-SUBDOMAIN.workers.dev/v1/events" \
+  -H "Authorization: Bearer slurp_pk_…" \
+  -H "Content-Type: application/x-ndjson" \
+  --data-binary $'{"id":"evt_1","type":"track","event":"signed_up","timestamp":"2026-11-07T12:00:00Z","user_id":"user_42","data":{"plan":"pro"}}\n'
+```
+
+Retrying the exact same bytes is safe: the Worker answers `Slurp-Duplicate: 1`. The event format is described in [docs/architecture.md](docs/architecture.md#contracts).
+
+## Connect your agent
+
+```sh
+slurp agent setup --out .agents/skills/slurp        # skills for any coding agent that runs commands
+claude mcp add slurp -- slurp mcp --project "$PWD" # or MCP: Claude Code, Cursor, Codex, Claude Desktop, Windsurf
+```
+
+`slurp mcp` lets an AI client describe the schema, run read-only SQL (in a sandbox that cannot read local files), sync and build reports; `--allow-send` also lets it send events, tagged `context.source = "mcp"`. To post results to your team, `slurp notify slack --channel C0123ABCD --file report/report.png --text "Weekly report"` (Slack bot token) or `slurp notify discord ...` (webhook), run from cron for a scheduled report. Tools, config for each client and a schedule recipe: [docs/integrations.md](docs/integrations.md).
+
+## Community
+
+Questions, ideas and show-and-tell: [Discord](https://discord.gg/jprRVWSRdn). Bugs and feature requests: [GitHub issues](https://github.com/hitSlop/slurp/issues). The site is [slurp.run](https://slurp.run).
+
+## Repository
+
+| Path | What |
+|---|---|
+| `backend/` | The Worker (TypeScript): ingest, archives, control plane. Self-contained so it can be deployed on its own. |
+| `crates/` | Rust CLI (`slurp-cli`), client and archive reader (`slurp-client`), Markdown reports (`slurp-document`, `slurp-render`) |
+| `sdks/` | SDKs: [`js`](sdks/js), [`react-native`](sdks/react-native), [`swift`](sdks/swift) (the root `Package.swift` exposes it to Swift Package Manager) |
+| `apps/site` | The public site (home, docs, self-host page, cost comparison) |
+| `apps/setup` | The private offline setup page `slurp init` opens (built into the CLI as `setup.html`) |
+| `docs/` | [Documentation](docs/README.md) |
+
+## Development
+
+```sh
+pnpm install                      # website, landing, SDK
+pnpm --filter slurp-setup build   # the quickstart page the CLI embeds (crates/slurp-cli/assets/setup.html)
+pnpm --filter slurp-site build
+cargo test --project
+(cd backend && npm install && npm test)   # Worker tests under wrangler dev, incl. the real CLI
+(cd sdks/js && node --test test/*.test.ts)
+backend/api/generate.sh --check   # regenerate webrpc clients (needs Go; webrpc-gen is pinned in the script)
+```
+
+The CLI contract test needs `cargo build -p slurp-cli` and a DuckDB 2 executable (`SLURP_DUCKDB`, default `~/.slurp/bin/duckdb`); it skips cleanly without them.
+
+## License
+
+MIT. See [LICENSE](LICENSE).

package/binary-install.js

@@ -0,0 +1,348 @@
+const {
+  createWriteStream,
+  existsSync,
+  mkdirSync,
+  mkdtemp,
+  rmSync,
+} = require("fs");
+const { join, sep } = require("path");
+const { spawnSync } = require("child_process");
+const { tmpdir } = require("os");
+
+const https = require("node:https");
+const http = require("node:http");
+
+const tmpDir = tmpdir();
+
+const error = (msg) => {
+  console.error(msg);
+  process.exit(1);
+};
+
+function getProxyForUrl(urlString) {
+  const url = new URL(urlString);
+  const isHttps = url.protocol === "https:";
+
+  const noProxy = process.env.NO_PROXY || process.env.no_proxy || "";
+  if (noProxy === "*") return null;
+  if (noProxy) {
+    const hostname = url.hostname.toLowerCase();
+    const noProxyList = noProxy.split(",").map((s) => s.trim().toLowerCase());
+    for (const entry of noProxyList) {
+      if (hostname === entry || hostname.endsWith("." + entry)) {
+        return null;
+      }
+    }
+  }
+
+  const proxyEnv = isHttps
+    ? process.env.HTTPS_PROXY || process.env.https_proxy
+    : process.env.HTTP_PROXY || process.env.http_proxy;
+
+  if (!proxyEnv) return null;
+
+  const proxyUrl = new URL(proxyEnv);
+
+  let auth = null;
+  if (proxyUrl.username || proxyUrl.password) {
+    auth = `${proxyUrl.username}:${proxyUrl.password}`;
+  }
+
+  return {
+    hostname: proxyUrl.hostname,
+    port: proxyUrl.port || (proxyUrl.protocol === "https:" ? 443 : 80),
+    auth: auth,
+  };
+}
+
+function connectThroughProxy(proxy, target) {
+  return new Promise((resolve, reject) => {
+    const headers = {};
+    if (proxy.auth) {
+      headers["Proxy-Authorization"] =
+        "Basic " + Buffer.from(proxy.auth).toString("base64");
+    }
+
+    const connectReq = http.request({
+      hostname: proxy.hostname,
+      port: proxy.port,
+      method: "CONNECT",
+      path: `${target.hostname}:${target.port || 443}`,
+      headers,
+    });
+    connectReq.on("connect", (res, socket) => {
+      if (res.statusCode === 200) {
+        resolve(socket);
+      } else {
+        reject(new Error(`Proxy CONNECT failed with status ${res.statusCode}`));
+      }
+    });
+    connectReq.on("error", reject);
+    connectReq.end();
+  });
+}
+
+function download(urlString, maxRedirects) {
+  if (maxRedirects === undefined) maxRedirects = 5;
+  return new Promise((resolve, reject) => {
+    if (maxRedirects < 0) {
+      return reject(new Error("Too many redirects"));
+    }
+
+    const parsed = new URL(urlString);
+    const isHttps = parsed.protocol === "https:";
+    const mod = isHttps ? https : http;
+    const proxy = getProxyForUrl(urlString);
+
+    const doRequest = (extraOptions) => {
+      const options = Object.assign(
+        {
+          hostname: parsed.hostname,
+          port: parsed.port || (isHttps ? 443 : 80),
+          path: parsed.pathname + parsed.search,
+          method: "GET",
+          headers: { "User-Agent": "cargo-dist-npm-installer" },
+        },
+        extraOptions || {},
+      );
+
+      if (proxy && !isHttps) {
+        // HTTP through HTTP proxy: request the full URL via the proxy
+        options.hostname = proxy.hostname;
+        options.port = proxy.port;
+        options.path = urlString;
+        if (proxy.auth) {
+          options.headers["Proxy-Authorization"] =
+            "Basic " + Buffer.from(proxy.auth).toString("base64");
+        }
+      }
+
+      const req = mod.request(options, (res) => {
+        if (
+          res.statusCode >= 300 &&
+          res.statusCode < 400 &&
+          res.headers.location
+        ) {
+          res.resume();
+          const nextUrl = new URL(res.headers.location, urlString).toString();
+          return download(nextUrl, maxRedirects - 1).then(resolve, reject);
+        }
+        if (res.statusCode < 200 || res.statusCode >= 300) {
+          res.resume();
+          return reject(new Error(`HTTP ${res.statusCode} from ${urlString}`));
+        }
+        resolve(res);
+      });
+      req.on("error", reject);
+      req.end();
+    };
+
+    if (proxy && isHttps) {
+      connectThroughProxy(proxy, parsed).then(
+        (socket) => doRequest({ socket, agent: false }),
+        reject,
+      );
+    } else {
+      doRequest();
+    }
+  });
+}
+
+class Package {
+  constructor(platform, name, url, filename, zipExt, binaries) {
+    let errors = [];
+    if (typeof url !== "string") {
+      errors.push("url must be a string");
+    } else {
+      try {
+        new URL(url);
+      } catch (e) {
+        errors.push(e);
+      }
+    }
+    if (name && typeof name !== "string") {
+      errors.push("package name must be a string");
+    }
+    if (!name) {
+      errors.push("You must specify the name of your package");
+    }
+    if (binaries && typeof binaries !== "object") {
+      errors.push("binaries must be a string => string map");
+    }
+    if (!binaries) {
+      errors.push("You must specify the binaries in the package");
+    }
+
+    if (errors.length > 0) {
+      let errorMsg =
+        "One or more of the parameters you passed to the Binary constructor are invalid:\n";
+      errors.forEach((error) => {
+        errorMsg += error;
+      });
+      errorMsg +=
+        '\n\nCorrect usage: new Package("my-binary", "https://example.com/binary/download.tar.gz", {"my-binary": "my-binary"})';
+      error(errorMsg);
+    }
+
+    this.platform = platform;
+    this.url = url;
+    this.name = name;
+    this.filename = filename;
+    this.zipExt = zipExt;
+    this.installDirectory = join(__dirname, "node_modules", ".bin_real");
+    this.binaries = binaries;
+
+    if (!existsSync(this.installDirectory)) {
+      mkdirSync(this.installDirectory, { recursive: true });
+    }
+  }
+
+  exists() {
+    for (const binaryName in this.binaries) {
+      const binRelPath = this.binaries[binaryName];
+      const binPath = join(this.installDirectory, binRelPath);
+      if (!existsSync(binPath)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  install(suppressLogs = false) {
+    if (this.exists()) {
+      if (!suppressLogs) {
+        console.error(
+          `${this.name} is already installed, skipping installation.`,
+        );
+      }
+      return Promise.resolve();
+    }
+
+    try {
+      rmSync(this.installDirectory, { recursive: true, force: true });
+    } catch {
+      // ignore - directory may not exist
+    }
+
+    mkdirSync(this.installDirectory, { recursive: true });
+
+    if (!suppressLogs) {
+      console.error(`Downloading release from ${this.url}`);
+    }
+
+    return download(this.url)
+      .then((res) => {
+        return new Promise((resolve, reject) => {
+          mkdtemp(`${tmpDir}${sep}`, (err, directory) => {
+            if (err) return reject(err);
+            let tempFile = join(directory, this.filename);
+            const sink = res.pipe(createWriteStream(tempFile));
+            sink.on("error", (err) => reject(err));
+            sink.on("close", () => {
+              if (/\.tar\.*/.test(this.zipExt)) {
+                const result = spawnSync("tar", [
+                  "xf",
+                  tempFile,
+                  // The tarballs are stored with a leading directory
+                  // component; we strip one component in the
+                  // shell installers too.
+                  "--strip-components",
+                  "1",
+                  "-C",
+                  this.installDirectory,
+                ]);
+                if (result.status == 0) {
+                  resolve();
+                } else if (result.error) {
+                  reject(result.error);
+                } else {
+                  reject(
+                    new Error(
+                      `An error occurred untarring the artifact: stdout: ${result.stdout}; stderr: ${result.stderr}`,
+                    ),
+                  );
+                }
+              } else if (this.zipExt == ".zip") {
+                let result;
+                if (this.platform.artifactName.includes("windows")) {
+                  // Windows does not have "unzip" by default on many installations, instead
+                  // we use Expand-Archive from powershell
+                  result = spawnSync("powershell.exe", [
+                    "-NoProfile",
+                    "-NonInteractive",
+                    "-Command",
+                    `& {
+                        param([string]$LiteralPath, [string]$DestinationPath)
+                        Expand-Archive -LiteralPath $LiteralPath -DestinationPath $DestinationPath -Force
+                    }`,
+                    tempFile,
+                    this.installDirectory,
+                  ]);
+                } else {
+                  result = spawnSync("unzip", [
+                    "-q",
+                    tempFile,
+                    "-d",
+                    this.installDirectory,
+                  ]);
+                }
+
+                if (result.status == 0) {
+                  resolve();
+                } else if (result.error) {
+                  reject(result.error);
+                } else {
+                  reject(
+                    new Error(
+                      `An error occurred unzipping the artifact: stdout: ${result.stdout}; stderr: ${result.stderr}`,
+                    ),
+                  );
+                }
+              } else {
+                reject(
+                  new Error(`Unrecognized file extension: ${this.zipExt}`),
+                );
+              }
+            });
+          });
+        });
+      })
+      .then(() => {
+        if (!suppressLogs) {
+          console.error(`${this.name} has been installed!`);
+        }
+      })
+      .catch((e) => {
+        error(`Error fetching release: ${e.message}`);
+      });
+  }
+
+  run(binaryName) {
+    const promise = !this.exists() ? this.install(true) : Promise.resolve();
+
+    promise
+      .then(() => {
+        const [, , ...args] = process.argv;
+
+        const options = { cwd: process.cwd(), stdio: "inherit" };
+
+        const binRelPath = this.binaries[binaryName];
+        if (!binRelPath) {
+          error(`${binaryName} is not a known binary in ${this.name}`);
+        }
+        const binPath = join(this.installDirectory, binRelPath);
+        const result = spawnSync(binPath, args, options);
+
+        if (result.error) {
+          error(result.error);
+        }
+
+        process.exit(result.status);
+      })
+      .catch((e) => {
+        error(e.message);
+      });
+  }
+}
+
+module.exports.Package = Package;

package/binary.js

@@ -0,0 +1,124 @@
+const { Package } = require("./binary-install");
+const os = require("os");
+const libc = require("detect-libc");
+
+const error = (msg) => {
+  console.error(msg);
+  process.exit(1);
+};
+
+const {
+  name,
+  artifactDownloadUrls,
+  supportedPlatforms,
+  glibcMinimum,
+} = require("./package.json");
+
+// FIXME: implement NPM installer handling of fallback download URLs
+const artifactDownloadUrl = artifactDownloadUrls[0];
+const builderGlibcMajorVersion = glibcMinimum.major;
+const builderGlibcMinorVersion = glibcMinimum.series;
+
+const getPlatform = () => {
+  const rawOsType = os.type();
+  const rawArchitecture = os.arch();
+
+  // We want to use rust-style target triples as the canonical key
+  // for a platform, so translate the "os" library's concepts into rust ones
+  let osType = "";
+  switch (rawOsType) {
+    case "Windows_NT":
+      osType = "pc-windows-msvc";
+      break;
+    case "Darwin":
+      osType = "apple-darwin";
+      break;
+    case "Linux":
+      osType = "unknown-linux-gnu";
+      break;
+  }
+
+  let arch = "";
+  switch (rawArchitecture) {
+    case "x64":
+      arch = "x86_64";
+      break;
+    case "arm64":
+      arch = "aarch64";
+      break;
+  }
+
+  if (rawOsType === "Linux") {
+    if (libc.familySync() == "musl") {
+      osType = "unknown-linux-musl-dynamic";
+    } else if (libc.isNonGlibcLinuxSync()) {
+      console.warn(
+        "Your libc is neither glibc nor musl; trying static musl binary instead",
+      );
+      osType = "unknown-linux-musl-static";
+    } else {
+      let libcVersion = libc.versionSync();
+      let splitLibcVersion = libcVersion.split(".");
+      let libcMajorVersion = splitLibcVersion[0];
+      let libcMinorVersion = splitLibcVersion[1];
+      if (
+        libcMajorVersion != builderGlibcMajorVersion ||
+        libcMinorVersion < builderGlibcMinorVersion
+      ) {
+        // We can't run the glibc binaries, but we can run the static musl ones
+        // if they exist
+        console.warn(
+          "Your glibc isn't compatible; trying static musl binary instead",
+        );
+        osType = "unknown-linux-musl-static";
+      }
+    }
+  }
+
+  // Assume the above succeeded and build a target triple to look things up with.
+  // If any of it failed, this lookup will fail and we'll handle it like normal.
+  let targetTriple = `${arch}-${osType}`;
+  let platform = supportedPlatforms[targetTriple];
+
+  if (!platform) {
+    error(
+      `Platform with type "${rawOsType}" and architecture "${rawArchitecture}" is not supported by ${name}.\nYour system must be one of the following:\n\n${Object.keys(
+        supportedPlatforms,
+      ).join(",")}`,
+    );
+  }
+
+  return platform;
+};
+
+const getPackage = () => {
+  const platform = getPlatform();
+  const url = `${artifactDownloadUrl}/${platform.artifactName}`;
+  let filename = platform.artifactName;
+  let ext = platform.zipExt;
+  let binary = new Package(platform, name, url, filename, ext, platform.bins);
+
+  return binary;
+};
+
+const install = (suppressLogs) => {
+  if (!artifactDownloadUrl || artifactDownloadUrl.length === 0) {
+    console.warn("in demo mode, not installing binaries");
+    return;
+  }
+  const pkg = getPackage();
+
+  return pkg.install(suppressLogs);
+};
+
+const run = (binaryName) => {
+  const pkg = getPackage();
+
+  pkg.run(binaryName);
+};
+
+module.exports = {
+  install,
+  run,
+  getPackage,
+};

package/install.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+
+const { install } = require("./binary");
+install(false);

package/npm-shrinkwrap.json

@@ -0,0 +1,52 @@
+{
+  "lockfileVersion": 3,
+  "name": "@hitslop/slurp",
+  "packages": {
+    "": {
+      "bin": {
+        "slurp": "run-slurp.js"
+      },
+      "dependencies": {
+        "detect-libc": "^2.1.2"
+      },
+      "devDependencies": {
+        "prettier": "^3.9.10"
+      },
+      "engines": {
+        "node": ">=14.18",
+        "npm": ">=6"
+      },
+      "hasInstallScript": true,
+      "license": "MIT",
+      "name": "@hitslop/slurp",
+      "version": "0.1.1"
+    },
+    "node_modules/detect-libc": {
+      "engines": {
+        "node": ">=8"
+      },
+      "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==",
+      "license": "Apache-2.0",
+      "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz",
+      "version": "2.1.2"
+    },
+    "node_modules/prettier": {
+      "bin": {
+        "prettier": "bin/prettier.cjs"
+      },
+      "dev": true,
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/prettier/prettier?sponsor=1"
+      },
+      "integrity": "sha512-skGHTH1Yb9QvaTC4hWnRTzEYtCpApF0UMBPz+t/0ZPzP8ihefo/btKd+QA7pUE0fEwA1SbS/NmhyEcstdXOIdA==",
+      "license": "MIT",
+      "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.9.10.tgz",
+      "version": "3.9.10"
+    }
+  },
+  "requires": true,
+  "version": "0.1.1"
+}

package/package.json

@@ -1,6 +1,66 @@
 {
+  "artifactDownloadUrls": [
+    "https://github.com/hitSlop/slurp/releases/download/v0.1.1"
+  ],
+  "bin": {
+    "slurp": "run-slurp.js"
+  },
+  "dependencies": {
+    "detect-libc": "^2.1.2"
+  },
+  "devDependencies": {
+    "prettier": "^3.9.10"
+  },
+  "engines": {
+    "node": ">=14.18",
+    "npm": ">=6"
+  },
+  "glibcMinimum": {
+    "major": 2,
+    "series": 35
+  },
+  "license": "MIT",
   "name": "@hitslop/slurp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "preferUnplugged": true,
+  "repository": "https://github.com/hitSlop/slurp",
+  "scripts": {
+    "fmt": "prettier --write **/*.js",
+    "fmt:check": "prettier --check **/*.js",
+    "postinstall": "node ./install.js"
+  },
+  "supportedPlatforms": {
+    "aarch64-apple-darwin": {
+      "artifactName": "slurp-cli-aarch64-apple-darwin.tar.xz",
+      "bins": {
+        "slurp": "slurp"
+      },
+      "zipExt": ".tar.xz"
+    },
+    "aarch64-unknown-linux-gnu": {
+      "artifactName": "slurp-cli-aarch64-unknown-linux-gnu.tar.xz",
+      "bins": {
+        "slurp": "slurp"
+      },
+      "zipExt": ".tar.xz"
+    },
+    "x86_64-apple-darwin": {
+      "artifactName": "slurp-cli-x86_64-apple-darwin.tar.xz",
+      "bins": {
+        "slurp": "slurp"
+      },
+      "zipExt": ".tar.xz"
+    },
+    "x86_64-unknown-linux-gnu": {
+      "artifactName": "slurp-cli-x86_64-unknown-linux-gnu.tar.xz",
+      "bins": {
+        "slurp": "slurp"
+      },
+      "zipExt": ".tar.xz"
+    }
+  },
+  "version": "0.1.1",
+  "volta": {
+    "node": "18.14.1",
+    "npm": "9.5.0"
+  }
 }

package/run-slurp.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+
+const { run } = require("./binary");
+run("slurp");