@dewee/identity 0.0.0-stage → 0.1.0-beta.1

package/dist/links.js

@@ -0,0 +1,140 @@
+import { createAssertion } from "./assertion.js";
+import { DeweeIdentityError, invalidArgument } from "./errors.js";
+import { IDENTITY_SESSION_HEADER } from "./exchange.js";
+import { assertServer, gatewayRequest, normalizeBaseUrl, requireString } from "./transport.js";
+/** Path of the hosted Connect page that receives the partner handoff. */
+export const CONNECT_RETURN_PATH = "/connect/return";
+const TXN_PATTERN = /^[A-Za-z0-9_-]{16,256}$/;
+function expectedReturnTo(connectBaseUrl, allowInsecureHttp) {
+    return `${normalizeBaseUrl(connectBaseUrl, "connectBaseUrl", allowInsecureHttp)}${CONNECT_RETURN_PATH}`;
+}
+/**
+ * Checks the two values Dewee sends to your connect start URL. `return_to` must be exactly your
+ * Dewee Connect page: anything else is refused, so a crafted link can never make your server hand
+ * a signed assertion to another site.
+ */
+export function checkConnectRequest(input, opts) {
+    const expected = expectedReturnTo(opts.connectBaseUrl, opts.allowInsecureHttp);
+    if (typeof input.deweeTxn !== "string" || !TXN_PATTERN.test(input.deweeTxn)) {
+        throw invalidArgument("dewee_txn is missing or malformed");
+    }
+    if (typeof input.returnTo !== "string" || input.returnTo === "") {
+        throw invalidArgument("return_to is missing");
+    }
+    let returnTo;
+    try {
+        returnTo = new URL(input.returnTo);
+    }
+    catch {
+        throw invalidArgument("return_to is not a URL");
+    }
+    const normalized = `${returnTo.origin}${returnTo.pathname}`;
+    if (normalized !== expected || returnTo.search !== "" || returnTo.hash !== "" || returnTo.username !== "") {
+        throw invalidArgument("return_to is not your Dewee Connect page; refusing to hand off");
+    }
+    return { deweeTxn: input.deweeTxn, returnTo: expected };
+}
+/** Reads and checks `dewee_txn` and `return_to` from the URL of a request to your connect start URL. */
+export function readConnectRequest(requestUrl, opts) {
+    let url;
+    try {
+        url = new URL(requestUrl.toString(), "http://placeholder.invalid");
+    }
+    catch {
+        throw invalidArgument("request URL is malformed");
+    }
+    return checkConnectRequest({ deweeTxn: url.searchParams.get("dewee_txn"), returnTo: url.searchParams.get("return_to") }, opts);
+}
+const CSP_NONCE_PATTERN = /^[A-Za-z0-9+/=_-]{8,256}$/;
+function escapeHtml(value) {
+    return value
+        .replaceAll("&", "&")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&#39;");
+}
+/**
+ * Builds the hosted-link handoff: signs a handoff assertion for the signed-in user, bound to this
+ * ceremony (`nonce` = `dewee_txn`), and returns the POST form that sends the user back to Dewee
+ * Connect. Dewee then shows the consent screen and the chat proof step.
+ */
+export async function createConnectRedirect(opts) {
+    assertServer();
+    if (opts === null || typeof opts !== "object")
+        throw invalidArgument("options are required");
+    const checked = checkConnectRequest({ deweeTxn: opts.deweeTxn, returnTo: opts.returnTo }, opts);
+    if (opts.cspNonce !== undefined && (typeof opts.cspNonce !== "string" || !CSP_NONCE_PATTERN.test(opts.cspNonce))) {
+        throw invalidArgument("cspNonce must be 8 to 256 base64 characters");
+    }
+    const scriptNonce = opts.cspNonce === undefined ? "" : ` nonce="${opts.cspNonce}"`;
+    const assertion = await createAssertion({
+        ...opts.signer,
+        purpose: "handoff",
+        subject: opts.subject,
+        nonce: checked.deweeTxn,
+        ttlSeconds: opts.ttlSeconds,
+    });
+    const action = checked.returnTo;
+    const location = `${action}?${new URLSearchParams({ assertion }).toString()}`;
+    const html = "<!doctype html><html><head><meta charset=\"utf-8\"><meta name=\"referrer\" content=\"no-referrer\">" +
+        "<title>Continuing to Dewee</title></head><body>" +
+        `<form id="dewee-connect" method="post" action="${escapeHtml(action)}">` +
+        `<input type="hidden" name="assertion" value="${escapeHtml(assertion)}">` +
+        "<button type=\"submit\">Continue</button></form>" +
+        `<script${scriptNonce}>document.getElementById("dewee-connect").submit();</script></body></html>`;
+    return { action, method: "POST", fields: { assertion }, html, location };
+}
+const IDEMPOTENCY_KEY_PATTERN = /^[\x21-\x7E]{1,255}$/;
+/**
+ * Starts a web-first link for a signed-in user (`POST /v1/identity/links`): Dewee returns a proof
+ * code the user sends from the chat account to link. The user never types an id; Dewee checks both
+ * sides and links on its own.
+ */
+export async function startLink(opts) {
+    assertServer();
+    if (opts === null || typeof opts !== "object")
+        throw invalidArgument("options are required");
+    if (typeof opts.sessionToken !== "string" || opts.sessionToken === "" || opts.sessionToken.length > 512) {
+        throw invalidArgument("sessionToken is required");
+    }
+    const headers = { [IDENTITY_SESSION_HEADER]: opts.sessionToken };
+    if (opts.idempotencyKey !== undefined) {
+        if (!IDEMPOTENCY_KEY_PATTERN.test(opts.idempotencyKey)) {
+            throw invalidArgument("idempotencyKey must be 1 to 255 printable ASCII characters without spaces");
+        }
+        headers["Idempotency-Key"] = opts.idempotencyKey;
+    }
+    const path = "/v1/identity/links";
+    const { body } = await gatewayRequest(opts, {
+        method: "POST",
+        path,
+        headers,
+        body: { kind: "web_first" },
+    });
+    const expiresAt = new Date(requireString(body, "expires_at", path));
+    if (Number.isNaN(expiresAt.getTime())) {
+        throw new DeweeIdentityError({ code: "INVALID_RESPONSE", message: `INVALID_RESPONSE: ${path} answer has a bad expires_at` });
+    }
+    const targets = Array.isArray(body.deep_links) ? body.deep_links : [];
+    return {
+        transactionId: requireString(body, "transaction_id", path),
+        kind: String(body.kind ?? "web_first"),
+        state: String(body.state ?? ""),
+        proofCode: requireString(body, "proof_code", path),
+        expiresAt,
+        created: body.created !== false,
+        deepLinks: targets
+            .filter((t) => t !== null && typeof t === "object")
+            .map((t) => {
+            const target = {
+                channelType: String(t.channel_type ?? ""),
+                channelInstanceId: String(t.channel_instance_id ?? ""),
+                name: String(t.name ?? ""),
+            };
+            if (typeof t.display_name === "string" && t.display_name !== "")
+                target.displayName = t.display_name;
+            return target;
+        }),
+    };
+}

package/dist/transport.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Refuses to run in a browser. The SDK signs with partner secrets and handles session tokens; both
+ * belong on the partner's server, never in a page.
+ */
+export declare function assertServer(): void;
+/** Options shared by every call that talks to the gateway. */
+export interface GatewayOptions {
+    /** Gateway origin, for example `https://dewee.example.com`. A path prefix is kept. */
+    gatewayUrl: string;
+    /**
+     * Allow plain `http://` to a host that is not loopback, for a private network such as a compose
+     * file. Off by default: credentials then only travel over https (or to localhost).
+     */
+    allowInsecureHttp?: boolean;
+    /** Request timeout in milliseconds (default 10000). */
+    timeoutMs?: number;
+    /** A fetch implementation; defaults to the global fetch. */
+    fetch?: typeof fetch;
+    /** Cancels the request. */
+    signal?: AbortSignal;
+}
+/** Validates a gateway or connect base URL and returns it as origin + path, without a trailing slash. */
+export declare function normalizeBaseUrl(raw: string, name: string, allowInsecureHttp?: boolean): string;
+export interface GatewayRequest {
+    method: "GET" | "POST" | "DELETE";
+    path: string;
+    headers?: Record<string, string>;
+    body?: unknown;
+}
+export interface GatewayResponse<T> {
+    status: number;
+    body: T;
+}
+/**
+ * Sends one request and returns the parsed JSON of a 2xx answer. Any other answer becomes a typed
+ * {@link DeweeIdentityError}. Request headers and bodies are never put in an error.
+ */
+export declare function gatewayRequest<T>(opts: GatewayOptions, req: GatewayRequest): Promise<GatewayResponse<T>>;
+/** Reads a required string field of a gateway answer. */
+export declare function requireString(body: Record<string, unknown>, field: string, path: string): string;

package/dist/transport.js

@@ -0,0 +1,103 @@
+import { DeweeIdentityError, errorFromResponse, invalidArgument } from "./errors.js";
+/**
+ * Refuses to run in a browser. The SDK signs with partner secrets and handles session tokens; both
+ * belong on the partner's server, never in a page.
+ */
+export function assertServer() {
+    if (typeof globalThis.window !== "undefined") {
+        throw new DeweeIdentityError({
+            code: "SERVER_ONLY",
+            message: "@dewee/identity runs on your server only: it holds application secrets. Call your own backend from the browser instead.",
+        });
+    }
+}
+const LOOPBACK_HOSTS = new Set(["localhost", "127.0.0.1", "[::1]", "::1"]);
+const DEFAULT_TIMEOUT_MS = 10_000;
+/** Validates a gateway or connect base URL and returns it as origin + path, without a trailing slash. */
+export function normalizeBaseUrl(raw, name, allowInsecureHttp = false) {
+    if (typeof raw !== "string" || raw.trim() === "") {
+        throw invalidArgument(`${name} is required`);
+    }
+    let url;
+    try {
+        url = new URL(raw.trim());
+    }
+    catch {
+        throw invalidArgument(`${name} must be an absolute URL`);
+    }
+    if (url.username !== "" || url.password !== "") {
+        throw invalidArgument(`${name} must not carry credentials`);
+    }
+    if (url.search !== "" || url.hash !== "") {
+        throw invalidArgument(`${name} must not carry a query or fragment`);
+    }
+    const loopback = LOOPBACK_HOSTS.has(url.hostname);
+    if (url.protocol !== "https:" && !(url.protocol === "http:" && (loopback || allowInsecureHttp))) {
+        throw invalidArgument(`${name} must be https (http only for localhost, or with allowInsecureHttp)`);
+    }
+    return `${url.origin}${url.pathname.replace(/\/+$/, "")}`;
+}
+/**
+ * Sends one request and returns the parsed JSON of a 2xx answer. Any other answer becomes a typed
+ * {@link DeweeIdentityError}. Request headers and bodies are never put in an error.
+ */
+export async function gatewayRequest(opts, req) {
+    const base = normalizeBaseUrl(opts.gatewayUrl, "gatewayUrl", opts.allowInsecureHttp);
+    const url = `${base}${req.path}`;
+    const doFetch = opts.fetch ?? globalThis.fetch;
+    if (typeof doFetch !== "function") {
+        throw invalidArgument("no fetch implementation is available; pass options.fetch");
+    }
+    const timeout = AbortSignal.timeout(opts.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+    const signal = opts.signal ? AbortSignal.any([opts.signal, timeout]) : timeout;
+    const headers = { Accept: "application/json", ...req.headers };
+    let payload;
+    if (req.body !== undefined) {
+        headers["Content-Type"] = "application/json";
+        payload = JSON.stringify(req.body);
+    }
+    let res;
+    try {
+        res = await doFetch(url, { method: req.method, headers, body: payload, signal, redirect: "error" });
+    }
+    catch (cause) {
+        const name = cause instanceof Error ? cause.name : "Error";
+        throw new DeweeIdentityError({
+            code: "TRANSPORT_ERROR",
+            message: `TRANSPORT_ERROR: ${req.method} ${req.path} failed (${name})`,
+            cause,
+        });
+    }
+    const text = await res.text().catch(() => "");
+    let body;
+    if (text !== "") {
+        try {
+            body = JSON.parse(text);
+        }
+        catch {
+            body = undefined;
+        }
+    }
+    if (!res.ok) {
+        throw errorFromResponse(res.status, body, res.headers.get("Retry-After"));
+    }
+    if (body === undefined || body === null || typeof body !== "object") {
+        throw new DeweeIdentityError({
+            code: "INVALID_RESPONSE",
+            status: res.status,
+            message: `INVALID_RESPONSE: ${req.method} ${req.path} answered ${res.status} without a JSON object`,
+        });
+    }
+    return { status: res.status, body: body };
+}
+/** Reads a required string field of a gateway answer. */
+export function requireString(body, field, path) {
+    const v = body[field];
+    if (typeof v !== "string" || v === "") {
+        throw new DeweeIdentityError({
+            code: "INVALID_RESPONSE",
+            message: `INVALID_RESPONSE: ${path} answer has no ${field}`,
+        });
+    }
+    return v;
+}

package/dist/verify-trusted-user.d.ts

@@ -0,0 +1,76 @@
+/** JWS `typ` of the trusted user token Dewee attaches to MCP calls. */
+export declare const TRUSTED_USER_TOKEN_TYPE = "dewee-tuc+jwt";
+/** Longest token lifetime (exp - iat) Dewee issues. */
+export declare const TRUSTED_USER_TOKEN_TTL_SECONDS = 60;
+/** How far ahead of this server's clock a token's iat may lie. */
+export declare const TRUSTED_USER_CLOCK_SKEW_SECONDS = 5;
+/** Issuer prefix of a gateway without a public URL: `urn:dewee:tenant:<tenant id>`. */
+export declare const TRUSTED_USER_ISSUER_PREFIX = "urn:dewee:tenant:";
+/** The verified user of one MCP call. */
+export interface TrustedUser {
+    /** Your stable user id (the `sub` your assertions carried). */
+    subject: string;
+    principalId: string;
+    tenantId: string;
+    applicationId: string;
+    grantVersion: number;
+    authnLevel: string;
+    verificationMethod: string;
+    scopes: string[];
+    issuer: string;
+    /** The MCP server id the token was minted for. */
+    audience: string;
+    issuedAt: Date;
+    expiresAt: Date;
+    jti: string;
+}
+/**
+ * Remembers accepted token ids until they expire, so a captured token cannot be replayed. Use a
+ * shared store (Redis `SET NX EX`, a database row) when your MCP server runs more than one
+ * process.
+ */
+export interface ReplayGuard {
+    /** Records `jti` until `expiresAt` (unix seconds). Returns false when it was already recorded. */
+    claim(jti: string, expiresAt: number, now: number): boolean | Promise<boolean>;
+}
+/** In-process {@link ReplayGuard}. Refuses (fails closed) when full of unexpired ids. */
+export declare class MemoryReplayGuard implements ReplayGuard {
+    private readonly maxEntries;
+    private readonly seen;
+    constructor(maxEntries?: number);
+    claim(jti: string, expiresAt: number, now: number): boolean;
+    get size(): number;
+}
+/**
+ * What your MCP server expects of a token. Every field is required: a check that leaves the issuer,
+ * tenant or application out is refused rather than letting that claim go unchecked.
+ */
+export interface VerifyTrustedUserOptions {
+    /** The application's MCP context secret (shown once by `dewee identity setup`). */
+    mcpContextSecret: string;
+    /** The id of this MCP server in Dewee; tokens for any other server are refused. */
+    serverId: string;
+    /** The gateway's issuer: its public URL without a trailing slash, or `urn:dewee:tenant:<tenant id>`. */
+    issuer: string;
+    /** The tenant your application belongs to. */
+    tenantId: string;
+    /** Your Dewee application id. */
+    applicationId: string;
+    /** Replay protection; defaults to one in-process guard shared by every call. */
+    replayGuard?: ReplayGuard;
+    /** Clock override, for tests. */
+    now?: Date;
+}
+/** Where a trusted user token travels: `params._meta.dewee.trusted_user`. */
+export declare function extractTrustedUserToken(meta: unknown): string | undefined;
+/**
+ * Verifies the trusted user token of one MCP call, as `identity.VerifyTrustedUserToken` does in the
+ * gateway: HS256 only, `typ` `dewee-tuc+jwt`, the signature, `aud` = this server, the pinned `iss`,
+ * `tenant_id` and `application_id`, an `iat` at most 5 s ahead, a lifetime of at most 60 s that has
+ * not ended, a subject and principal, and a `jti` accepted only once.
+ *
+ * Accepts `params._meta`, the whole `params`, or the token itself. Any refusal is a
+ * {@link DeweeIdentityError} with code `IDENTITY_REQUIRED` and a bounded `reason`; answer the call
+ * with an error and never fall back to an argument or header naming a user.
+ */
+export declare function verifyTrustedUser(meta: unknown, opts: VerifyTrustedUserOptions): Promise<TrustedUser>;

package/dist/verify-trusted-user.js

@@ -0,0 +1,173 @@
+import { compactVerify, decodeProtectedHeader } from "jose";
+import { MIN_SECRET_LENGTH, requireUuid } from "./assertion.js";
+import { DeweeIdentityError, invalidArgument } from "./errors.js";
+import { assertServer } from "./transport.js";
+/** JWS `typ` of the trusted user token Dewee attaches to MCP calls. */
+export const TRUSTED_USER_TOKEN_TYPE = "dewee-tuc+jwt";
+/** Longest token lifetime (exp - iat) Dewee issues. */
+export const TRUSTED_USER_TOKEN_TTL_SECONDS = 60;
+/** How far ahead of this server's clock a token's iat may lie. */
+export const TRUSTED_USER_CLOCK_SKEW_SECONDS = 5;
+/** Issuer prefix of a gateway without a public URL: `urn:dewee:tenant:<tenant id>`. */
+export const TRUSTED_USER_ISSUER_PREFIX = "urn:dewee:tenant:";
+const MAX_TOKEN_LENGTH = 8 * 1024;
+/** In-process {@link ReplayGuard}. Refuses (fails closed) when full of unexpired ids. */
+export class MemoryReplayGuard {
+    maxEntries;
+    seen = new Map();
+    constructor(maxEntries = 100_000) {
+        this.maxEntries = maxEntries;
+        if (!Number.isInteger(maxEntries) || maxEntries < 1)
+            throw invalidArgument("maxEntries must be a positive integer");
+    }
+    claim(jti, expiresAt, now) {
+        const until = this.seen.get(jti);
+        if (until !== undefined && until > now)
+            return false;
+        if (this.seen.size >= this.maxEntries) {
+            for (const [id, exp] of this.seen) {
+                if (exp <= now)
+                    this.seen.delete(id);
+            }
+            if (this.seen.size >= this.maxEntries)
+                return false;
+        }
+        this.seen.set(jti, expiresAt);
+        return true;
+    }
+    get size() {
+        return this.seen.size;
+    }
+}
+const defaultReplayGuard = new MemoryReplayGuard();
+/** Where a trusted user token travels: `params._meta.dewee.trusted_user`. */
+export function extractTrustedUserToken(meta) {
+    if (typeof meta === "string")
+        return meta;
+    if (meta === null || typeof meta !== "object")
+        return undefined;
+    const m = meta;
+    const inner = m._meta !== null && typeof m._meta === "object" ? m._meta : m;
+    const dewee = inner.dewee;
+    if (dewee === null || typeof dewee !== "object")
+        return undefined;
+    const token = dewee.trusted_user;
+    return typeof token === "string" ? token : undefined;
+}
+function refuse(reason) {
+    return new DeweeIdentityError({
+        code: "IDENTITY_REQUIRED",
+        status: 401,
+        reason,
+        message: `IDENTITY_REQUIRED: trusted user token refused (${reason})`,
+        remediation: { action: "send_connect_link", audience: "end_user" },
+    });
+}
+function nonEmpty(value, name) {
+    if (typeof value !== "string" || value.trim() === "") {
+        throw invalidArgument(`${name} is required: a trusted user check must name the server, issuer, tenant and application`);
+    }
+    return value;
+}
+/**
+ * Verifies the trusted user token of one MCP call, as `identity.VerifyTrustedUserToken` does in the
+ * gateway: HS256 only, `typ` `dewee-tuc+jwt`, the signature, `aud` = this server, the pinned `iss`,
+ * `tenant_id` and `application_id`, an `iat` at most 5 s ahead, a lifetime of at most 60 s that has
+ * not ended, a subject and principal, and a `jti` accepted only once.
+ *
+ * Accepts `params._meta`, the whole `params`, or the token itself. Any refusal is a
+ * {@link DeweeIdentityError} with code `IDENTITY_REQUIRED` and a bounded `reason`; answer the call
+ * with an error and never fall back to an argument or header naming a user.
+ */
+export async function verifyTrustedUser(meta, opts) {
+    assertServer();
+    if (opts === null || typeof opts !== "object")
+        throw invalidArgument("options are required");
+    const secret = nonEmpty(opts.mcpContextSecret, "mcpContextSecret");
+    const key = new TextEncoder().encode(secret);
+    if (key.length < MIN_SECRET_LENGTH) {
+        throw invalidArgument(`mcpContextSecret must be at least ${MIN_SECRET_LENGTH} bytes`);
+    }
+    const serverId = nonEmpty(opts.serverId, "serverId");
+    const issuer = nonEmpty(opts.issuer, "issuer");
+    const tenantId = requireUuid(nonEmpty(opts.tenantId, "tenantId"), "tenantId");
+    const applicationId = requireUuid(nonEmpty(opts.applicationId, "applicationId"), "applicationId");
+    const guard = opts.replayGuard ?? defaultReplayGuard;
+    const token = extractTrustedUserToken(meta);
+    if (token === undefined || token === "")
+        throw refuse("missing");
+    if (token.length > MAX_TOKEN_LENGTH || token.split(".").length !== 3)
+        throw refuse("malformed");
+    let header;
+    try {
+        header = decodeProtectedHeader(token);
+    }
+    catch {
+        throw refuse("malformed");
+    }
+    if (header.alg !== "HS256")
+        throw refuse("algorithm");
+    if (header.typ !== TRUSTED_USER_TOKEN_TYPE)
+        throw refuse("type");
+    let payload;
+    try {
+        ({ payload } = await compactVerify(token, key, { algorithms: ["HS256"] }));
+    }
+    catch {
+        throw refuse("signature");
+    }
+    let c;
+    try {
+        const parsed = JSON.parse(new TextDecoder().decode(payload));
+        if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+            throw new Error("not an object");
+        c = parsed;
+    }
+    catch {
+        throw refuse("malformed");
+    }
+    const str = (k) => (typeof c[k] === "string" ? c[k] : "");
+    const int = (k) => (Number.isSafeInteger(c[k]) ? c[k] : undefined);
+    const iat = int("iat");
+    const exp = int("exp");
+    if (iat === undefined || exp === undefined)
+        throw refuse("malformed");
+    const now = Math.floor((opts.now ?? new Date()).getTime() / 1000);
+    if (str("aud") === "" || str("aud") !== serverId)
+        throw refuse("audience");
+    if (str("iss") !== issuer)
+        throw refuse("issuer");
+    if (str("tenant_id") !== tenantId)
+        throw refuse("tenant");
+    if (str("application_id") !== applicationId)
+        throw refuse("application");
+    if (iat > now + TRUSTED_USER_CLOCK_SKEW_SECONDS)
+        throw refuse("not_yet_valid");
+    if (exp <= iat || exp - iat > TRUSTED_USER_TOKEN_TTL_SECONDS)
+        throw refuse("lifetime");
+    if (now >= exp)
+        throw refuse("expired");
+    if (str("sub").trim() === "" || str("principal_id") === "")
+        throw refuse("subject");
+    const jti = str("jti");
+    if (jti === "")
+        throw refuse("jti");
+    if (!(await guard.claim(`${applicationId}:${jti}`, exp, now)))
+        throw refuse("replay");
+    const scopes = Array.isArray(c.scopes) ? c.scopes.filter((s) => typeof s === "string") : [];
+    return {
+        subject: str("sub"),
+        principalId: str("principal_id"),
+        tenantId,
+        applicationId,
+        grantVersion: int("grant_version") ?? 0,
+        authnLevel: str("authn_level"),
+        verificationMethod: str("verification_method"),
+        scopes,
+        issuer,
+        audience: serverId,
+        issuedAt: new Date(iat * 1000),
+        expiresAt: new Date(exp * 1000),
+        jti,
+    };
+}

package/package.json

@@ -1,6 +1,55 @@
 {
   "name": "@dewee/identity",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0-beta.1",
+  "description": "Server SDK for Dewee Connect: partner assertions, identity session exchange and trusted user verification for MCP servers.",
+  "license": "CC-BY-NC-4.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nextlevelbuilder/dewee.git",
+    "directory": "packages/dewee-identity"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=20.3"
+  },
+  "exports": {
+    "./browser": {
+      "types": "./dist/browser.d.ts",
+      "import": "./dist/browser.js"
+    },
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "tag": "beta"
+  },
+  "scripts": {
+    "build": "node scripts/clean-dist.mjs && tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "lint": "pnpm run build && publint --strict",
+    "test": "vitest run",
+    "test:integration": "vitest run --config vitest.integration.config.ts",
+    "fixtures:generate": "pnpm run build && node scripts/generate-fixtures.mjs",
+    "prepack": "pnpm run build"
+  },
+  "dependencies": {
+    "jose": "^6.2.13"
+  },
+  "devDependencies": {
+    "@types/node": "^24.13.3",
+    "publint": "^0.3.25",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.9"
+  }
+}