npm - @decentnetwork/beagle-service - Versions diffs - 0.0.0-stage → 0.2.0 - Mend

@decentnetwork/beagle-service 0.0.0-stage → 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (43) hide show

package/LICENSE +21 -0
package/README.md +720 -2
package/dist/agent.d.ts +18 -0
package/dist/agent.js +448 -0
package/dist/auth.d.ts +28 -0
package/dist/auth.js +340 -0
package/dist/cli.d.ts +2 -0
package/dist/cli.js +163 -0
package/dist/commonjs.cjs +49 -0
package/dist/commonjs.d.cts +11 -0
package/dist/index.d.ts +23 -0
package/dist/index.js +191 -0
package/dist/outbox.d.ts +63 -0
package/dist/outbox.js +314 -0
package/dist/routes.d.ts +29 -0
package/dist/routes.js +454 -0
package/dist/stores.d.ts +21 -0
package/dist/stores.js +92 -0
package/dist/types.d.ts +641 -0
package/dist/types.js +1 -0
package/dist/users.d.ts +16 -0
package/dist/users.js +429 -0
package/dist/util.d.ts +48 -0
package/dist/util.js +208 -0
package/examples/minimal-site/index.html +91 -0
package/examples/minimal-site/server.mjs +64 -0
package/examples/next-pages-cjs/README.md +30 -0
package/examples/next-pages-cjs/instrumentation.js +16 -0
package/examples/next-pages-cjs/lib/beagle.js +23 -0
package/examples/next-pages-cjs/lib/peer-for-browser.mjs +2 -0
package/examples/next-pages-cjs/next.config.js +11 -0
package/examples/next-pages-cjs/package.json +19 -0
package/examples/next-pages-cjs/pages/api/auth/[...nextauth].js +17 -0
package/examples/next-pages-cjs/pages/api/auth/launch.js +3 -0
package/examples/next-pages-cjs/pages/api/auth/logout.js +3 -0
package/examples/next-pages-cjs/pages/api/auth/me.js +3 -0
package/examples/next-pages-cjs/pages/api/auth/nonce.js +3 -0
package/examples/next-pages-cjs/pages/api/auth/register.js +3 -0
package/examples/next-pages-cjs/pages/api/auth/sign-in.js +3 -0
package/examples/next-pages-cjs/pages/api/notes.js +16 -0
package/examples/next-pages-cjs/pages/index.js +52 -0
package/examples/sign-in-from-script.mjs +37 -0
package/package.json +67 -4

package/examples/minimal-site/index.html ADDED Viewed

@@ -0,0 +1,91 @@
+<!doctype html>
+<html lang="en">
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Minimal site</title>
+<style>
+  body { font: 16px/1.5 system-ui, sans-serif; max-width: 34rem; margin: 3rem auto; padding: 0 1rem; }
+  button, input { font: inherit; padding: .5rem .8rem; margin: .2rem .2rem .2rem 0; }
+  code { word-break: break-all; }
+  #error { color: #b00020; }
+</style>
+<h1>Minimal site</h1>
+<div id="out">Loading…</div>
+<p id="error"></p>
+<script type="module">
+import { signIn, readLaunch, addFriend } from "/beagle-connect.js";
+// Two doors, one origin each: an https page cannot probe for an installed
+// Beagle, so the visitor says which one they use. A Beagle on another local
+// port: open this page with ?beagle=http://127.0.0.1:8767
+const local = new URLSearchParams(location.search).get("beagle");
+const DOORS = {
+  installed: /^http:\/\/(127\.0\.0\.1|localhost):\d+$/.test(local ?? "") ? local : "http://127.0.0.1:8766",
+  web: "https://app.beagle.chat",
+};
+const out = document.querySelector("#out");
+const fail = (e) => (document.querySelector("#error").textContent = e?.message ?? String(e));
+const api = async (path, body) => {
+  const r = await fetch(`/api/auth/${path}`, body ? { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body) } : {});
+  return { status: r.status, ...(await r.json()) };
+};
+const el = (tag, props = {}, ...kids) => {
+  const n = Object.assign(document.createElement(tag), props);
+  n.append(...kids);
+  return n;
+};
+async function signInThrough(door) {
+  // Open the window inside the click: one opened after an await has lost the user gesture.
+  const win = window.open("about:blank", "beagle-connect", "width=420,height=560");
+  if (!win) return fail(new Error("Allow pop-ups for this site, then click again."));
+  try {
+    const { nonce } = await api("nonce");
+    const who = await signIn({ nonce, origins: [DOORS[door]], existingWindow: win });
+    render(await api("sign-in", who)); // { userid, address, name, avatar, sig, nonce, uiOrigin }
+  } catch (e) {
+    try { win.close(); } catch {}
+    fail(e);
+  }
+}
+function render(me) {
+  document.querySelector("#error").textContent = "";
+  out.replaceChildren();
+  if (!me.user) {
+    if (me.error && me.error !== "not-signed-in") fail(new Error(me.message));
+    out.append(
+      el("button", { textContent: "Sign in with Beagle (installed)", onclick: () => signInThrough("installed") }),
+      el("button", { textContent: "Sign in with Beagle in the browser", onclick: () => signInThrough("web") }),
+    );
+    return;
+  }
+  const { user, registration, agent } = me;
+  out.append(el("p", {}, `Signed in as ${user.name ?? "someone"} (${user.status}) `, el("code", { textContent: user.userid })));
+  if (registration.missing.length || registration.optional.length) {
+    const form = el("form", {}, el("p", { textContent: registration.due ? "Please register to go on:" : registration.missing.length ? "Register:" : "Your details:" }));
+    for (const f of [...registration.required, ...registration.optional]) {
+      form.append(el("input", { name: f, placeholder: f + (registration.required.includes(f) ? " (required)" : ""), value: user.profile[f] ?? "" }));
+    }
+    form.append(el("button", { textContent: "Save" }));
+    form.onsubmit = async (ev) => {
+      ev.preventDefault();
+      const r = await api("register", { profile: Object.fromEntries(new FormData(form)) });
+      r.ok ? render(r) : fail(new Error(Object.entries(r.fields ?? {}).map(([k, v]) => `${k}: ${v}`).join(", ") || r.message));
+    };
+    out.append(form);
+  }
+  if (agent) out.append(el("button", { textContent: `Add ${agent.name ?? "our agent"} on Beagle`, onclick: () => addFriend({ address: agent.address, name: agent.name }).catch(fail) }));
+  out.append(el("button", { textContent: "Sign out", onclick: async () => { await api("logout", {}); render({}); } }));
+  fetch("/api/hello").then((r) => r.json()).then((j) => out.append(el("p", { textContent: j.message ?? `The site's own route says: ${j.error}` })));
+}
+// Arrived from Beagle's Apps tab? Then the visitor is signed in already.
+try {
+  const launch = await readLaunch();
+  if (launch) await api("launch", launch);
+} catch (e) { fail(e); }
+render(await api("me"));
+</script>
+</html>

package/examples/minimal-site/server.mjs ADDED Viewed

@@ -0,0 +1,64 @@
+// A whole site on Beagle identity in one file.
+//   npm install @decentnetwork/beagle-service @decentnetwork/beagle-connect esbuild
+//   node server.mjs        →  http://localhost:3000
+import http from "node:http";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { build } from "esbuild";
+import { createBeagleService } from "@decentnetwork/beagle-service";
+const PORT = Number(process.env.PORT ?? 3000);
+const ORIGIN = process.env.ORIGIN ?? `http://localhost:${PORT}`; // exactly what the browser's address bar shows
+const svc = await createBeagleService({
+  origins: [ORIGIN],
+  dataDir: process.env.DATA_DIR ?? fileURLToPath(new URL("./data", import.meta.url)),
+  register: { required: ["email"], optional: ["location"] }, // [] = every visitor is a user at once
+  visitor: { maxDays: 14, then: "ask" },                     // "refuse" = 403 until they register
+  // The site's own Carrier identity. Leave it out if the site only needs sign-in.
+  agent: process.env.AGENT ? { nickname: "Minimal Site", accept: "signed-in", befriendOn: "register" } : undefined,
+});
+svc.agent?.onMessage(({ user, text, reply }) => reply(user ? `Hello ${user.name ?? "there"}, you said: ${text}` : "Sign in on the site first."));
+svc.users.on("registered", (user) => console.log(`registered: ${user.userid} ${JSON.stringify(user.profile)}`));
+// beagle-connect for the browser. It needs two functions of @decentnetwork/peer
+// (the signature check), so bundle those two modules instead of the whole peer.
+const peerForBrowser = {
+  name: "peer-for-browser",
+  setup(b) {
+    b.onResolve({ filter: /^@decentnetwork\/peer$/ }, () => ({ path: "peer", namespace: "shim" }));
+    b.onLoad({ filter: /.*/, namespace: "shim" }, () => ({
+      resolveDir: fileURLToPath(new URL(".", import.meta.url)),
+      contents: `export { verifyDetached } from "@decentnetwork/peer/dist/crypto/sign.js";
+                 export { base58ToBytes } from "@decentnetwork/peer/dist/utils/base58.js";`,
+    }));
+  },
+};
+const client = (await build({
+  entryPoints: [fileURLToPath(import.meta.resolve("@decentnetwork/beagle-connect"))],
+  bundle: true, format: "esm", platform: "browser", write: false, plugins: [peerForBrowser],
+})).outputFiles[0].text;
+const page = readFileSync(new URL("./index.html", import.meta.url));
+const auth = svc.nodeHandler({ prefix: "/api/auth" }); // nonce, sign-in, launch, me, logout, register
+const send = (res, status, type, body) => { res.writeHead(status, { "content-type": type, "cache-control": "no-store" }); res.end(body); };
+http.createServer(async (req, res) => {
+  const path = new URL(req.url, ORIGIN).pathname;
+  if (path.startsWith("/api/auth/")) return auth(req, res);
+  if (path === "/api/hello") {
+    // One of the site's own routes: who is asking?
+    const who = await svc.auth.authenticate(req);
+    if (!who.ok) return send(res, who.status, "application/json", JSON.stringify({ error: who.error }));
+    return send(res, 200, "application/json", JSON.stringify({ message: `Hello ${who.user.name ?? who.user.userid}, you are ${who.user.status}.` }));
+  }
+  if (path === "/beagle-connect.js") return send(res, 200, "text/javascript; charset=utf-8", client);
+  if (path === "/") return send(res, 200, "text/html; charset=utf-8", page);
+  send(res, 404, "text/plain", "not found");
+}).listen(PORT, () => {
+  console.log(`minimal-site: ${ORIGIN}`);
+  if (svc.agent) console.log(`agent address (add it in Beagle): ${svc.agent.address}`);
+});
+// To refuse someone:  await svc.users.block(userid, "spam")   (sign-in answers 403, sessions end, the agent drops them)

package/examples/next-pages-cjs/README.md ADDED Viewed

@@ -0,0 +1,30 @@
+# Sign in with Beagle beside NextAuth, in a CommonJS Next.js site
+A pages-router site whose `lib/` is CommonJS and which already has NextAuth's catch-all at
+`pages/api/auth/[...nextauth].js`.
+```bash
+npm install
+npm run build
+BEAGLE_ORIGINS=http://localhost:3000 npm start
+```
+| File | What it shows |
+|---|---|
+| `lib/beagle.js` | `require("@decentnetwork/beagle-service")`, one service per process, the `onSignIn` hook |
+| `instrumentation.js` | the service is created when the server starts, so a wrong `BEAGLE_ORIGINS` stops the start |
+| `pages/api/auth/[...nextauth].js` | NextAuth's catch-all, untouched |
+| `pages/api/auth/nonce.js`, `sign-in.js`, `launch.js`, `me.js`, `logout.js`, `register.js` | one Beagle route per file: `export default beagle.route("signIn")` |
+| `pages/api/notes.js` | a route of the site's own: `beagle.authenticate(req, { checkOrigin: true })` |
+| `pages/index.js` | reading the session in `getServerSideProps`; the popup with `beagle-connect` |
+| `next.config.js`, `lib/peer-for-browser.mjs` | what the browser bundle needs for `beagle-connect` |
+The operator's command works beside the running server:
+```bash
+npx beagle-service users list
+npx beagle-service users block <userid> spam
+```
+`npm run e2e:next` in the package builds this example against the package as it would be published and runs it
+with `next build` and `next start`.

package/examples/next-pages-cjs/instrumentation.js ADDED Viewed

@@ -0,0 +1,16 @@
+// Next.js runs this once when the server starts (`next start`, `next dev`),
+// before any request. Creating the service here means a wrong configuration
+// (an entry of BEAGLE_ORIGINS that is not an exact origin, a users file that
+// does not parse) is found at start, with its reason, instead of showing up as
+// a failed sign-in later.
+//
+// When `register` rejects, Next.js prints "Failed to prepare server" with the
+// reason and answers 500 to every request until the configuration is fixed and
+// the server started again. To keep the rest of the site up and have only the
+// sign-in routes answer 500, do not await: `beagle.ready().catch(() => {})`
+// (the reason is still printed at start).
+export async function register() {
+  if (process.env.NEXT_RUNTIME !== "nodejs") return;
+  const { beagle } = require("./lib/beagle");
+  await beagle.ready();
+}

package/examples/next-pages-cjs/lib/beagle.js ADDED Viewed

@@ -0,0 +1,23 @@
+// The site's one beagle-service. CommonJS, like the rest of this lib/.
+//
+// `sharedBeagleService` returns at once and creates the service on first use,
+// one per process however many times Next.js evaluates this file. It never
+// throws at a request: while the service cannot start, the routes answer 500
+// and `authenticate` answers `ok: false`.
+const { sharedBeagleService } = require("@decentnetwork/beagle-service");
+const list = (v) => String(v || "").split(",").map((s) => s.trim()).filter(Boolean);
+const beagle = sharedBeagleService(() => ({
+  // Exact origins of this site's pages: scheme, host and port.
+  origins: list(process.env.BEAGLE_ORIGINS || `http://localhost:${process.env.PORT || 3000}`),
+  dataDir: process.env.BEAGLE_DATA_DIR || "./data",
+  // The site's part of a sign-in, awaited before the answer goes out. What it
+  // returns is added to the answer; `{ refuse: "why" }` refuses the sign-in.
+  onSignIn: async (user, { origin, door, first }) => {
+    if (first) console.log(`first sign-in: ${user.userid} at ${origin} through ${door}`);
+    return { role: user.signIns > 100 ? "regular" : "listener" };
+  },
+}));
+module.exports = { beagle };

package/examples/next-pages-cjs/lib/peer-for-browser.mjs ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export { verifyDetached } from "@decentnetwork/peer/dist/crypto/sign.js";
2	+ export { base58ToBytes } from "@decentnetwork/peer/dist/utils/base58.js";

package/examples/next-pages-cjs/next.config.js ADDED Viewed

@@ -0,0 +1,11 @@
+const path = require("path");
+module.exports = {
+  webpack(config, { isServer }) {
+    // The page uses beagle-connect, which needs two functions of
+    // @decentnetwork/peer (the signature check). Give the browser those two
+    // modules instead of the whole peer.
+    if (!isServer) config.resolve.alias["@decentnetwork/peer$"] = path.join(__dirname, "lib/peer-for-browser.mjs");
+    return config;
+  },
+};

package/examples/next-pages-cjs/package.json ADDED Viewed

@@ -0,0 +1,19 @@
+{
+  "name": "beagle-service-next-pages-cjs",
+  "private": true,
+  "description": "Sign in with Beagle in a CommonJS Next.js pages-router site that also has NextAuth's catch-all.",
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "start": "next start",
+    "users": "beagle-service users list"
+  },
+  "dependencies": {
+    "@decentnetwork/beagle-connect": "^0.1.2",
+    "@decentnetwork/beagle-service": "^0.2.0",
+    "next": "^15.3.2",
+    "next-auth": "^4.24.14",
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0"
+  }
+}

package/examples/next-pages-cjs/pages/api/auth/[...nextauth].js ADDED Viewed

@@ -0,0 +1,17 @@
+// NextAuth owns the catch-all under /api/auth. A second catch-all in this
+// directory does not build, so the Beagle routes beside it are one file each
+// (nonce.js, sign-in.js, launch.js, me.js, logout.js, register.js); a named
+// file wins over the catch-all, and none of those names is one of NextAuth's.
+import NextAuth from "next-auth";
+import Credentials from "next-auth/providers/credentials";
+export default NextAuth({
+  secret: process.env.NEXTAUTH_SECRET || "example-only-secret-change-me",
+  providers: [
+    Credentials({
+      name: "Demo",
+      credentials: { name: { label: "Name", type: "text" } },
+      authorize: async (credentials) => (credentials?.name ? { id: credentials.name, name: credentials.name } : null),
+    }),
+  ],
+});

package/examples/next-pages-cjs/pages/api/auth/launch.js ADDED Viewed

@@ -0,0 +1,3 @@
+const { beagle } = require("../../../lib/beagle");
+export default beagle.route("launch");

package/examples/next-pages-cjs/pages/api/auth/logout.js ADDED Viewed

@@ -0,0 +1,3 @@
+const { beagle } = require("../../../lib/beagle");
+export default beagle.route("logout");

package/examples/next-pages-cjs/pages/api/auth/me.js ADDED Viewed

@@ -0,0 +1,3 @@
+const { beagle } = require("../../../lib/beagle");
+export default beagle.route("me");

package/examples/next-pages-cjs/pages/api/auth/nonce.js ADDED Viewed

@@ -0,0 +1,3 @@
+const { beagle } = require("../../../lib/beagle");
+export default beagle.route("nonce");

package/examples/next-pages-cjs/pages/api/auth/register.js ADDED Viewed

@@ -0,0 +1,3 @@
+const { beagle } = require("../../../lib/beagle");
+export default beagle.route("register");

package/examples/next-pages-cjs/pages/api/auth/sign-in.js ADDED Viewed

@@ -0,0 +1,3 @@
+const { beagle } = require("../../../lib/beagle");
+export default beagle.route("signIn");

package/examples/next-pages-cjs/pages/api/notes.js ADDED Viewed

@@ -0,0 +1,16 @@
+// One of the site's own routes. Reading a session is asynchronous and never
+// throws: no session, a bad one, a blocked user or a server that cannot check
+// all come back as `ok: false` with a status.
+const { beagle } = require("../../lib/beagle");
+const notes = new Map(); // userid -> text; a real site has a database
+export default async function handler(req, res) {
+  // checkOrigin: a request that changes something and carries the session
+  // cookie must come from one of this site's pages (its Origin header is on
+  // the list). A GET is not checked.
+  const who = await beagle.authenticate(req, { checkOrigin: true });
+  if (!who.ok) return res.status(who.status).json({ error: who.error });
+  if (req.method === "POST") notes.set(who.user.userid, String(req.body?.text ?? "").slice(0, 500));
+  res.status(200).json({ note: notes.get(who.user.userid) ?? "" });
+}

package/examples/next-pages-cjs/pages/index.js ADDED Viewed

@@ -0,0 +1,52 @@
+import { useState } from "react";
+import { beagle } from "../lib/beagle"; // used on the server only, in getServerSideProps
+export async function getServerSideProps({ req }) {
+  const who = await beagle.authenticate(req);
+  return { props: { user: who.ok ? { userid: who.user.userid, name: who.user.name } : null } };
+}
+export default function Home({ user }) {
+  const [me, setMe] = useState(user);
+  const [error, setError] = useState("");
+  async function signInWithBeagle() {
+    // Open the window inside the click, or the browser blocks it.
+    const win = window.open("about:blank", "beagle-connect", "width=420,height=560");
+    try {
+      const { signIn } = await import("@decentnetwork/beagle-connect");
+      const { nonce } = await (await fetch("/api/auth/nonce")).json();
+      const who = await signIn({ nonce, existingWindow: win });
+      const res = await fetch("/api/auth/sign-in", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(who) });
+      const answer = await res.json();
+      if (!res.ok) throw new Error(answer.message || answer.error);
+      setMe(answer.user);
+      setError("");
+    } catch (e) {
+      win?.close();
+      setError(String(e.message || e));
+    }
+  }
+  async function signOut() {
+    await fetch("/api/auth/logout", { method: "POST" });
+    setMe(null);
+  }
+  return (
+    <main style={{ font: "16px system-ui", maxWidth: 560, margin: "64px auto", padding: "0 16px" }}>
+      <h1>Sign in with Beagle</h1>
+      {me ? (
+        <>
+          <p>Signed in as <b>{me.name || "someone"}</b></p>
+          <p><code style={{ wordBreak: "break-all" }}>{me.userid}</code></p>
+          <button onClick={signOut}>Sign out</button>
+        </>
+      ) : (
+        <button onClick={signInWithBeagle}>Sign in with Beagle</button>
+      )}
+      {error && <p role="alert">{error}</p>}
+      <p><a href="/api/auth/signin">NextAuth's own sign-in page</a> lives beside it.</p>
+    </main>
+  );
+}

package/examples/sign-in-from-script.mjs ADDED Viewed

@@ -0,0 +1,37 @@
+// A script that signs in to a site: a publisher node, a cron job, a test.
+//
+//   node sign-in-from-script.mjs https://your.app
+//
+// A browser adds the `Origin` header by itself; a script has to. The server
+// takes the origin from that header only (never from the body), checks it
+// against its exact list, and checks that the signature was made for it. So a
+// script names the site's own origin, the one its pages are served from, in
+// the header and in the string it signs.
+import { generateKeyPairSync } from "node:crypto";
+import { bytesToBase58, signDetached } from "@decentnetwork/peer";
+const site = new URL(process.argv[2] ?? "http://localhost:3000").origin;
+const sendOrigin = !process.argv.includes("--no-origin");
+// The script's identity. A real one loads its key from a file it keeps; this
+// one makes a throwaway X25519 key so the example runs anywhere.
+const { publicKey, privateKey } = generateKeyPairSync("x25519");
+const secretKey = new Uint8Array(Buffer.from(privateKey.export({ format: "jwk" }).d, "base64url"));
+const userid = bytesToBase58(new Uint8Array(Buffer.from(publicKey.export({ format: "jwk" }).x, "base64url")));
+const headers = sendOrigin ? { Origin: site, "content-type": "application/json" } : { "content-type": "application/json" };
+// README:begin
+const { nonce } = await (await fetch(`${site}/api/auth/nonce`)).json();
+const sig = Buffer.from(signDetached(secretKey, new TextEncoder().encode(`decent-auth\n${site}\n${nonce}`))).toString("hex");
+const res = await fetch(`${site}/api/auth/sign-in`, { method: "POST", headers, body: JSON.stringify({ userid, nonce, sig }) });
+// README:end
+const answer = await res.json();
+if (!res.ok) {
+  console.error(`sign-in refused: ${res.status} ${answer.error}`);
+  process.exit(1);
+}
+// The session: send this cookie back on later requests (or use `session: { transport: "bearer" }` on the site).
+const cookie = res.headers.getSetCookie().map((c) => c.split(";")[0]).join("; ");
+const me = await (await fetch(`${site}/api/auth/me`, { headers: { cookie } })).json();
+console.log(`signed in as ${me.user.userid}`);

package/package.json CHANGED Viewed

@@ -1,6 +1,69 @@
 {
   "name": "@decentnetwork/beagle-service",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "description": "The web backend for a site on Beagle identity: Sign in with Beagle on the server, a user store with registration and a blacklist, and the site's own Carrier agent.",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/commonjs.cjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/commonjs.d.cts",
+        "default": "./dist/commonjs.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "beagle-service": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "examples",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.json && chmod +x dist/cli.js",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "npm run build && tsc -p test/types/tsconfig.json && node --test --test-force-exit test/*.test.mjs",
+    "e2e": "npm run build && node test/e2e/agent-public.mjs",
+    "prepack": "npm run build",
+    "e2e:next": "node test/e2e/next-example.mjs",
+    "test:gaps-on-0.1.0": "node test/gaps-on-0.1.0.mjs"
+  },
+  "dependencies": {
+    "@decentnetwork/beagle-connect": "^0.1.2",
+    "@decentnetwork/peer": "^0.1.178"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "typescript": "^5.3.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "beagle",
+    "carrier",
+    "decent network",
+    "sign-in",
+    "authentication",
+    "p2p",
+    "agent"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/0xli/beagle.git",
+    "directory": "packages/beagle-service"
+  },
+  "module": "./dist/index.js"
+}