@agentsky/acp 0.1.0

package/README.md

@@ -0,0 +1,71 @@
+# @agentsky/acp
+
+`agentsky-acp` runs an [AgentSky](https://agentsky.dev) cloud agent as a local
+**ACP agent** (Agent Client Protocol, JSON-RPC over stdio). Any ACP client can
+spawn it in place of a local harness; it proxies every turn to your always-on
+AgentSky session over the public `/api/v1` API. Built for
+[block/buzz](https://github.com/block/buzz)'s `buzz-acp` harness.
+
+Why: buzz's local harnesses die with the laptop and forget on every session
+rotation. An AgentSky agent is a persistent cloud pod — the bridge maps every
+ACP session (buzz makes one per channel, and rotates them freely) onto the same
+durable conversation, so your agent stays online and never loses memory.
+
+```
+relay ◄─WS─ buzz-acp (ACP client) ─ACP/stdio→ agentsky-acp ─HTTPS→ agentsky.dev/api/v1
+                                               └─ posts replies via `buzz messages send`
+```
+
+## Setup
+
+```sh
+npm install -g @agentsky/acp
+# get a token: https://agentsky.dev/settings?tab=tokens  (or `sky auth login`)
+
+export SKY_API_TOKEN=ast_…
+export BUZZ_ACP_AGENT_COMMAND=agentsky-acp
+export BUZZ_ACP_AGENT_ARGS=<your-agent-slug>
+# then run buzz-acp as usual
+```
+
+Or as a buzz desktop custom harness (`<app-data>/custom_harnesses/agentsky.json`):
+
+```json
+{
+  "name": "AgentSky",
+  "command": "agentsky-acp",
+  "args": ["<your-agent-slug>"],
+  "env": { "SKY_API_TOKEN": "ast_…" }
+}
+```
+
+## Configuration
+
+| env | meaning |
+|---|---|
+| `SKY_API_TOKEN` | AgentSky API token (`ast_…`), required |
+| `SKY_API_URL` | API base, default `https://agentsky.dev` |
+| `SKY_AGENT` | agent spec slug or `sess-…` session id (alternative to argv) |
+| `SKY_UNIVERSE` | universe slug (sent as `X-Universe`) |
+| `SKY_ACP_NO_REPLY_POST=1` | don't post replies to buzz channels via the buzz CLI |
+| `SKY_ACP_BUZZ_BIN` | buzz CLI binary, default `buzz` |
+| `SKY_ACP_TURN_TIMEOUT_MS` | per-turn safety timeout, default 3600000 |
+
+## Behavior notes
+
+- **Session mapping**: on start the adapter resolves the agent's default
+  session (creating one if the spec has none). All ACP sessions map to it —
+  channel context and thread history arrive in each prompt, so replies stay
+  channel-correct while the agent keeps one continuous memory.
+- **Reply posting**: buzz-acp does not forward the ACP response text to the
+  channel; agents are expected to post via the buzz CLI. The cloud pod has no
+  buzz CLI or Nostr key, so the adapter posts the completed reply itself with
+  `buzz messages send --channel <uuid>` (channel parsed from the prompt's
+  `[Context]` section; env `BUZZ_RELAY_URL`/`BUZZ_PRIVATE_KEY` are inherited
+  from buzz-acp). A bridge note in each forwarded prompt tells the agent to
+  reply in plain text instead of attempting buzz commands.
+- **Reliability**: `Idempotency-Key` on every message post (safe restarts),
+  standing SSE with liveness watchdog + reconnect, events-ledger catch-up
+  deduped by event id, `session/cancel` → interrupt.
+- `mcpServers` from `session/new` are ignored (local stdio sidecars can't
+  reach the cloud pod).

package/dist/index.js

@@ -0,0 +1,555 @@
+#!/usr/bin/env node
+
+// src/api.ts
+var ApiError = class extends Error {
+  constructor(status, code, message) {
+    super(message);
+    this.status = status;
+    this.code = code;
+  }
+  status;
+  code;
+};
+var SkyApi = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  headers() {
+    const headers = {
+      authorization: `Bearer ${this.config.token}`
+    };
+    if (this.config.universe) headers["x-universe"] = this.config.universe;
+    return headers;
+  }
+  async request(method, path, body, extraHeaders = {}) {
+    const res = await fetch(`${this.config.apiBase}${path}`, {
+      method,
+      headers: {
+        ...this.headers(),
+        ...extraHeaders,
+        ...body !== void 0 ? { "content-type": "application/json" } : {}
+      },
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+    if (!res.ok) {
+      let code = "http_error";
+      let message = `${res.status} ${res.statusText}`;
+      try {
+        const parsed = await res.json();
+        if (parsed.error?.message) {
+          code = parsed.error.code ?? code;
+          message = parsed.error.message;
+        }
+      } catch {
+      }
+      throw new ApiError(res.status, code, message);
+    }
+    return await res.json();
+  }
+  /** Resolve the agent ref to the one session this adapter drives: an
+   *  explicit `sess-…` id, else the spec's default session, else a freshly
+   *  created session (which is guaranteed the API channel binding). */
+  async resolveSession() {
+    const ref = this.config.agent;
+    if (ref.startsWith("sess-")) return ref;
+    const { agent } = await this.request("GET", `/api/v1/agents/${encodeURIComponent(ref)}`);
+    if (agent.defaultSessionId) return agent.defaultSessionId;
+    const { session } = await this.request(
+      "POST",
+      "/api/v1/sessions",
+      { agent: ref, title: "buzz (acp bridge)" }
+    );
+    return session.id;
+  }
+  async sendMessage(sessionId, text, idempotencyKey) {
+    await this.request(
+      "POST",
+      `/api/v1/sessions/${encodeURIComponent(sessionId)}/messages`,
+      { parts: [{ type: "text", index: 0, text }] },
+      { "idempotency-key": idempotencyKey }
+    );
+  }
+  async interrupt(sessionId) {
+    await this.request("POST", `/api/v1/sessions/${encodeURIComponent(sessionId)}/interrupt`);
+  }
+  async listEvents(sessionId, cursor, limit = 500) {
+    const params = new URLSearchParams({ limit: String(limit) });
+    if (cursor !== null) params.set("cursor", cursor);
+    return this.request(
+      "GET",
+      `/api/v1/sessions/${encodeURIComponent(sessionId)}/events?${params}`
+    );
+  }
+  /** Open the standing SSE stream. Returns the body; caller parses/aborts. */
+  async openStream(sessionId, signal) {
+    const res = await fetch(
+      `${this.config.apiBase}/api/v1/sessions/${encodeURIComponent(sessionId)}/stream`,
+      { headers: { ...this.headers(), accept: "text/event-stream" }, signal }
+    );
+    if (!res.ok) {
+      throw new ApiError(res.status, "stream_failed", `stream returned ${res.status}`);
+    }
+    if (!res.body) throw new ApiError(502, "no_body", "stream returned no body");
+    return res.body;
+  }
+};
+
+// src/agent.ts
+import { randomUUID } from "crypto";
+
+// src/buzz.ts
+import { execFile } from "child_process";
+
+// src/config.ts
+function loadConfig(argv) {
+  const agent = argv[0] ?? process.env.SKY_AGENT;
+  const token = process.env.SKY_API_TOKEN;
+  if (!agent || !token) {
+    process.stderr.write(
+      "usage: SKY_API_TOKEN=ast_\u2026 agentsky-acp <agent-slug>\n  env: SKY_API_URL (default https://agentsky.dev), SKY_AGENT (alternative to argv),\n       SKY_UNIVERSE, SKY_ACP_NO_REPLY_POST=1, SKY_ACP_BUZZ_BIN (default buzz),\n       SKY_ACP_TURN_TIMEOUT_MS (default 3600000)\n"
+    );
+    process.exit(2);
+  }
+  return {
+    apiBase: (process.env.SKY_API_URL ?? "https://agentsky.dev").replace(/\/$/, ""),
+    token,
+    agent,
+    universe: process.env.SKY_UNIVERSE,
+    replyPost: process.env.SKY_ACP_NO_REPLY_POST !== "1",
+    buzzBin: process.env.SKY_ACP_BUZZ_BIN ?? "buzz",
+    turnTimeoutMs: Number(process.env.SKY_ACP_TURN_TIMEOUT_MS ?? 36e5)
+  };
+}
+function log(message) {
+  process.stderr.write(`[agentsky-acp] ${message}
+`);
+}
+
+// src/buzz.ts
+var UUID = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
+function extractChannelId(prompt) {
+  const context = prompt.match(/\[(?:Context|Thread Context|Conversation Context)\][^[]*/gi);
+  for (const section of context ?? []) {
+    const match = section.match(UUID);
+    if (match) return match[0];
+  }
+  const line = prompt.split(/\r?\n/).find((l) => /channel/i.test(l) && UUID.test(l));
+  return line?.match(UUID)?.[0] ?? null;
+}
+function postReply(bin, channelId, content) {
+  return new Promise((resolve) => {
+    execFile(
+      bin,
+      ["messages", "send", "--channel", channelId, "--content", content],
+      { timeout: 3e4, env: process.env },
+      (error, _stdout, stderr) => {
+        if (error) {
+          log(`buzz reply post failed (channel ${channelId}): ${error.message} ${stderr ?? ""}`);
+        }
+        resolve();
+      }
+    );
+  });
+}
+
+// src/events.ts
+import { setTimeout as sleep } from "timers/promises";
+var SEEN_CAP = 5e3;
+var WATCHDOG_MS = 9e4;
+var EventBus = class {
+  constructor(api, sessionId) {
+    this.api = api;
+    this.sessionId = sessionId;
+  }
+  api;
+  sessionId;
+  listeners = /* @__PURE__ */ new Set();
+  seen = /* @__PURE__ */ new Set();
+  cursor = null;
+  stopped = false;
+  abort = null;
+  connected = false;
+  connectWaiters = [];
+  onEvent(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  /** Resolves once the SSE stream is open (posting before that risks missing
+   *  frames with nothing to catch up from until the next reconnect). */
+  waitConnected() {
+    if (this.connected) return Promise.resolve();
+    return new Promise((resolve) => this.connectWaiters.push(resolve));
+  }
+  /** Advance the ledger cursor to the tail without dispatching history. */
+  async primeCursor() {
+    let cursor = null;
+    while (true) {
+      const page = await this.api.listEvents(this.sessionId, cursor);
+      cursor = page.cursor ?? cursor;
+      for (const event of page.events) this.remember(event.id);
+      if (!page.hasMore) break;
+    }
+    this.cursor = cursor;
+  }
+  /** Run the stream loop until stop(). Never throws; logs and retries. */
+  async run() {
+    let backoffMs = 1e3;
+    while (!this.stopped) {
+      this.abort = new AbortController();
+      const { signal } = this.abort;
+      let lastActivity = Date.now();
+      const watchdog = setInterval(() => {
+        if (Date.now() - lastActivity > WATCHDOG_MS) this.abort?.abort();
+      }, 1e4);
+      try {
+        const body = await this.api.openStream(this.sessionId, signal);
+        backoffMs = 1e3;
+        this.connected = true;
+        for (const resolve of this.connectWaiters.splice(0)) resolve();
+        const { parseSseStream } = await import("./sse-MBBVHOJ7.js");
+        for await (const frame of parseSseStream(body, () => lastActivity = Date.now())) {
+          if (!frame.data) continue;
+          try {
+            this.dispatch(JSON.parse(frame.data));
+          } catch {
+          }
+        }
+      } catch (error) {
+        if (!this.stopped && !signal.aborted) {
+          log(`stream error: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      } finally {
+        this.connected = false;
+        clearInterval(watchdog);
+      }
+      if (this.stopped) break;
+      await this.catchUp().catch(
+        (error) => log(`catch-up failed: ${error instanceof Error ? error.message : String(error)}`)
+      );
+      await sleep(backoffMs);
+      backoffMs = Math.min(backoffMs * 2, 3e4);
+    }
+  }
+  /** Page the ledger from the last cursor, dispatching anything unseen. */
+  async catchUp() {
+    while (true) {
+      const page = await this.api.listEvents(this.sessionId, this.cursor);
+      this.cursor = page.cursor ?? this.cursor;
+      for (const event of page.events) this.dispatch(event);
+      if (!page.hasMore) break;
+    }
+  }
+  stop() {
+    this.stopped = true;
+    this.abort?.abort();
+  }
+  dispatch(event) {
+    if (typeof event.id === "string" && event.id) {
+      if (this.seen.has(event.id)) return;
+      this.remember(event.id);
+    }
+    for (const listener of this.listeners) listener(event);
+  }
+  remember(id) {
+    this.seen.add(id);
+    if (this.seen.size > SEEN_CAP) {
+      const oldest = this.seen.values().next().value;
+      if (oldest !== void 0) this.seen.delete(oldest);
+    }
+  }
+};
+
+// src/rpc.ts
+import { createInterface } from "readline";
+var RpcError = class extends Error {
+  constructor(code, message, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+  }
+  code;
+  data;
+};
+var RpcEndpoint = class {
+  constructor(input = process.stdin, output = process.stdout) {
+    this.input = input;
+    this.output = output;
+  }
+  input;
+  output;
+  handlers = /* @__PURE__ */ new Map();
+  on(method, handler) {
+    this.handlers.set(method, handler);
+  }
+  notify(method, params) {
+    this.write({ jsonrpc: "2.0", method, params });
+  }
+  /** Consume stdin until EOF, dispatching requests and notifications. */
+  async run() {
+    const lines = createInterface({ input: this.input, crlfDelay: Infinity });
+    for await (const line of lines) {
+      if (!line.trim()) continue;
+      let request;
+      try {
+        request = JSON.parse(line);
+      } catch {
+        this.write({
+          jsonrpc: "2.0",
+          id: null,
+          error: { code: -32700, message: "parse error" }
+        });
+        continue;
+      }
+      void this.dispatch(request);
+    }
+  }
+  async dispatch(request) {
+    const handler = this.handlers.get(request.method);
+    if (!handler) {
+      if (request.id !== void 0) {
+        this.write({
+          jsonrpc: "2.0",
+          id: request.id,
+          error: { code: -32601, message: `method not found: ${request.method}` }
+        });
+      }
+      return;
+    }
+    try {
+      const result = await handler(request.params);
+      if (request.id !== void 0) {
+        this.write({ jsonrpc: "2.0", id: request.id, result: result ?? {} });
+      }
+    } catch (error) {
+      if (request.id === void 0) {
+        log(`notification ${request.method} failed: ${String(error)}`);
+        return;
+      }
+      const rpcError = error instanceof RpcError ? { code: error.code, message: error.message, data: error.data } : { code: -32603, message: error instanceof Error ? error.message : String(error) };
+      this.write({ jsonrpc: "2.0", id: request.id, error: rpcError });
+    }
+  }
+  write(frame) {
+    this.output.write(`${JSON.stringify(frame)}
+`);
+  }
+};
+
+// src/agent.ts
+var VERSION = "0.1.0";
+var PROTOCOL_VERSION = 2;
+var BRIDGE_NOTE = "[Bridge note] You are connected to this Buzz workspace through the AgentSky bridge. The `buzz` CLI and Nostr relay are NOT available in your environment \u2014 do not attempt to run `buzz` commands. Write your reply as plain response text; the bridge posts it to the correct channel for you.";
+var AcpAgent = class {
+  constructor(config, api, rpc) {
+    this.config = config;
+    this.api = api;
+    this.rpc = rpc;
+  }
+  config;
+  api;
+  rpc;
+  sessionId = null;
+  bus = null;
+  initPromise = null;
+  turnChain = Promise.resolve();
+  inflight = false;
+  acpSessionCounter = 0;
+  register() {
+    this.rpc.on("initialize", () => ({
+      protocolVersion: PROTOCOL_VERSION,
+      agentCapabilities: {
+        loadSession: false,
+        promptCapabilities: { image: false, audio: false, embeddedContext: false }
+      },
+      authMethods: [],
+      agentInfo: { name: "agentsky-acp", version: VERSION }
+    }));
+    this.rpc.on("authenticate", () => ({}));
+    this.rpc.on("session/new", () => this.newSession());
+    this.rpc.on("session/prompt", (params) => this.prompt(params));
+    this.rpc.on("session/cancel", () => this.cancel());
+  }
+  /** Resolve the AgentSky session and start the event pipeline, once. */
+  ensureReady() {
+    this.initPromise ??= (async () => {
+      const sessionId = await this.api.resolveSession();
+      this.sessionId = sessionId;
+      const bus = new EventBus(this.api, sessionId);
+      await bus.primeCursor().catch((error) => {
+        log(`cursor prime failed (continuing live-only): ${String(error)}`);
+      });
+      void bus.run();
+      this.bus = bus;
+      log(`attached to session ${sessionId}`);
+    })();
+    return this.initPromise;
+  }
+  async newSession() {
+    await this.ensureReady();
+    return { sessionId: `sky-acp-${++this.acpSessionCounter}-${randomUUID().slice(0, 8)}` };
+  }
+  prompt(params) {
+    const turn = this.turnChain.then(
+      () => this.runTurn(params),
+      () => this.runTurn(params)
+    );
+    this.turnChain = turn.catch(() => void 0);
+    return turn;
+  }
+  async runTurn(params) {
+    await this.ensureReady();
+    const sessionId = this.sessionId;
+    const bus = this.bus;
+    if (!sessionId || !bus) throw new RpcError(-32603, "adapter not initialized");
+    const text = (params.prompt ?? []).filter((block) => block.type === "text" && typeof block.text === "string").map((block) => block.text).join("\n\n");
+    if (!text.trim()) return { stopReason: "end_turn" };
+    const channelId = extractChannelId(text);
+    const acpSessionId = params.sessionId;
+    let replyText = "";
+    let sawTurnActivity = false;
+    let settle;
+    let fail;
+    const done = new Promise((resolve, reject) => {
+      settle = resolve;
+      fail = reject;
+    });
+    const unsubscribe = bus.onEvent((event) => {
+      switch (event.type) {
+        case "user.message":
+        case "turn.accepted":
+          sawTurnActivity = true;
+          break;
+        case "agent.message": {
+          sawTurnActivity = true;
+          const chunk = typeof event.text === "string" ? event.text : "";
+          if (chunk) {
+            replyText += (replyText ? "\n\n" : "") + chunk;
+            this.update(acpSessionId, {
+              sessionUpdate: "agent_message_chunk",
+              content: { type: "text", text: chunk }
+            });
+          }
+          break;
+        }
+        case "agent.reasoning": {
+          sawTurnActivity = true;
+          const part = event.part;
+          if (part?.text) {
+            this.update(acpSessionId, {
+              sessionUpdate: "agent_thought_chunk",
+              content: { type: "text", text: part.text }
+            });
+          }
+          break;
+        }
+        case "agent.tool_use": {
+          sawTurnActivity = true;
+          const part = event.part;
+          this.update(acpSessionId, {
+            sessionUpdate: "tool_call",
+            toolCallId: part?.call_id ?? randomUUID(),
+            title: part?.tool_name ?? "tool",
+            kind: "other",
+            status: "in_progress"
+          });
+          break;
+        }
+        case "agent.tool_result": {
+          sawTurnActivity = true;
+          const part = event.part;
+          if (part?.call_id) {
+            this.update(acpSessionId, {
+              sessionUpdate: "tool_call_update",
+              toolCallId: part.call_id,
+              status: part.status === "error" ? "failed" : "completed"
+            });
+          }
+          break;
+        }
+        case "turn.status_idle":
+          if (sawTurnActivity) settle("end_turn");
+          break;
+        case "turn.interrupted":
+          settle("cancelled");
+          break;
+        case "error": {
+          const code = typeof event.code === "string" ? event.code : "";
+          if (code === "enqueue_failed") {
+            fail(new Error("turn enqueue failed \u2014 pod unavailable"));
+          } else {
+            log(`stream error event: ${code} ${String(event.message ?? "")}`);
+          }
+          break;
+        }
+        case "session.deleted":
+          fail(new Error("session deleted"));
+          break;
+      }
+    });
+    this.inflight = true;
+    const timeout = setTimeout(() => {
+      log(`turn timeout after ${this.config.turnTimeoutMs}ms \u2014 interrupting`);
+      this.api.interrupt(sessionId).catch(() => void 0);
+      settle("cancelled");
+    }, this.config.turnTimeoutMs);
+    try {
+      await Promise.race([
+        bus.waitConnected(),
+        new Promise((resolve) => setTimeout(resolve, 1e4))
+      ]);
+      await this.api.sendMessage(sessionId, `${text}
+
+${BRIDGE_NOTE}`, randomUUID());
+      const stopReason = await done;
+      if (this.config.replyPost && channelId && replyText.trim()) {
+        await postReply(this.config.buzzBin, channelId, replyText.trim());
+      } else if (!channelId && replyText.trim()) {
+        log("no channel UUID found in prompt \u2014 reply not posted to buzz");
+      }
+      return { stopReason };
+    } catch (error) {
+      if (error instanceof ApiError) {
+        throw new RpcError(-32603, `agentsky api error (${error.code}): ${error.message}`);
+      }
+      throw error instanceof RpcError ? error : new RpcError(-32603, error instanceof Error ? error.message : String(error));
+    } finally {
+      clearTimeout(timeout);
+      unsubscribe();
+      this.inflight = false;
+    }
+  }
+  async cancel() {
+    if (!this.sessionId || !this.inflight) return;
+    await this.api.interrupt(this.sessionId).catch((error) => {
+      log(`interrupt failed: ${error instanceof Error ? error.message : String(error)}`);
+    });
+  }
+  update(sessionId, update) {
+    this.rpc.notify("session/update", { sessionId: sessionId ?? "", update });
+  }
+  shutdown() {
+    this.bus?.stop();
+  }
+};
+
+// src/index.ts
+async function main() {
+  const config = loadConfig(process.argv.slice(2));
+  const rpc = new RpcEndpoint();
+  const agent = new AcpAgent(config, new SkyApi(config), rpc);
+  agent.register();
+  const shutdown = () => {
+    agent.shutdown();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  log(`agentsky-acp ${VERSION} \u2014 agent ${config.agent} via ${config.apiBase}`);
+  await rpc.run();
+  shutdown();
+}
+main().catch((error) => {
+  log(`fatal: ${error instanceof Error ? error.stack ?? error.message : String(error)}`);
+  process.exit(1);
+});

package/dist/sse-MBBVHOJ7.js

@@ -0,0 +1,37 @@
+// src/sse.ts
+async function* parseSseStream(body, onActivity) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      onActivity?.();
+      buffer += decoder.decode(value, { stream: true });
+      let sep;
+      while ((sep = buffer.match(/\r?\n\r?\n/)) && sep.index !== void 0) {
+        const raw = buffer.slice(0, sep.index);
+        buffer = buffer.slice(sep.index + sep[0].length);
+        const frame = { data: "" };
+        const dataLines = [];
+        for (const line of raw.split(/\r?\n/)) {
+          if (!line || line.startsWith(":")) continue;
+          const colon = line.indexOf(":");
+          const field = colon === -1 ? line : line.slice(0, colon);
+          const value2 = colon === -1 ? "" : line.slice(colon + 1).replace(/^ /, "");
+          if (field === "id") frame.id = value2;
+          else if (field === "event") frame.event = value2;
+          else if (field === "data") dataLines.push(value2);
+        }
+        frame.data = dataLines.join("\n");
+        if (frame.id !== void 0 || frame.event !== void 0 || frame.data) yield frame;
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+export {
+  parseSseStream
+};

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@agentsky/acp",
+  "version": "0.1.0",
+  "description": "agentsky-acp — ACP (Agent Client Protocol) adapter: run an AgentSky cloud agent as a local ACP agent over stdio.",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "agentsky-acp": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "build": "tsup src/index.ts --format esm --target node20 --clean",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@types/node": "^20",
+    "tsup": "^8.5.0",
+    "tsx": "^4.22.4",
+    "typescript": "^5",
+    "vitest": "^3.0.0"
+  }
+}