@thehumanpatternlab/hpl 0.0.1-alpha.5

package/README.md

@@ -0,0 +1,42 @@
+# HPL CLI (Alpha) 🧭🦊
+
+<span>
+  <img src="https://img.shields.io/badge/AI--Forward%20CLI-black?style=flat-square" />
+  <img src="https://img.shields.io/badge/automation--safe%20by%20design-8b5cf6?style=flat-square" />
+</span>
+ 
+ [![Carmel Judgment Protocol 😼](https://github.com/AdaInTheLab/the-human-pattern-lab-cli/actions/workflows/carmel-judgment.yml/badge.svg)](https://github.com/AdaInTheLab/the-human-pattern-lab-cli/actions/workflows/carmel-judgment.yml)
+
+Contract-first CLI for The Human Pattern Lab.
+
+## Install (local dev)
+
+```bash
+npm install
+npm run dev -- --help
+```
+
+## Config
+
+- `HPL_API_BASE_URL` (default: `https://api.thehumanpatternlab.com`)
+
+## Commands (MVP)
+
+- `hpl version`
+- `hpl capabilities`
+- `hpl health`
+- `hpl notes list [--limit N]`
+- `hpl notes get <slug> [--raw]`
+
+## JSON contract
+
+Add `--json` to emit machine-readable JSON only on stdout.
+
+### Examples
+
+```bash
+hpl capabilities --json
+hpl health --json
+hpl notes list --json
+hpl notes get the-invitation --json
+```

package/dist/__tests__/config.test.js

@@ -0,0 +1,22 @@
+import { describe, expect, it, beforeEach } from 'vitest';
+import { SKULK_BASE_URL, SKULK_TOKEN } from '../lib/config.js';
+describe('env config', () => {
+    beforeEach(() => {
+        delete process.env.SKULK_BASE_URL;
+        delete process.env.SKULK_TOKEN;
+        delete process.env.HPL_API_BASE_URL;
+        delete process.env.HPL_TOKEN;
+    });
+    it('uses SKULK_TOKEN when set', () => {
+        process.env.SKULK_TOKEN = 'abc123';
+        expect(SKULK_TOKEN()).toBe('abc123');
+    });
+    it('uses SKULK_BASE_URL when set', () => {
+        process.env.SKULK_BASE_URL = 'https://example.com/api';
+        expect(SKULK_BASE_URL()).toBe('https://example.com/api');
+    });
+    it('override beats SKULK_BASE_URL', () => {
+        process.env.SKULK_BASE_URL = 'https://example.com/api';
+        expect(SKULK_BASE_URL('https://override.com/api')).toBe('https://override.com/api');
+    });
+});

package/dist/__tests__/outputContract.test.js

@@ -0,0 +1,58 @@
+import { describe, expect, it } from 'vitest';
+import { buildSyncReport } from '../cli/outputContract.js';
+describe('buildSyncReport (JSON contract)', () => {
+    it('counts synced in live mode (dryRun=false)', () => {
+        const report = buildSyncReport({
+            dryRun: false,
+            locale: 'en',
+            baseUrl: 'https://example.com/api',
+            results: [
+                { file: 'a.md', slug: 'a', status: 'ok', action: 'updated' },
+                { file: 'b.md', slug: 'b', status: 'ok', action: 'created' },
+            ],
+        });
+        expect(report.ok).toBe(true);
+        expect(report.summary).toEqual({
+            synced: 2,
+            dryRun: 0,
+            failed: 0,
+            total: 2,
+        });
+        expect(report.results.every((r) => r.written === true)).toBe(true);
+    });
+    it('counts dryRun in dry-run mode (dryRun=true)', () => {
+        const report = buildSyncReport({
+            dryRun: true,
+            results: [
+                { file: 'a.md', slug: 'a', status: 'dry-run' },
+                { file: 'b.md', slug: 'b', status: 'dry-run' },
+            ],
+        });
+        expect(report.ok).toBe(true);
+        expect(report.dryRun).toBe(true);
+        expect(report.summary).toEqual({
+            synced: 0,
+            dryRun: 2,
+            failed: 0,
+            total: 2,
+        });
+        expect(report.results.every((r) => r.written === false)).toBe(true);
+    });
+    it('normalizes legacy fail -> failed and keeps totals balanced', () => {
+        const report = buildSyncReport({
+            dryRun: false,
+            results: [
+                { file: 'a.md', slug: 'a', status: 'ok' },
+                { file: 'b.md', status: 'fail', error: 'boom' },
+            ],
+        });
+        expect(report.ok).toBe(false);
+        expect(report.summary).toEqual({
+            synced: 1,
+            dryRun: 0,
+            failed: 1,
+            total: 2,
+        });
+        expect(report.results[1].status).toBe('failed');
+    });
+});

package/dist/bin/hpl.js

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+/* ===========================================================
+   🌌 HUMAN PATTERN LAB — CLI ENTRYPOINT
+   -----------------------------------------------------------
+   Commands:
+     - version
+     - capabilities
+     - health
+     - notes list
+     - notes get <slug>
+   Contract: --json => JSON only on stdout
+   Notes:
+     - Avoid process.exit() inside command handlers (can trip libuv on Windows + tsx).
+   =========================================================== */
+import { Command } from "commander";
+import { writeHuman, writeJson } from "../src/io";
+import { EXIT } from "../src/contract/exitCodes";
+import { runVersion } from "../src/commands/version";
+import { runCapabilities } from "../src/commands/capabilities";
+import { runHealth } from "../src/commands/health";
+import { runNotesList } from "../src/commands/notes/list";
+import { runNotesGet } from "../src/commands/notes/get";
+import { renderTable } from "../src/render/table";
+import { formatTags, safeLine, stripHtml } from "../src/render/text";
+const program = new Command();
+program
+    .name("hpl")
+    .description("Human Pattern Lab CLI (alpha)")
+    .option("--json", "Emit contract JSON only on stdout")
+    .showHelpAfterError();
+function setExit(code) {
+    // Let Node exit naturally (important for Windows + tsx stability).
+    process.exitCode = code;
+}
+program
+    .command("version")
+    .description("Show CLI version (contract: show_version)")
+    .action(() => {
+    const opts = program.opts();
+    const envelope = runVersion("version");
+    if (opts.json)
+        writeJson(envelope);
+    else
+        writeHuman(`${envelope.data.name} ${envelope.data.version}`);
+    setExit(EXIT.OK);
+});
+program
+    .command("capabilities")
+    .description("Show CLI capabilities for agents (contract: show_capabilities)")
+    .action(() => {
+    const opts = program.opts();
+    const envelope = runCapabilities("capabilities");
+    if (opts.json)
+        writeJson(envelope);
+    else {
+        writeHuman(`intentTier: ${envelope.data.intentTier}`);
+        writeHuman(`schemaVersions: ${envelope.data.schemaVersions.join(", ")}`);
+        writeHuman(`supportedIntents:`);
+        for (const i of envelope.data.supportedIntents)
+            writeHuman(`  - ${i}`);
+    }
+    setExit(EXIT.OK);
+});
+program
+    .command("health")
+    .description("Check API health (contract: check_health)")
+    .action(async () => {
+    const opts = program.opts();
+    const result = await runHealth("health");
+    if (opts.json) {
+        writeJson(result.envelope);
+    }
+    else {
+        if (result.envelope.status === "ok") {
+            const d = result.envelope.data;
+            const db = d.dbPath ? ` (db: ${d.dbPath})` : "";
+            writeHuman(`ok${db}`);
+        }
+        else {
+            const e = result.envelope.error;
+            writeHuman(`error: ${e.code} — ${e.message}`);
+        }
+    }
+    setExit(result.exitCode);
+});
+const notes = program.command("notes").description("Lab Notes commands");
+notes
+    .command("list")
+    .description("List lab notes (contract: render_lab_note)")
+    .option("--limit <n>", "Limit number of rows (client-side)", (v) => parseInt(v, 10))
+    .action(async (cmdOpts) => {
+    const opts = program.opts();
+    const result = await runNotesList("notes list");
+    if (opts.json) {
+        writeJson(result.envelope);
+        setExit(result.exitCode);
+        return;
+    }
+    if (result.envelope.status !== "ok") {
+        const e = result.envelope.error;
+        writeHuman(`error: ${e.code} — ${e.message}`);
+        setExit(result.exitCode);
+        return;
+    }
+    const data = result.envelope.data;
+    const rows = data.notes ?? [];
+    const limit = Number.isFinite(cmdOpts.limit) && cmdOpts.limit > 0 ? cmdOpts.limit : rows.length;
+    const slice = rows.slice(0, limit);
+    const table = renderTable(slice, [
+        { header: "slug", width: 28, value: (n) => safeLine(String(n.slug ?? "")) },
+        { header: "title", width: 34, value: (n) => safeLine(String(n.title ?? "")) },
+        { header: "status", width: 10, value: (n) => safeLine(String(n.status ?? "-")) },
+        { header: "dept", width: 8, value: (n) => safeLine(String(n.department_id ?? "-")) },
+        { header: "tags", width: 22, value: (n) => formatTags(n.tags) },
+    ]);
+    writeHuman(table);
+    writeHuman(`\ncount: ${data.count}`);
+    setExit(result.exitCode);
+});
+notes
+    .command("get")
+    .description("Get a lab note by slug (contract: render_lab_note)")
+    .argument("<slug>", "Lab Note slug")
+    .option("--raw", "Print raw contentHtml (no HTML stripping)")
+    .action(async (slug, cmdOpts) => {
+    const opts = program.opts();
+    const result = await runNotesGet(slug, "notes get");
+    if (opts.json) {
+        writeJson(result.envelope);
+        setExit(result.exitCode);
+        return;
+    }
+    if (result.envelope.status !== "ok") {
+        const e = result.envelope.error;
+        writeHuman(`error: ${e.code} — ${e.message}`);
+        setExit(result.exitCode);
+        return;
+    }
+    const n = result.envelope.data;
+    writeHuman(`# ${n.title}`);
+    writeHuman(`slug: ${n.slug}`);
+    if (n.status)
+        writeHuman(`status: ${n.status}`);
+    if (n.type)
+        writeHuman(`type: ${n.type}`);
+    if (n.department_id)
+        writeHuman(`department_id: ${n.department_id}`);
+    if (n.published)
+        writeHuman(`published: ${n.published}`);
+    if (Array.isArray(n.tags))
+        writeHuman(`tags: ${formatTags(n.tags)}`);
+    writeHuman("");
+    const body = cmdOpts.raw ? String(n.contentHtml ?? "") : stripHtml(String(n.contentHtml ?? ""));
+    writeHuman(body || "(no content)");
+    setExit(result.exitCode);
+});
+// Let commander handle errors; set exit code without hard exit.
+program.parseAsync(process.argv).catch(() => setExit(EXIT.UNKNOWN));

package/dist/cli/output.js

@@ -0,0 +1,21 @@
+// Output is a contract. If it breaks, it should break loudly.
+function getRootCommand(cmd) {
+    let cur = cmd;
+    while (cur.parent)
+        cur = cur.parent;
+    return cur;
+}
+export function getOutputMode(cmd) {
+    const root = getRootCommand(cmd);
+    const opts = root.opts?.() ?? {};
+    return opts.json ? "json" : "human";
+}
+export function printJson(data) {
+    process.stdout.write(JSON.stringify(data, null, 2) + "\n");
+}
+export function printError(message) {
+    process.stderr.write(message + "\n");
+}
+export function printJsonError(message, extra) {
+    process.stderr.write(JSON.stringify({ ok: false, error: { message, extra } }, null, 2) + "\n");
+}

package/dist/cli/outputContract.js

@@ -0,0 +1,32 @@
+// src/cli/outputContract.ts
+import { buildSyncSummary } from "../sync/summary.js";
+function normalizeResult(r, dryRunFlag) {
+    const status = r.status === "fail" ? "failed" : "ok"; // "dry-run" is not a failure
+    // If any result claims "dry-run", treat it as dry-run even if flag is off (safety)
+    const effectiveDryRun = dryRunFlag || r.status === "dry-run";
+    return {
+        file: r.file,
+        slug: r.slug,
+        status,
+        action: r.action,
+        error: r.error,
+        // written only when not dry-run and ok
+        written: !effectiveDryRun && status === "ok",
+    };
+}
+export function buildSyncReport(args) {
+    const { results, dryRun, locale, baseUrl } = args;
+    const normalized = results.map((r) => normalizeResult(r, dryRun));
+    // IMPORTANT: pass the effective dryRun mode you used for written calc
+    // If you want to be ultra strict, you could compute effectiveDryRun = dryRun || any(r.status==="dry-run")
+    const effectiveDryRun = dryRun || results.some((r) => r.status === "dry-run");
+    const summary = buildSyncSummary(normalized, effectiveDryRun);
+    return {
+        ok: summary.failed === 0,
+        summary,
+        results: normalized,
+        dryRun: effectiveDryRun,
+        locale,
+        baseUrl,
+    };
+}

package/dist/commands/notesSync.js

@@ -0,0 +1,191 @@
+/* ===========================================================
+   🦊 THE HUMAN PATTERN LAB — SKULK CLI
+   -----------------------------------------------------------
+   Author: Ada (Founder, The Human Pattern Lab)
+   Assistant: Lyric (AI Lab Companion)
+   File: notesSync.ts
+   Module: Notes Command Suite
+   Lab Unit: SCMS — Systems & Code Management Suite
+   Status: Active
+   -----------------------------------------------------------
+   Purpose:
+     Implements `skulk notes sync` — syncing local markdown Lab Notes
+     to the Lab API with predictable behavior in both human and
+     automation contexts.
+   -----------------------------------------------------------
+   Key Behaviors:
+     - Human mode: readable progress + summaries
+     - JSON mode (--json): stdout emits ONLY valid JSON (contract)
+     - Errors: stderr only
+     - Exit codes: deterministic (non-zero only on failure)
+   -----------------------------------------------------------
+   Notes:
+     JSON output is a contract. If it breaks, it should break loudly.
+   =========================================================== */
+/**
+ * @file notesSync.ts
+ * @author Ada
+ * @assistant Lyric
+ * @lab-unit SCMS — Systems & Code Management Suite
+ * @since 2025-12-28
+ * @description Syncs markdown Lab Notes to the API via `skulk notes sync`.
+ *              Supports human + JSON output modes; JSON mode is stdout-pure.
+ */
+import { Command } from 'commander';
+import { SKULK_BASE_URL, SKULK_TOKEN } from '../lib/config.js';
+import { httpJson } from '../lib/http.js';
+import { listMarkdownFiles, readNote } from '../lib/notes.js';
+import { getOutputMode, printJson } from '../cli/output.js';
+import { buildSyncReport } from '../cli/outputContract.js';
+import fs from 'node:fs';
+async function upsertNote(baseUrl, token, note, locale) {
+    const payload = {
+        slug: note.slug,
+        title: note.attributes.title,
+        markdown: note.markdown,
+        locale,
+    };
+    if (!payload.slug || !payload.title || !payload.markdown) {
+        throw new Error(`Invalid note payload: slug/title/markdown missing for ${payload.slug ?? 'unknown'}`);
+    }
+    return httpJson({ baseUrl, token }, 'POST', '/lab-notes/upsert', payload);
+}
+export function notesSyncCommand() {
+    const notes = new Command('notes').description('Lab Notes commands');
+    notes
+        .command('sync')
+        .description('Sync local markdown notes to the API')
+        .option('--dir <path>', 'Directory containing markdown notes', './src/labnotes/en')
+        //.option("--dir <path>", "Directory containing markdown notes", "./labnotes/en")
+        .option('--locale <code>', 'Locale code', 'en')
+        .option('--base-url <url>', 'Override API base URL (ex: https://thehumanpatternlab.com/api)')
+        .option('--dry-run', 'Print what would be sent, but do not call the API', false)
+        .option('--only <slug>', 'Sync only a single note by slug')
+        .option('--limit <n>', 'Sync only the first N notes', (v) => parseInt(v, 10))
+        .action(async (opts, cmd) => {
+        const mode = getOutputMode(cmd); // "json" | "human"
+        const jsonError = (message, extra) => {
+            if (mode === 'json') {
+                process.stderr.write(JSON.stringify({ ok: false, error: { message, extra } }, null, 2) +
+                    '\n');
+            }
+            else {
+                console.error(message);
+                if (extra)
+                    console.error(extra);
+            }
+            process.exitCode = 1;
+        };
+        if (!fs.existsSync(opts.dir)) {
+            jsonError(`Notes directory not found: ${opts.dir}`, {
+                hint: `Try: skulk notes sync --dir "..\\\\the-human-pattern-lab\\\\src\\\\labnotes\\\\en"`,
+            });
+            return;
+        }
+        const baseUrl = SKULK_BASE_URL(opts.baseUrl);
+        const token = SKULK_TOKEN();
+        const files = listMarkdownFiles(opts.dir);
+        let selectedFiles = files;
+        if (opts.only) {
+            selectedFiles = files.filter((f) => f.toLowerCase().includes(opts.only.toLowerCase()));
+        }
+        if (opts.limit && Number.isFinite(opts.limit)) {
+            selectedFiles = selectedFiles.slice(0, opts.limit);
+        }
+        if (selectedFiles.length === 0) {
+            if (mode === 'json') {
+                printJson({
+                    ok: true,
+                    action: 'noop',
+                    message: 'No matching notes found.',
+                    matched: 0,
+                });
+            }
+            else {
+                console.log('No matching notes found.');
+            }
+            process.exitCode = 0;
+            return;
+        }
+        // Human-mode header chatter
+        if (mode === 'human') {
+            console.log(`Skulk syncing ${selectedFiles.length} note(s) from ${opts.dir}`);
+            console.log(`API: ${baseUrl}`);
+            console.log(`Locale: ${opts.locale}`);
+            console.log(opts.dryRun ? 'Mode: DRY RUN (no writes)' : 'Mode: LIVE (writing)');
+        }
+        let ok = 0;
+        let fail = 0;
+        const results = [];
+        for (const file of selectedFiles) {
+            try {
+                const note = readNote(file, opts.locale);
+                if (opts.dryRun) {
+                    ok++;
+                    results.push({
+                        file,
+                        slug: note.slug,
+                        status: 'dry-run',
+                    });
+                    if (mode === 'human') {
+                        console.log(`\n---\n${note.slug}\n${file}\nfrontmatter keys: ${Object.keys(note.attributes).join(', ')}`);
+                    }
+                    continue;
+                }
+                const res = await upsertNote(baseUrl, token, note, opts.locale);
+                ok++;
+                results.push({
+                    file,
+                    slug: note.slug,
+                    status: 'ok',
+                    action: res.action,
+                });
+                if (mode === 'human') {
+                    console.log(`✅ ${note.slug} (${res.action ?? 'ok'})`);
+                }
+            }
+            catch (e) {
+                fail++;
+                const msg = String(e);
+                results.push({
+                    file,
+                    status: 'fail',
+                    error: msg,
+                });
+                if (mode === 'human') {
+                    console.error(`❌ ${file}`);
+                    console.error(msg);
+                }
+            }
+        }
+        if (mode === 'json') {
+            const report = buildSyncReport({
+                results,
+                dryRun: Boolean(opts.dryRun),
+                locale: opts.locale,
+                baseUrl,
+            });
+            printJson(report);
+            if (!report.ok)
+                process.exitCode = 1;
+        }
+        else {
+            const report = buildSyncReport({
+                results,
+                dryRun: Boolean(opts.dryRun),
+                locale: opts.locale,
+                baseUrl,
+            });
+            const { synced, dryRun, failed } = report.summary;
+            if (report.dryRun) {
+                console.log(`\nDone. ${dryRun} note(s) would be synced (dry-run). Failures: ${failed}`);
+            }
+            else {
+                console.log(`\nDone. ${synced} note(s) synced successfully. Failures: ${failed}`);
+            }
+            if (!report.ok)
+                process.exitCode = 1;
+        }
+    });
+    return notes;
+}

package/dist/commands/publish.js

@@ -0,0 +1,36 @@
+import { Command } from 'commander';
+import { loadMarkdown } from '../utils/loadMarkdown.js';
+import { LabClient } from '../sdk/LabClient.js';
+import path from 'path';
+const publish = new Command('publish')
+    .description('Publish a Lab Note from a Markdown file')
+    .argument('<file>', 'Markdown file to publish')
+    .option('-u, --url <url>', 'API base URL', 'https://thehumanpatternlab.com/api')
+    .option('-t, --token <token>', 'Auth token (if required)')
+    .action(async (file, options) => {
+    try {
+        const filePath = path.resolve(process.cwd(), file);
+        const { content, metadata } = loadMarkdown(filePath);
+        if (!metadata.title || !metadata.slug) {
+            console.error('Error: frontmatter must include at least: title, slug');
+            process.exit(1);
+        }
+        const client = new LabClient(options.url, options.token);
+        const payload = {
+            title: metadata.title,
+            slug: metadata.slug,
+            content,
+            tags: metadata.tags || [],
+            artifacts: metadata.artifacts || []
+        };
+        const result = await client.createOrUpdateNote(payload);
+        console.log(`✔ Published: ${metadata.title}`);
+        console.log(`→ slug: ${metadata.slug}`);
+        console.log(result.message);
+    }
+    catch (err) {
+        console.error('Publish failed:', err.message);
+        process.exit(1);
+    }
+});
+export default publish;

package/dist/index.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+/* ===========================================================
+   🦊 THE HUMAN PATTERN LAB — SKULK CLI
+   -----------------------------------------------------------
+   File: notesSync.ts
+   Role: Command Implementation
+   Author: Ada (The Human Pattern Lab)
+   Assistant: Lyric
+   Status: Active
+   Description:
+     Implements the `skulk notes sync` command.
+     Handles human-readable and machine-readable output modes
+     with enforced JSON purity for automation safety.
+   -----------------------------------------------------------
+   Design Notes:
+     - Output format is a contract
+     - JSON mode emits stdout-only structured data
+     - Errors are written to stderr
+     - Exit codes are deterministic
+   =========================================================== */
+import { Command } from "commander";
+import { notesSyncCommand } from "./commands/notesSync.js";
+const program = new Command();
+program
+    .name("skulk")
+    .description("Skulk CLI for The Human Pattern Lab")
+    .version("0.1.0")
+    .option("--json", "Output machine-readable JSON")
+    .configureHelp({ helpWidth: 100 });
+const argv = process.argv.slice(2);
+if (argv.length === 0) {
+    program.outputHelp();
+    process.exit(0);
+}
+program.addCommand(notesSyncCommand());
+program.parse(process.argv);

package/dist/lab.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import publishCommand from './commands/publish.js';
+const program = new Command();
+program
+    .name('lab')
+    .description('CLI tools for The Human Pattern Lab')
+    .version('0.1.0');
+program.addCommand(publishCommand);
+program.parse();

package/dist/lib/config.js

@@ -0,0 +1,52 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { z } from 'zod';
+/**
+ * Skulk CLI configuration schema
+ * Stored in ~/.humanpatternlab/skulk.json
+ */
+const ConfigSchema = z.object({
+    apiBaseUrl: z.string().url().default('https://thehumanpatternlab.com/api'),
+    token: z.string().optional(),
+});
+function getConfigPath() {
+    return path.join(os.homedir(), '.humanpatternlab', 'skulk.json');
+}
+export function loadConfig() {
+    const p = getConfigPath();
+    if (!fs.existsSync(p)) {
+        return ConfigSchema.parse({});
+    }
+    const raw = fs.readFileSync(p, 'utf-8');
+    return ConfigSchema.parse(JSON.parse(raw));
+}
+export function saveConfig(partial) {
+    const p = getConfigPath();
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    const current = loadConfig();
+    const next = ConfigSchema.parse({ ...current, ...partial });
+    fs.writeFileSync(p, JSON.stringify(next, null, 2), 'utf-8');
+}
+export function SKULK_BASE_URL(override) {
+    if (override?.trim())
+        return override.trim();
+    // NEW official env var
+    const env = process.env.SKULK_BASE_URL?.trim();
+    if (env)
+        return env;
+    // optional legacy support (remove later if you want)
+    const legacy = process.env.HPL_API_BASE_URL?.trim();
+    if (legacy)
+        return legacy;
+    return loadConfig().apiBaseUrl;
+}
+export function SKULK_TOKEN() {
+    const env = process.env.SKULK_TOKEN?.trim();
+    if (env)
+        return env;
+    const legacy = process.env.HPL_TOKEN?.trim();
+    if (legacy)
+        return legacy;
+    return loadConfig().token;
+}

package/dist/lib/http.js

@@ -0,0 +1,18 @@
+export async function httpJson(opts, method, path, body) {
+    const url = `${opts.baseUrl.replace(/\/$/, "")}/${path.replace(/^\//, "")}`;
+    const headers = {
+        "Content-Type": "application/json"
+    };
+    if (opts.token)
+        headers["Authorization"] = `Bearer ${opts.token}`;
+    const res = await fetch(url, {
+        method,
+        headers,
+        body: body ? JSON.stringify(body) : undefined
+    });
+    const text = await res.text();
+    if (!res.ok) {
+        throw new Error(`HTTP ${res.status} ${res.statusText} @ ${url}\n${text}`);
+    }
+    return text ? JSON.parse(text) : {};
+}