@zenera/server 0.0.0-stage → 1.2.1

package/README.md

@@ -1,3 +1,158 @@
-# Temporary Holding Version
+<div align="center">
+  <img
+    src="https://raw.githubusercontent.com/zenera-ai/ZeneraNeo/main/docs/imgs/zenera-logo-with-media-queries.svg"
+    alt="Zenera"
+    width="24"
+  />
+  <div>Powered By Zenera</div>
+  <br>
+  <img
+    src="https://raw.githubusercontent.com/zenera-ai/ZeneraNeo/main/docs/imgs/banner-server-with-media-queries.svg"
+    alt="ZENERA SERVER"
+    width="918"
+  />
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![npm](https://img.shields.io/npm/v/@zenera/server.svg)](https://www.npmjs.com/package/@zenera/server)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/zenera-ai/ZeneraNeo/blob/main/LICENSE)
+[![Node](https://img.shields.io/badge/node-%E2%89%A524-brightgreen.svg)](https://nodejs.org)
+
+[Quickstart](#quickstart) · [Secure setup](#secure-setup) · [Commands](#commands) · [Options](#common-options) · [HTTP API](#http-api)
+
+</div>
+
+# `@zenera/server`
+
+Serve a ZeneraNeo project's chats over HTTP. Each user has private sessions and
+memory; agent commands run in Podman sandboxes, or under bwrap in an agent container.
+Requires Node.js 24+ and the [Zenera CLI](../cli/README.md).
+
+## Quickstart
+
+From a configured project:
+
+```sh
+zen server start --insecure --user ann
+```
+
+Open the printed HTTP `/chat` link to list sessions, send messages, follow active
+runs, cancel them, or delete a session. `--user` selects the development JWT's
+subject, not a server-wide user. The default is `local`.
+
+**Insecure mode is for local testing only:** anyone who can reach the server can
+impersonate any user. API requests still need a JWT, but signatures are not checked.
+The test page is available only in this mode. Its token stays in memory; after a
+reload, reopen the printed link or enter a development token again.
+
+To run the server in the project's agent image:
+
+```sh
+zen server start --container --insecure --user ann
+zen server start --container --insecure --user ann --verbose # full build logs
+```
+
+Podman builds and caches the image. Default build output shows a spinner, elapsed
+time, and the latest line; warnings remain visible. Use `--rebuild` to rebuild.
+Press Ctrl+C to stop gracefully and save active runs.
+
+## Secure setup
+
+A trusted caller, usually Zenera-app, authenticates users, checks project access,
+and signs a short-lived JWT for each runtime request. The runtime holds **only
+the public key**.
+
+For a standalone caller, generate an Ed25519 pair outside the project directory:
+
+```sh
+zen server keygen --out "$HOME/runtime-auth"
+zen server start --jwt-public-key "$HOME/runtime-auth.public.pem"
+```
+
+`keygen` creates `<prefix>.private.pem` (PKCS#8, owner-only `0600` permissions)
+and `<prefix>.public.pem` (SPKI). The parent directory must already exist.
+Existing files are never overwritten; a failed write removes newly created files.
+Keep the private key with the trusted caller, out of source control and runtime
+containers. Zenera-app already manages its own signing identity; it does not need
+this command.
+
+Generating keys does **not** sign requests. Secure callers send an
+`Authorization: Bearer <jwt>` header containing an EdDSA-signed token with:
+
+- `iss` / `aud`: defaults `zenera-app` / `zenera-runtime`.
+- `sub`: the authenticated user; `prj`: this server's project ID.
+- `req`: the exact `"<METHOD> <path-and-query>"` of the request.
+- `iat` / `exp`: issue time and expiry; maximum age 2 minutes, 30 seconds clock tolerance.
+
+Use HTTPS at the ingress or a protected internal connection. A token cannot
+authorize a different endpoint, but can be replayed for the same request until
+it expires. The server does not perform user login or project-membership checks.
+
+## Commands
+
+| Command                            | Use                                                             |
+| ---------------------------------- | --------------------------------------------------------------- |
+| `zen server start`                 | Start a project's runtime.                                      |
+| `zen server check`                 | Check whether it can start in the current environment.          |
+| `zen server status`                | Inspect a running runtime; use `--token <jwt>` for secure mode. |
+| `zen server keygen --out <prefix>` | Generate private/public signing keys.                           |
+| `zen server token --user <id>`     | Print an **unsigned** development JWT for insecure mode.        |
+
+Test an API without the browser:
+
+```sh
+TOKEN=$(zen server token --user ann)
+curl http://127.0.0.1:3000/api/sessions \
+  -H "Authorization: Bearer $TOKEN"
+```
+
+`token` also accepts `--email`, `--role`, `--name`, and `--thread`. It neither
+creates an account nor signs a secure token.
+
+## Common options
+
+| Option                            | Use / default                                                          |
+| --------------------------------- | ---------------------------------------------------------------------- |
+| `--project <name-or-dir>`         | Select a project; otherwise use the current project.                   |
+| `--port <n>` / `--host <addr>`    | `3000` / `127.0.0.1`. Insecure mode is loopback-only.                  |
+| `--root <dir>`                    | Persistent user state; `~/.zenera/neo/servers/<project>` on the host.  |
+| `--memory-seed <dir>`             | Initial memory for new users; defaults to project memory.              |
+| `--no-memory-seed`                | Start new users with empty memory.                                     |
+| `--jwt-public-key <file>`         | Public PEM for secure mode; alternatively `ZEN_SERVER_JWT_PUBLIC_KEY`. |
+| `--jwt-issuer` / `--jwt-audience` | Override the expected signer / audience.                               |
+| `--container`                     | Run the server in the project image; commands use bwrap.               |
+| `--verbose` / `--rebuild`         | Full container build logs / rebuild images.                            |
+| `--debug`                         | Enable run, trace, and memory inspection routes.                       |
+
+Run `zen server --help` for all options. Sessions and memory live under
+`<root>/users/<user>/`; memory is private per user and shared across their sessions.
+New users receive the memory seed captured at startup. Existing user memory is
+never replaced by a restart.
+
+Model credentials come from `zen key`, the environment, and the project's `.env`.
+Container mode forwards provider settings, including Vertex and Bifrost, and
+credential files. The gateway must be reachable from the container; host
+`localhost` is not container `localhost`.
+Set `sandbox.keys: false` to withhold credentials from agent-written commands,
+while allowing the engine to use them for model calls.
+
+## HTTP API
+
+Session routes operate only on the JWT subject's own sessions.
+
+| Route                                          | Use                                            |
+| ---------------------------------------------- | ---------------------------------------------- |
+| `GET /healthz`                                 | Public health probe.                           |
+| `GET /chat`                                    | Public test page, insecure mode only.          |
+| `GET /api/status` / `GET /api/activity`        | Runtime status / active runs.                  |
+| `GET /api/sessions` / `GET /api/sessions/:tid` | List sessions / load history.                  |
+| `POST /api/sessions/:tid/runs`                 | Start a turn, streaming AG-UI events over SSE. |
+| `GET /api/sessions/:tid/runs/:runId/events`    | Follow or replay a run.                        |
+| `POST /api/sessions/:tid/runs/:runId/cancel`   | Cancel a run.                                  |
+| `DELETE /api/sessions/:tid`                    | Delete a session and its files.                |
+
+Runs continue after a client disconnects and can be followed again. Defaults:
+4 concurrent runs total, 2 per user (`ZEN_RUNTIME_MAX_RUNS`,
+`ZEN_RUNTIME_MAX_USER_RUNS`).
+
+For deployment and sandbox details, see [agent-image architecture](../../docs/agent-image.md).
+To rebuild the bundled test page, run `npm run build:chat` from ZeneraLite's root;
+it automatically copies the page into a sibling ZeneraNeo checkout when present.

package/dist/agui.d.ts

@@ -0,0 +1,29 @@
+import { type AGUIEvent, type Interrupt, type TokenUsage as AguiUsage, type RunAgentInput } from '@ag-ui/core';
+import type { AgentEvent, AgentState, Payload, TokenUsage } from '@zenera/neo';
+export declare const MAX_TOOL_OUTPUT = 8000;
+export declare function clip(text: string, max?: number): string;
+export type Resolve = (payload: Payload) => Promise<string>;
+/**
+ * The calls a suspended run waits on, as AG-UI interrupts. The id is zenera-app's interrupt id
+ * when the tool got one (it resumes the run by it), else the call id; `toolCallId` ties it to the
+ * tool card; `metadata` is what the tool said about it (server, icon, ...), for that card.
+ */
+export declare function interruptsOf(state: AgentState): Interrupt[];
+export interface TranslatorOptions {
+    threadId: string;
+    runId: string;
+    resolve: Resolve;
+    newId?: () => string;
+}
+export declare class AguiTranslator {
+    #private;
+    constructor(opts: TranslatorOptions);
+    get done(): boolean;
+    /** The run's input goes with it: a replayed run then shows what it answered. */
+    started(input?: RunAgentInput): AGUIEvent[];
+    translate(ev: AgentEvent): Promise<AGUIEvent[]>;
+    /** The end of a run that stopped without a run_finished: an exception or a cancel. */
+    fail(err: unknown, code?: string): AGUIEvent[];
+}
+export declare function toAguiUsage(u: TokenUsage): AguiUsage;
+//# sourceMappingURL=agui.d.ts.map

package/dist/agui.js

@@ -0,0 +1,333 @@
+// AG-UI for a @zenera/neo run. neo streams bare deltas plus a checkpoint per model call, tool
+// call, hand-off and branch; AG-UI wants every text, reasoning and tool-call stream opened and
+// closed around them. One translator per run keeps that bookkeeping, per branch.
+//   AguiTranslator  - neo AgentEvent -> AG-UI events, in order (await each call before the next)
+//   clip            - the cap on tool output sent to a browser
+//   interruptsOf    - what a suspended run waits for, as AG-UI interrupts (RUN_FINISHED outcome)
+import { EventType, } from '@ag-ui/core';
+import { randomUUID } from 'node:crypto';
+export const MAX_TOOL_OUTPUT = 8000;
+export function clip(text, max = MAX_TOOL_OUTPUT) {
+    return text.length > max
+        ? `${text.slice(0, max)}\n… ${text.length - max} more characters`
+        : text;
+}
+/**
+ * The calls a suspended run waits on, as AG-UI interrupts. The id is zenera-app's interrupt id
+ * when the tool got one (it resumes the run by it), else the call id; `toolCallId` ties it to the
+ * tool card; `metadata` is what the tool said about it (server, icon, ...), for that card.
+ */
+export function interruptsOf(state) {
+    // `suspended` is newer than some @zenera/neo typings this compiles against.
+    const suspended = state.suspended ?? [];
+    return suspended.map((raw) => {
+        const s = raw;
+        const data = s.data && typeof s.data === 'object' ? s.data : undefined;
+        return {
+            id: typeof data?.interruptId === 'string' ? data.interruptId : s.callId,
+            reason: s.reason,
+            ...(s.message ? { message: s.message } : {}),
+            toolCallId: s.callId,
+            ...(s.responseSchema ? { responseSchema: s.responseSchema } : {}),
+            ...(data ? { metadata: data } : {}),
+        };
+    });
+}
+export class AguiTranslator {
+    #threadId;
+    #runId;
+    #resolve;
+    #newId;
+    #lanes = new Map();
+    // fork node id -> the tool call that asked for it
+    #forks = new Map();
+    #agent;
+    #done = false;
+    constructor(opts) {
+        this.#threadId = opts.threadId;
+        this.#runId = opts.runId;
+        this.#resolve = opts.resolve;
+        this.#newId = opts.newId ?? randomUUID;
+    }
+    get done() {
+        return this.#done;
+    }
+    /** The run's input goes with it: a replayed run then shows what it answered. */
+    started(input) {
+        return [
+            {
+                type: EventType.RUN_STARTED,
+                threadId: this.#threadId,
+                runId: this.#runId,
+                ...(input ? { input } : {}),
+            },
+        ];
+    }
+    async translate(ev) {
+        if (this.#done)
+            return [];
+        const out = [];
+        const lane = this.#lane(ev.branch?.runId);
+        const sub = lane.subagentRunId ? { subagentRunId: lane.subagentRunId } : {};
+        // A continued session sends no run_created, so the first trunk event opens the step.
+        if (!ev.branch && !this.#agent) {
+            this.#agent = ev.agent;
+            out.push({ type: EventType.STEP_STARTED, stepName: ev.agent });
+        }
+        switch (ev.type) {
+            case 'thinking_delta': {
+                if (!ev.delta)
+                    break;
+                this.#endText(lane, out);
+                if (!lane.reasoning) {
+                    lane.reasoning = this.#newId();
+                    out.push({ type: EventType.REASONING_START, messageId: lane.reasoning, ...sub }, {
+                        type: EventType.REASONING_MESSAGE_START,
+                        messageId: lane.reasoning,
+                        role: 'reasoning',
+                        ...sub,
+                    });
+                }
+                out.push({
+                    type: EventType.REASONING_MESSAGE_CONTENT,
+                    messageId: lane.reasoning,
+                    delta: ev.delta,
+                    ...sub,
+                });
+                break;
+            }
+            case 'text_delta':
+                if (!ev.delta)
+                    break;
+                this.#endReasoning(lane, out);
+                this.#text(lane, ev.agent, ev.delta, out);
+                lane.streamedText = true;
+                break;
+            case 'tool_call_detected':
+                this.#endReasoning(lane, out);
+                this.#startTool(lane, ev.callId, ev.name, out);
+                break;
+            case 'tool_args_delta':
+                if (!lane.tools.has(ev.callId))
+                    this.#startTool(lane, ev.callId, ev.name, out);
+                if (ev.delta) {
+                    out.push({
+                        type: EventType.TOOL_CALL_ARGS,
+                        toolCallId: ev.callId,
+                        delta: ev.delta,
+                        ...sub,
+                    });
+                }
+                break;
+            case 'before_llm_call':
+                lane.streamedText = false;
+                lane.tools.clear();
+                break;
+            case 'after_llm_call': {
+                this.#endReasoning(lane, out);
+                // A model that does not stream says everything here, at once.
+                if (!lane.streamedText) {
+                    const text = await this.#resolve(ev.node.text);
+                    if (text.trim())
+                        this.#text(lane, ev.agent, text, out);
+                }
+                this.#endText(lane, out, { model: ev.node.model, usage: ev.node.usage });
+                for (const call of ev.node.toolCalls) {
+                    if (!lane.tools.has(call.callId)) {
+                        this.#startTool(lane, call.callId, call.name, out);
+                        const args = await this.#resolve(call.args);
+                        if (args) {
+                            out.push({
+                                type: EventType.TOOL_CALL_ARGS,
+                                toolCallId: call.callId,
+                                delta: args,
+                                ...sub,
+                            });
+                        }
+                    }
+                    out.push({ type: EventType.TOOL_CALL_END, toolCallId: call.callId, ...sub });
+                }
+                lane.tools.clear();
+                break;
+            }
+            case 'after_tool_call': {
+                const content = clip(await this.#resolve(ev.node.result));
+                out.push({
+                    type: EventType.TOOL_CALL_RESULT,
+                    messageId: this.#newId(),
+                    toolCallId: ev.node.callId,
+                    content,
+                    role: 'tool',
+                    ...sub,
+                    ...(ev.node.isError ? { metadata: { isError: true } } : {}),
+                });
+                break;
+            }
+            case 'handoff':
+                this.#endReasoning(lane, out);
+                this.#endText(lane, out);
+                out.push({ type: EventType.STEP_FINISHED, stepName: ev.from, ...sub }, { type: EventType.STEP_STARTED, stepName: ev.to, ...sub });
+                if (!ev.branch)
+                    this.#agent = ev.to;
+                break;
+            case 'before_fork':
+                this.#forks.set(ev.node.id, ev.node.callId);
+                break;
+            case 'branch_started': {
+                const parentToolCallId = this.#forks.get(ev.child.forkId);
+                out.push({
+                    type: EventType.SUBAGENT_STARTED,
+                    subagentRunId: ev.child.runId,
+                    name: ev.child.name,
+                    description: ev.childState.agentName,
+                    ...(lane.subagentRunId ? { parentSubagentRunId: lane.subagentRunId } : {}),
+                    ...(parentToolCallId ? { parentToolCallId } : {}),
+                });
+                break;
+            }
+            case 'branch_finished': {
+                const child = this.#lane(ev.child.runId);
+                this.#endReasoning(child, out);
+                this.#endText(child, out);
+                this.#lanes.delete(ev.child.runId);
+                if (ev.status === 'ok') {
+                    out.push({ type: EventType.SUBAGENT_FINISHED, subagentRunId: ev.child.runId });
+                }
+                else {
+                    out.push({
+                        type: EventType.SUBAGENT_ERROR,
+                        subagentRunId: ev.child.runId,
+                        message: ev.childState.error ?? `branch ${ev.child.name} ${ev.status}`,
+                        code: ev.status,
+                    });
+                }
+                break;
+            }
+            case 'run_finished':
+                // A branch's own end is reported by branch_finished on its parent.
+                if (!ev.branch)
+                    out.push(...this.#finish(ev.result));
+                break;
+            default:
+                break;
+        }
+        return out;
+    }
+    /** The end of a run that stopped without a run_finished: an exception or a cancel. */
+    fail(err, code = 'error') {
+        if (this.#done)
+            return [];
+        const out = this.#closeAll();
+        this.#done = true;
+        if (this.#agent)
+            out.push({ type: EventType.STEP_FINISHED, stepName: this.#agent });
+        const message = err instanceof Error ? err.message : String(err);
+        out.push({ type: EventType.RUN_ERROR, message, code });
+        return out;
+    }
+    #finish(result) {
+        const out = this.#closeAll();
+        this.#done = true;
+        if (this.#agent)
+            out.push({ type: EventType.STEP_FINISHED, stepName: this.#agent });
+        const usage = [toAguiUsage(result.usage)];
+        if (result.stopReason === 'failed') {
+            out.push({
+                type: EventType.RUN_ERROR,
+                message: result.state.error ?? 'the run failed',
+                code: 'failed',
+                usage,
+            });
+            return out;
+        }
+        out.push({
+            type: EventType.RUN_FINISHED,
+            threadId: this.#threadId,
+            runId: this.#runId,
+            outcome: result.stopReason === 'aborted'
+                ? { type: 'cancelled' }
+                : // 'suspended' is newer than some @zenera/neo typings this compiles against.
+                    result.stopReason === 'suspended'
+                        ? { type: 'interrupt', interrupts: interruptsOf(result.state) }
+                        : { type: 'success' },
+            result: { agent: result.agent },
+            usage,
+        });
+        return out;
+    }
+    #closeAll() {
+        const out = [];
+        for (const lane of this.#lanes.values()) {
+            this.#endReasoning(lane, out);
+            this.#endText(lane, out);
+            const sub = lane.subagentRunId ? { subagentRunId: lane.subagentRunId } : {};
+            for (const callId of lane.tools.keys()) {
+                out.push({ type: EventType.TOOL_CALL_END, toolCallId: callId, ...sub });
+            }
+            lane.tools.clear();
+        }
+        return out;
+    }
+    #lane(subagentRunId) {
+        const key = subagentRunId ?? '';
+        let lane = this.#lanes.get(key);
+        if (!lane) {
+            lane = { subagentRunId, streamedText: false, tools: new Map() };
+            this.#lanes.set(key, lane);
+        }
+        return lane;
+    }
+    #text(lane, agent, delta, out) {
+        const sub = lane.subagentRunId ? { subagentRunId: lane.subagentRunId } : {};
+        if (!lane.text) {
+            lane.text = this.#newId();
+            out.push({
+                type: EventType.TEXT_MESSAGE_START,
+                messageId: lane.text,
+                role: 'assistant',
+                name: agent,
+                ...sub,
+            });
+        }
+        out.push({ type: EventType.TEXT_MESSAGE_CONTENT, messageId: lane.text, delta, ...sub });
+    }
+    #endText(lane, out, call) {
+        if (!lane.text)
+            return;
+        const sub = lane.subagentRunId ? { subagentRunId: lane.subagentRunId } : {};
+        out.push({
+            type: EventType.TEXT_MESSAGE_END,
+            messageId: lane.text,
+            ...sub,
+            ...(call ? { metadata: { model: call.model, usage: toAguiUsage(call.usage) } } : {}),
+        });
+        lane.text = undefined;
+    }
+    #endReasoning(lane, out) {
+        if (!lane.reasoning)
+            return;
+        const sub = lane.subagentRunId ? { subagentRunId: lane.subagentRunId } : {};
+        out.push({ type: EventType.REASONING_MESSAGE_END, messageId: lane.reasoning, ...sub }, { type: EventType.REASONING_END, messageId: lane.reasoning, ...sub });
+        lane.reasoning = undefined;
+    }
+    #startTool(lane, callId, name, out) {
+        lane.tools.set(callId, { name });
+        out.push({
+            type: EventType.TOOL_CALL_START,
+            toolCallId: callId,
+            toolCallName: name,
+            ...(lane.text ? { parentMessageId: lane.text } : {}),
+            ...(lane.subagentRunId ? { subagentRunId: lane.subagentRunId } : {}),
+        });
+    }
+}
+export function toAguiUsage(u) {
+    return {
+        inputTokens: u.inputTokens,
+        outputTokens: u.outputTokens,
+        totalTokens: u.inputTokens + u.outputTokens,
+        reasoningTokens: u.reasoningTokens,
+        cachedInputTokens: u.cachedInputTokens,
+    };
+}
+//# sourceMappingURL=agui.js.map

package/dist/auth.d.ts

@@ -0,0 +1,16 @@
+import type { NextFunction, Request, Response } from 'express';
+import { type JWTPayload } from 'jose';
+export interface CallerClaims extends JWTPayload {
+    sub: string;
+    prj?: string;
+    req?: string;
+    thr?: string;
+    role?: string;
+    email?: string;
+    name?: string;
+}
+export declare function verifyCaller(req: Request): Promise<CallerClaims>;
+export declare function requireCaller(): (req: Request, res: Response, next: NextFunction) => Promise<void>;
+/** A token an `insecure` server takes: the claims, no signature. */
+export declare function unsignedToken(claims: Record<string, unknown>): string;
+//# sourceMappingURL=auth.d.ts.map

package/dist/auth.js

@@ -0,0 +1,79 @@
+import { decodeJwt, importSPKI, jwtVerify } from 'jose';
+import { settings } from "./config.js";
+import { HttpError } from "./http.js";
+const OPEN = new Set(['/healthz']);
+let key;
+function publicKey(pem) {
+    if (key?.pem !== pem)
+        key = { pem, key: importSPKI(pem, 'EdDSA') };
+    return key.key;
+}
+function bearer(req) {
+    const header = req.get('authorization') ?? '';
+    if (!header.startsWith('Bearer '))
+        throw new HttpError(401, 'no caller token');
+    return header.slice('Bearer '.length).trim();
+}
+export async function verifyCaller(req) {
+    const s = settings();
+    const token = bearer(req);
+    let payload;
+    if (s.auth.mode === 'insecure') {
+        try {
+            payload = decodeJwt(token);
+        }
+        catch (err) {
+            throw new HttpError(401, `not a token: ${err instanceof Error ? err.message : err}`);
+        }
+    }
+    else {
+        let verifyKey;
+        try {
+            verifyKey = await publicKey(s.auth.publicKey);
+        }
+        catch (err) {
+            throw new HttpError(503, `the server's public key is not an Ed25519 key: ${err}`);
+        }
+        try {
+            ({ payload } = await jwtVerify(token, verifyKey, {
+                algorithms: ['EdDSA'],
+                issuer: s.auth.issuer,
+                audience: s.auth.audience,
+                requiredClaims: ['sub', 'iat', 'exp'],
+                clockTolerance: 30,
+                maxTokenAge: '2m',
+            }));
+        }
+        catch (err) {
+            throw new HttpError(401, `invalid caller token: ${err instanceof Error ? err.message : err}`);
+        }
+        if (payload.prj !== s.projectId) {
+            throw new HttpError(403, 'the token is for another project');
+        }
+        // Bound to one request: a token seen in transit is no good for any other.
+        if (payload.req !== `${req.method} ${req.originalUrl}`) {
+            throw new HttpError(401, 'the token is for another request');
+        }
+    }
+    if (typeof payload.sub !== 'string' || !payload.sub.trim()) {
+        throw new HttpError(401, 'the token names no user (sub)');
+    }
+    return payload;
+}
+export function requireCaller() {
+    return async (req, res, next) => {
+        if (OPEN.has(req.path)) {
+            next();
+            return;
+        }
+        res.locals.caller = await verifyCaller(req);
+        next();
+    };
+}
+/** A token an `insecure` server takes: the claims, no signature. */
+export function unsignedToken(claims) {
+    const part = (v) => Buffer.from(JSON.stringify(v)).toString('base64url');
+    const now = Math.floor(Date.now() / 1000);
+    return `${part({ alg: 'none', typ: 'JWT' })}.${part({ iat: now, ...claims })}.`;
+}
+//# sourceMappingURL=auth.js.map