@sylphx/lookout 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SylphxAI
+
+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

@@ -0,0 +1,127 @@
+# Lookout
+
+### The web from your machine. 
+
+**Lookout** is a local-first **web instrument** for agents and apps: **search, fetch, extract, cache** with citeable excerpts — **no required API key**, **tiny default install**, same API on **SDK · CLI · MCP**.
+
+Primary competitive anchor: [wigolo](https://github.com/KnockOutEZ/wigolo) (learn multi-surface + honesty; **do not** require multi-GB browser/model warmup).
+
+
+
+## Product docs
+
+| Doc | Purpose |
+| --- | --- |
+| [docs/POSITIONING.md](docs/POSITIONING.md) | Strategic positioning |
+| [docs/COMPETITIVE.md](docs/COMPETITIVE.md) | Peer anchors and wedge |
+| [docs/EVIDENCE_CONTRACT.md](docs/EVIDENCE_CONTRACT.md) | Evidence = result contract |
+| [docs/TOOL_SURFACE.md](docs/TOOL_SURFACE.md) | Few clear tools policy |
+| [docs/PRODUCT_INDEPENDENCE.md](docs/PRODUCT_INDEPENDENCE.md) | This repo is SSOT |
+| [docs/IPPB.md](docs/IPPB.md) | Independent public product bar |
+| [docs/PUBLISH.md](docs/PUBLISH.md) | npm/git publish status |
+
+## Agent skill surface
+
+See [`skills/lookout/SKILL.md`](./skills/lookout/SKILL.md).
+
+## Why Lookout (vs multi-GB “local web” stacks)
+
+| Typical agent web path | Lookout |
+| --- | --- |
+| Paid search API keys | Default **public adapters**, $0/query |
+| Multi-GB browser + model warmup | **Tiny default** — HTML search/fetch/extract |
+| Opaque snippets | **Cite spans** + extract route + warnings |
+| One mega-tool | **Clear tools**: search · fetch · extract · cache (+ advanced crawl) |
+
+Primary competitive anchor: [wigolo](https://github.com/KnockOutEZ/wigolo) — learn multi-surface honesty; **do not** require heavy browser/model installs on the default path.
+
+Evidence is a **result contract** (spans, routes, warnings) — not a tool named `evidence_first`.
+
+## Install (30 seconds)
+
+```bash
+npm install -g @sylphx/lookout
+# brand bin
+lookout doctor
+lookout search "model context protocol"
+```
+
+Claude Code:
+
+```bash
+claude mcp add lookout -- npx @sylphx/lookout
+```
+
+## Install (dev)
+
+```bash
+git clone https://github.com/SylphxAI/lookout.git
+cd lookout
+bun install
+./bin/lookout tools
+./bin/lookout extract   # via engine with -- see CLI
+```
+
+```bash
+# CLI
+./bin/lookout doctor
+./bin/lookout tools
+./bin/lookout search "local-first agents"
+./bin/lookout fetch https://example.com
+./bin/lookout extract https://example.com
+./bin/lookout cache stats
+./bin/lookout crawl https://example.com --depth 0 --pages 2
+
+# MCP (stdio)
+bun src/mcp.ts
+# or: ./bin/lookout mcp
+```
+
+## SDK
+
+```ts
+import { Lookout } from '@sylphx/lookout'
+
+const lookout = Lookout.create()
+const search = await lookout.search('model context protocol')
+const page = await lookout.fetch('https://example.com')
+const extracted = await lookout.extract({ url: 'https://example.com' })
+```
+
+## Tools (clear, not merged)
+
+| Tool | Job |
+| --- | --- |
+| `web_search` | Public adapters (DuckDuckGo HTML + Wikipedia + npm registry + HN Algolia), rank fusion, query-term boost, host filters |
+| `web_fetch` | SSRF-safe HTTP(S) fetch, redirects, size limits, cite spans |
+| `web_extract` | Title, description, JSON-LD, tables, spans from HTML/URL |
+| `web_cache` | Local disk cache query/stats/clear/prune (`LOOKOUT_CACHE_DIR`, optional max age) |
+| `web_crawl` *(advanced)* | Same-origin, depth-limited crawl (not a full-site crawler) |
+| `web_research` *(advanced)* | Search then fetch/extract top pages with citeable excerpts |
+
+## Environment
+
+| Var | Purpose |
+| --- | --- |
+| `LOOKOUT_CACHE_DIR` | Cache directory (default `~/.cache/lookout`) |
+| `LOOKOUT_CACHE_MAX_AGE_MS` | Optional max age for search/fetch cache hits |
+| `LOOKOUT_LIVE=1` | Enable optional live network tests |
+| `LOOKOUT_USER_AGENT` | Optional User-Agent override for fetch |
+| `LOOKOUT_FETCH_TIMEOUT_MS` | Optional fetch timeout (ms) |
+| `LOOKOUT_FETCH_MAX_BYTES` | Optional max response body bytes |
+
+## Safety
+
+- Private IPv4/IPv6, localhost, link-local metadata hosts **denied**
+- Only `http`/`https`
+- Redirect cap + response size cap
+
+## Family
+
+Citra · Iris · Cue · Prism · Spine · **Lookout**
+
+Company portfolio knowledge (docs only — not a product monorepo):
+This repository is product SSOT. Sibling agent tools are separate repositories and are not vendored here.
+## License
+
+MIT

package/bin/lookout

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+set -euo pipefail
+ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+if command -v bun >/dev/null 2>&1; then
+  exec bun "$ROOT/src/cli.ts" "$@"
+fi
+if command -v node >/dev/null 2>&1; then
+  exec node --experimental-strip-types "$ROOT/src/cli.ts" "$@"
+fi
+echo "lookout requires bun or node>=22" >&2
+exit 1

package/docs/BRAND_PUBLISH.md

@@ -0,0 +1,36 @@
+# Lookout — brand npm publish readiness
+
+**Publish authority:** this repository only (not a multi-product monorepo).
+
+| Field | Value |
+| --- | --- |
+| Brand | **Lookout** |
+| Transitional npm id | `@sylphx/lookout` |
+| Target brand npm id | `@sylphx/lookout` |
+| Brand bin | `lookout` |
+| Marketplace title | Lookout (`server.json`) |
+
+## Current policy
+
+1. Ship/publish `@sylphx/lookout` from this repo (existing CI/release train).
+2. Optional second publish of `@sylphx/lookout` **from this same repo** (same artifacts, renamed package.json at pack time).
+3. Never publish brand packages from any other repository.
+
+## Dry-run (no npm auth required)
+
+```bash
+# Transitional package as configured
+npm pack --dry-run
+# Or product-specific brand pack plan script when present:
+# bun scripts/brand-pack-plan.ts
+```
+
+## Blockers for live brand publish
+
+- npm automation token / 2FA for `@sylphx` scope
+- Changeset/version alignment with transitional package
+- Registry readback proof after publish
+
+## Authority
+
+Publish and brand packages only from **this repository**. No central Instruments monorepo.

package/docs/COMPETITIVE.md

@@ -0,0 +1,27 @@
+# Lookout — competitive positioning
+
+## Job
+
+Local-first web search/fetch/extract/cache
+
+## Wedge
+
+Tiny default: public search adapters + fetch/extract/cache with citeable excerpts; no required API key and no multi-GB warmup.
+
+## Local-first
+
+Default public adapters; no required API key; SSRF-safe fetch.
+
+## Peer anchors (learn; do not clone)
+
+| Peer | Gap we exploit |
+| --- | --- |
+| KnockOutEZ/wigolo | Local web stack for agents; often heavier browser/model warmup paths |
+| Paid search API MCPs | API keys, quota, non-local |
+| Raw fetch without extract/cache | No citeable excerpts or repeatable cache |
+
+## Non-goals
+
+- Becoming a cloud SaaS wrapper as the default path
+- Multi-product monorepo for star aggregation
+- Generative summaries as the sole evidence authority

package/docs/EVIDENCE_CONTRACT.md

@@ -0,0 +1,21 @@
+# Evidence contract — product-specific
+
+**Evidence First** means results carry citeable structure. There is **no** MCP tool named `evidence_first`.
+
+## Locators and honesty for this product
+
+- result URL + rank
+- excerpt spans
+- fetch route + cache hit/miss
+- adapter warnings (no paid key required on default path)
+
+## Always include when applicable
+
+- **route**: which local engine path produced the payload
+- **warnings**: missing binaries, partial parse, network/adapter limits
+- raw facts over generative rewrite as authority
+
+## Non-goals
+
+- Requiring a cloud model to “confirm” local facts
+- Over-marketing Evidence First without locators on the wire

package/docs/IPPB.md

@@ -0,0 +1,16 @@
+# Independent Public Product Bar (IPPB)
+
+This repository is complete for the company programme only when all are true:
+
+1. **Independence** — product SSOT here; no central Instruments monorepo/hub authority
+2. **Surfaces** — SDK + CLI + MCP documented and present
+3. **Tools** — few clear tools; schema not agent-confusing
+4. **Evidence** — result contract with locators/routes/warnings (not `evidence_first` tool)
+5. **Local-first** — default path needs no cloud API key
+6. **Validation** — release-gate or declared test path green on tip
+7. **Public marketing** — README explains why-us, 30s install, competitive wedge
+8. **Competitive** — `docs/COMPETITIVE.md` anchors peers honestly
+9. **Packaging** — npm package published **or** explicit external publish blocker + git install path
+10. **Clean** — no archived family package deps; no misleading family SSOT docs
+
+Stars (e.g. 10k) are growth outcomes, not substitutes for the bar above.

package/docs/POSITIONING.md

@@ -0,0 +1,42 @@
+# Lookout — positioning
+
+## One-liner
+
+**Lookout**: Local-first web search/fetch/extract/cache — local-first, fast, light, powerful.
+
+## Why agents use this
+
+Tiny default: public search adapters + fetch/extract/cache with citeable excerpts; no required API key and no multi-GB warmup.
+
+## Surfaces
+
+| Surface | Role |
+| --- | --- |
+| MCP | Agent tools over stdio |
+| CLI | Human/scriptable brand bin |
+| SDK | Programmatic library for apps and internal dogfood |
+
+## Primary tools
+
+- `web_search`
+- `web_fetch`
+- `web_extract`
+- `web_cache`
+- `web_crawl (advanced)`
+- `web_research (advanced)`
+
+## Evidence
+
+See [EVIDENCE_CONTRACT.md](./EVIDENCE_CONTRACT.md).
+
+## Independence
+
+See [PRODUCT_INDEPENDENCE.md](./PRODUCT_INDEPENDENCE.md).
+
+## Competitive
+
+See [COMPETITIVE.md](./COMPETITIVE.md).
+
+## Completion bar
+
+See [IPPB.md](./IPPB.md).

package/docs/PRODUCT_INDEPENDENCE.md

@@ -0,0 +1,13 @@
+# Product independence
+
+**Lookout** (`lookout`) is an **independent product**.
+
+This repository is the only source of truth for marketplace listing, release train,
+package/CLI/MCP/SDK contracts, docs, tests, and stars.
+
+- No multi-product monorepo shipping
+- No `SylphxAI/instruments` authority (retired)
+- No archived `@sylphx/reader-evidence` control package
+- Composition with siblings is via **public contracts** only
+
+Company private thin map (internal): `SylphxAI/portfolio`.

package/docs/PUBLISH.md

@@ -0,0 +1,23 @@
+# Publish status — Lookout
+
+| Field | Value |
+| --- | --- |
+| Package | `@sylphx/lookout` |
+| Repo version | `0.1.0` |
+| Registry state | **not on npm (404)** |
+| npm auth in this environment | `ENEEDAUTH` (external credential blocker) |
+
+## In-repo readiness
+
+- CI/tests/release-gate green on tip
+- `npm pack --dry-run` produces a valid TS package (~23KB)
+- Live `npm publish` blocked only by missing `@sylphx` registry auth in this environment
+
+## Install until publish lands
+
+```bash
+git clone https://github.com/SylphxAI/lookout.git
+cd lookout
+bun install
+./bin/lookout doctor
+```

package/docs/TOOL_SURFACE.md

@@ -0,0 +1,19 @@
+# Tool surface — this product
+
+Policy: **few, powerful, obvious** tools. Prefer the primary read tool first.
+
+| Tool | Role |
+| --- | --- |
+| `web_search` | Local-first public search adapters |
+| `web_fetch` | SSRF-aware fetch |
+| `web_extract` | Main-content extract with citeable spans |
+| `web_cache` | Cache stats/control |
+| `web_crawl` | Advanced crawl |
+| `web_research` | Advanced multi-step research |
+
+## Rules
+
+1. Do not add near-duplicate tools that only differ by vanity naming.
+2. Advanced tools must be labeled advanced in README/skill.
+3. Schema fields should be agent-obvious; fail closed on unsafe input.
+4. Composition with sibling products is via public contracts, not monorepo imports.

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@sylphx/lookout",
+  "version": "0.1.0",
+  "private": false,
+  "description": "Lookout \u2014 local-first web instrument for agents. Search, fetch, extract, cache with citeable excerpts. No required API key. SDK \u00b7 CLI \u00b7 MCP.",
+  "type": "module",
+  "license": "MIT",
+  "bin": {
+    "lookout": "./bin/lookout"
+  },
+  "exports": {
+    ".": "./src/sdk.ts",
+    "./sdk": "./src/sdk.ts",
+    "./engine": "./src/engine.ts"
+  },
+  "files": [
+    "LICENSE",
+    "README.md",
+    "bin",
+    "docs",
+    "server.json",
+    "src"
+  ],
+  "scripts": {
+    "test": "bun test",
+    "start": "bun src/cli.ts",
+    "mcp": "bun src/mcp.ts",
+    "doctor": "./bin/lookout doctor",
+    "benchmark:release-gate": "bun scripts/release-gate.ts",
+    "validate": "bun test && bun scripts/release-gate.ts",
+    "benchmark:public-proof": "bun scripts/public-proof.ts",
+    "brand:pack-plan": "bun scripts/brand-pack-plan.ts"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "zod": "^3.25.76"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SylphxAI/lookout.git"
+  },
+  "homepage": "https://github.com/SylphxAI/lookout#readme",
+  "mcpName": "io.github.SylphxAI/lookout",
+  "keywords": [
+    "mcp",
+    "local-first",
+    "web-search",
+    "lookout",
+    "sylphx",
+    "agent"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/server.json

@@ -0,0 +1,22 @@
+{
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
+  "name": "io.github.SylphxAI/lookout",
+  "title": "Lookout",
+  "description": "Local-first web instrument for agents: search, fetch, extract, cache. No required API key. SDK · CLI · MCP.",
+  "repository": {
+    "url": "https://github.com/SylphxAI/lookout",
+    "source": "github"
+  },
+  "version": "0.1.0",
+  "websiteUrl": "https://github.com/SylphxAI/lookout#readme",
+  "packages": [
+    {
+      "registryType": "npm",
+      "identifier": "@sylphx/lookout",
+      "version": "0.1.0",
+      "transport": {
+        "type": "stdio"
+      }
+    }
+  ]
+}

package/src/cache.ts

@@ -0,0 +1,129 @@
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+export type CacheRecord = {
+  key: string;
+  kind: string;
+  createdAt: string;
+  url?: string;
+  query?: string;
+  contentType?: string;
+  body: string;
+  meta?: Record<string, unknown>;
+};
+
+export function defaultCacheDir(): string {
+  if (process.env.LOOKOUT_CACHE_DIR?.trim()) return process.env.LOOKOUT_CACHE_DIR.trim();
+  const xdg = process.env.XDG_CACHE_HOME?.trim();
+  if (xdg) return join(xdg, 'lookout');
+  return join(homedir(), '.cache', 'lookout');
+}
+
+export class LookoutCache {
+  readonly dir: string;
+
+  constructor(dir = defaultCacheDir()) {
+    this.dir = dir;
+    mkdirSync(this.dir, { recursive: true });
+  }
+
+  private pathFor(key: string): string {
+    const safe = createHash('sha256').update(key).digest('hex');
+    return join(this.dir, `${safe}.json`);
+  }
+
+  put(record: Omit<CacheRecord, 'createdAt'> & { createdAt?: string }): CacheRecord {
+    const full: CacheRecord = {
+      ...record,
+      createdAt: record.createdAt ?? new Date().toISOString(),
+    };
+    writeFileSync(this.pathFor(full.key), JSON.stringify(full), 'utf8');
+    return full;
+  }
+
+  get(key: string, options: { maxAgeMs?: number } = {}): CacheRecord | null {
+    const p = this.pathFor(key);
+    if (!existsSync(p)) return null;
+    try {
+      const rec = JSON.parse(readFileSync(p, 'utf8')) as CacheRecord;
+      if (typeof options.maxAgeMs === 'number' && options.maxAgeMs >= 0) {
+        const created = Date.parse(rec.createdAt);
+        if (!Number.isFinite(created) || Date.now() - created > options.maxAgeMs) {
+          return null;
+        }
+      }
+      return rec;
+    } catch {
+      return null;
+    }
+  }
+
+  query(q: string, limit = 20): CacheRecord[] {
+    const needle = q.toLowerCase();
+    const out: CacheRecord[] = [];
+    for (const name of readdirSync(this.dir)) {
+      if (!name.endsWith('.json')) continue;
+      try {
+        const rec = JSON.parse(readFileSync(join(this.dir, name), 'utf8')) as CacheRecord;
+        const hay = `${rec.url ?? ''} ${rec.query ?? ''} ${rec.body.slice(0, 2000)}`.toLowerCase();
+        if (!needle || hay.includes(needle)) out.push(rec);
+      } catch {
+        // skip corrupt
+      }
+    }
+    out.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+    return out.slice(0, limit);
+  }
+
+  stats(): { entries: number; dir: string; bytes: number } {
+    let entries = 0;
+    let bytes = 0;
+    for (const name of readdirSync(this.dir)) {
+      if (!name.endsWith('.json')) continue;
+      entries += 1;
+      try {
+        bytes += statSync(join(this.dir, name)).size;
+      } catch {
+        // ignore
+      }
+    }
+    return { entries, dir: this.dir, bytes };
+  }
+
+  clear(): { removed: number } {
+    let removed = 0;
+    for (const name of readdirSync(this.dir)) {
+      if (!name.endsWith('.json')) continue;
+      rmSync(join(this.dir, name), { force: true });
+      removed += 1;
+    }
+    return { removed };
+  }
+
+  /** Remove entries older than maxAgeMs. */
+  pruneExpired(maxAgeMs: number): { removed: number } {
+    let removed = 0;
+    const now = Date.now();
+    for (const name of readdirSync(this.dir)) {
+      if (!name.endsWith('.json')) continue;
+      try {
+        const rec = JSON.parse(readFileSync(join(this.dir, name), 'utf8')) as CacheRecord;
+        const created = Date.parse(rec.createdAt);
+        if (!Number.isFinite(created) || now - created > maxAgeMs) {
+          rmSync(join(this.dir, name), { force: true });
+          removed += 1;
+        }
+      } catch {
+        rmSync(join(this.dir, name), { force: true });
+        removed += 1;
+      }
+    }
+    return { removed };
+  }
+}
+
+export function cacheKey(parts: string[]): string {
+  return parts.join('|');
+}

package/src/cli.ts

@@ -0,0 +1,106 @@
+#!/usr/bin/env bun
+import { LookoutEngine, CORE_TOOLS, ADVANCED_TOOLS } from './engine.ts';
+
+function usage(): never {
+  console.log(`Lookout — local-first web instrument (Sylphx)
+
+Usage:
+  lookout search <query...>
+  lookout fetch <url>
+  lookout extract <url>
+  lookout cache [query]
+  lookout cache stats
+  lookout cache clear
+  lookout cache prune [maxAgeMs]
+  lookout crawl <url> [--depth N] [--pages N]
+  lookout research <query...> [--pages N]
+  lookout mcp
+  lookout tools
+  lookout doctor
+  lookout help
+
+Env:
+  LOOKOUT_CACHE_DIR          override cache directory (default: ~/.cache/lookout)
+  LOOKOUT_CACHE_MAX_AGE_MS   optional max age for cache hits (milliseconds)
+`);
+  process.exit(0);
+}
+
+async function main() {
+  const [cmd, ...rest] = process.argv.slice(2);
+  if (!cmd || cmd === 'help' || cmd === '-h' || cmd === '--help') usage();
+
+  if (cmd === 'tools') {
+    console.log(JSON.stringify({ core: CORE_TOOLS, advanced: ADVANCED_TOOLS }, null, 2));
+    return;
+  }
+
+  if (cmd === 'doctor') {
+    const { runDoctor, formatDoctorReport } = await import('./doctor.ts');
+    const report = runDoctor();
+    console.log(formatDoctorReport(report));
+    process.exit(report.ok ? 0 : 1);
+  }
+
+  if (cmd === 'mcp') {
+    await import('./mcp.ts');
+    return;
+  }
+
+  const engine = new LookoutEngine();
+  let envelope;
+  switch (cmd) {
+    case 'search':
+      envelope = await engine.handle('web_search', { query: rest.join(' ') });
+      break;
+    case 'fetch':
+      envelope = await engine.handle('web_fetch', { url: rest[0] });
+      break;
+    case 'extract':
+      envelope = await engine.handle('web_extract', { url: rest[0] });
+      break;
+    case 'cache':
+      if (rest[0] === 'stats') envelope = await engine.handle('web_cache', { op: 'stats' });
+      else if (rest[0] === 'clear') envelope = await engine.handle('web_cache', { op: 'clear' });
+      else if (rest[0] === 'prune') {
+        const maxAgeMs = rest[1] ? Number(rest[1]) : undefined;
+        envelope = await engine.handle('web_cache', { op: 'prune', maxAgeMs });
+      } else envelope = await engine.handle('web_cache', { op: 'query', query: rest.join(' ') });
+      break;
+    case 'crawl': {
+      let depth: number | undefined;
+      let pages: number | undefined;
+      const args = [...rest];
+      const url = args.shift();
+      while (args.length) {
+        const a = args.shift()!;
+        if (a === '--depth') depth = Number(args.shift());
+        else if (a === '--pages') pages = Number(args.shift());
+      }
+      envelope = await engine.handle('web_crawl', { url, maxDepth: depth, maxPages: pages });
+      break;
+    }
+    case 'research': {
+      let pages: number | undefined;
+      const args = [...rest];
+      const qparts: string[] = [];
+      while (args.length) {
+        const a = args.shift()!;
+        if (a === '--pages') pages = Number(args.shift());
+        else qparts.push(a);
+      }
+      envelope = await engine.handle('web_research', { query: qparts.join(' '), maxPages: pages });
+      break;
+    }
+    default:
+      console.error(`Unknown command: ${cmd}`);
+      usage();
+  }
+  console.log(JSON.stringify(envelope, null, 2));
+  process.exit(envelope?.status === 'ok' ? 0 : 1);
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});