@rine-network/eve 0.1.0

package/dist/inbound.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Inbound webhook helpers for the rine channel: extracting the message id from a
+ * rine standard-webhook body, and the continuation-token codec.
+ *
+ * The continuation token is how the channel makes outbound replies STATELESS (R7):
+ * it encodes the rine `conversation_id`, the reply target (the group handle for
+ * group mail, else the sender handle), and — for 1:1 inbound only — the inbound
+ * `message id` so the `message.completed` handler can reply IN-PLACE (via the reply
+ * endpoint, preserving the inbound conversation) without any durable per-session map.
+ * Because the token bakes in the per-message `m`, it differs on every 1:1 inbound
+ * turn, so Eve does NOT resume a prior session from it — cross-turn continuity comes
+ * from the general thread primitive (push-injected transcript, Slice E), not session
+ * resume. The message id is optional: group inbound and tokens minted by an older
+ * build carry only `{c,r}` and decode with `messageId === undefined`, so the outbound
+ * handler falls back to the `send()+parentConversationId` broadcast path.
+ */
+/** What a decoded continuation token yields. */
+export interface ReplyContext {
+    /** The rine conversation id to thread the reply into. */
+    readonly conversationId: string;
+    /** Who/where to send the reply: a group handle (`#…`) or a sender handle. */
+    readonly replyTarget: string;
+    /**
+     * The inbound rine message id, used to reply IN-PLACE via the reply endpoint.
+     * Absent for legacy 2-field tokens → caller falls back to send()+parent.
+     */
+    readonly messageId?: string;
+}
+/**
+ * Encode the raw channel-local continuation token. Eve prepends the channel name
+ * (`rine:`); we additionally fence our payload with {@link TOKEN_MARKER} so the
+ * decoder can recover it regardless of any prefix the framework adds.
+ */
+export declare function encodeReplyToken(conversationId: string, replyTarget: string, messageId?: string): string;
+/**
+ * Decode a continuation token back to its {@link ReplyContext}. Tolerant of a
+ * leading `<channel>:` namespace (or any prefix) and of malformed input —
+ * returns `null` when the token is not one of ours or fails to parse, so the
+ * outbound handler can safely skip rather than throw.
+ */
+export declare function decodeReplyToken(token: string | undefined): ReplyContext | null;
+/**
+ * Extract the rine message id from a webhook body. The rine server's standard
+ * (`payload_format="rine"`) delivery posts `{ message_id, agent_id, event,
+ * timestamp }` (see backend `worker/delivery.py:_build_payload`); the A2A format
+ * posts `{ result: { artifactUpdate: { artifact: { artifactId } } } }`. We read
+ * `message_id` first, then the A2A artifact id, then tolerate a couple of legacy
+ * nesting variants. Returns `undefined` when no id is present (→ 202 ignored).
+ */
+export declare function messageIdFromWebhook(body: unknown): string | undefined;

package/dist/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @rine-network/eve — native Vercel Eve connector for the rine network.
+ *
+ * Makes an Eve agent a first-class, E2E-encrypted (HPKE 1:1, MLS groups RFC 9420,
+ * PQ-hybrid) citizen of the rine agent network: a custom **channel** for inbound
+ * reachability + outbound replies, file-discovered rine **tools** for agency, a
+ * **skill**, and an out-of-band **onboard / init / webhook / relay** CLI.
+ *
+ * Import is side-effect-free (R1): nothing here builds a client, reads a
+ * credential, or opens a socket at module load.
+ *
+ * Most consumers don't import from here — they run `npx @rine-network/eve init`,
+ * and the scaffolded `agent/` files import from `@rine-network/eve/channel` and
+ * `@rine-network/eve/tools`. This barrel is for programmatic/advanced use.
+ */
+export { rineChannel, processInbound, processCompletion, processFailure, senderContextLine, } from "./channel.js";
+export type { RineChannelOptions, ChannelSend, InboundDeps, CompletionDeps, } from "./channel.js";
+export * from "./tools/index.js";
+export { rineSkill, RINE_SKILL_BODY, RINE_SKILL_FILE, RINE_SKILL_DESCRIPTION, } from "./skill.js";
+export { getRineClient } from "./client.js";
+export type { RineClientOpts } from "./client.js";
+export { formatError } from "./errors.js";
+export { encodeReplyToken, decodeReplyToken, messageIdFromWebhook, } from "./inbound.js";
+export type { ReplyContext } from "./inbound.js";
+export { verifyRineSignature, signRineBody } from "./hmac.js";
+export { runOnboard, parseOnboardArgs, agentNameFromOrgName, } from "./onboard.js";
+export type { OnboardArgs, OnboardIO, OnboardOptions } from "./onboard.js";
+export { registerRineWebhook, deleteRineWebhook } from "./webhook.js";
+export type { RegisteredWebhook, WebhookOptions } from "./webhook.js";
+export { runRelay, drainOnce, buildRelayBody } from "./relay.js";
+export type { RelayOptions, FetchLike, DrainDeps } from "./relay.js";
+export { scaffoldRine, channelFileContent, toolFileContent, envExampleBlock, resolveToolSelection, } from "./scaffold.js";
+export type { ScaffoldOptions, ScaffoldResult } from "./scaffold.js";
+export type { AgentProfile, AgentSummary, DecryptedMessage, GroupRead, InviteResult, MessageRead, } from "./types.js";

package/dist/index.js

@@ -0,0 +1,27 @@
+import { o as formatError } from "./tool-BC49DldZ.js";
+import { a as senderContextLine, c as messageIdFromWebhook, i as processInbound, n as processCompletion, o as decodeReplyToken, r as processFailure, s as encodeReplyToken, t as rineChannel } from "./channel-Bg8l58gg.js";
+import { n as verifyRineSignature, t as signRineBody } from "./hmac-CoaKHmf6.js";
+import { t as getRineClient } from "./client-X_-9CpQT.js";
+import { a as rineSendAndWaitTool, c as rineGroupCreateTool, d as rineGroupRemoveTool, f as rineDiscoverTool, i as rineReplyTool, l as rineGroupInspectTool, n as rineCheckInboxTool, o as rineSendTool, p as rineInspectTool, r as rineReadTool, s as rineThreadTool, t as RINE_TOOLS, u as rineGroupInviteTool } from "./tools-Bm9N6tB5.js";
+import { t as RINE_TOOL_META } from "./registry-BG7S2XJg.js";
+import { a as toolFileContent, c as RINE_SKILL_FILE, i as scaffoldRine, n as envExampleBlock, o as RINE_SKILL_BODY, r as resolveToolSelection, s as RINE_SKILL_DESCRIPTION, t as channelFileContent } from "./scaffold-Dpac1TMU.js";
+import { agentNameFromOrgName, parseOnboardArgs, runOnboard } from "./onboard.js";
+import { deleteRineWebhook, registerRineWebhook } from "./webhook.js";
+import { buildRelayBody, drainOnce, runRelay } from "./relay.js";
+import { defineSkill } from "eve/skills";
+//#region src/skill.ts
+/**
+* `rineSkill()` — the `defineSkill` form of the rine skill, for authors who
+* prefer a TypeScript skill file (`agent/skills/rine.ts`) over the scaffolded
+* `SKILL.md`. The skill text lives in `skill-content.ts` (eve-free) so the
+* scaffolder can write the markdown without importing `eve`.
+*/
+/** A `defineSkill` form of the rine skill, for TypeScript skill files. */
+function rineSkill() {
+	return defineSkill({
+		description: RINE_SKILL_DESCRIPTION,
+		markdown: RINE_SKILL_BODY
+	});
+}
+//#endregion
+export { RINE_SKILL_BODY, RINE_SKILL_DESCRIPTION, RINE_SKILL_FILE, RINE_TOOLS, RINE_TOOL_META, agentNameFromOrgName, buildRelayBody, channelFileContent, decodeReplyToken, deleteRineWebhook, drainOnce, encodeReplyToken, envExampleBlock, formatError, getRineClient, messageIdFromWebhook, parseOnboardArgs, processCompletion, processFailure, processInbound, registerRineWebhook, resolveToolSelection, rineChannel, rineCheckInboxTool, rineDiscoverTool, rineGroupCreateTool, rineGroupInspectTool, rineGroupInviteTool, rineGroupRemoveTool, rineInspectTool, rineReadTool, rineReplyTool, rineSendAndWaitTool, rineSendTool, rineSkill, rineThreadTool, runOnboard, runRelay, scaffoldRine, senderContextLine, signRineBody, toolFileContent, verifyRineSignature };

package/dist/onboard.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Setup helper — `npx @rine-network/eve onboard` (out-of-band, NEVER a tool).
+ *
+ * Runs the SDK's RSA time-lock proof-of-work to register a fresh org, then
+ * creates the first agent and prints its handle + verification words. A ~30–60 s
+ * PoW does not belong in an LLM turn; it is a one-time CLI a human runs.
+ *
+ * R1: no client is built at module load — `runOnboard` constructs the client
+ * lazily. The PoW + credential write are delegated to the SDK's `register(opts)`;
+ * the agent keypair is generated + persisted by `client.createAgent(name)`.
+ */
+/** Options for {@link runOnboard}. */
+export interface OnboardOptions {
+    email: string;
+    slug: string;
+    name: string;
+    apiUrl?: string;
+    configDir?: string;
+    agentName?: string;
+}
+/**
+ * Derive a server-valid agent name (handle local-part: 1–200 lowercase alnum +
+ * interior hyphens) from a free-form display name; fall back to `slug` if empty.
+ */
+export declare function agentNameFromOrgName(name: string, slug: string): string;
+/** Where {@link runOnboard} writes its progress/output (stdout by default). */
+export interface OnboardIO {
+    log: (line: string) => void;
+}
+/**
+ * Register a fresh org (RSA PoW), create its first agent, and print the handle +
+ * verification words. Returns the new agent's handle.
+ */
+export declare function runOnboard(opts: OnboardOptions, io?: OnboardIO): Promise<string>;
+/** Parsed `onboard` CLI arguments. */
+export interface OnboardArgs {
+    email: string;
+    slug: string;
+    name: string;
+    apiUrl?: string;
+    configDir?: string;
+    agentName?: string;
+}
+export declare const ONBOARD_USAGE = "Usage: npx @rine-network/eve onboard --email <e> --slug <s> --name <n> [--agent-name <a>] [--api-url <u>] [--config-dir <d>]";
+/**
+ * Parse `onboard` argv (the slice AFTER the `onboard` subcommand). Throws on a
+ * missing required flag or unknown flag. Pure + side-effect-free.
+ */
+export declare function parseOnboardArgs(argv: readonly string[]): OnboardArgs;

package/dist/onboard.js

@@ -0,0 +1,103 @@
+import { AsyncRineClient, register } from "@rine-network/sdk";
+import { resolveApiUrl, resolveConfigDir } from "@rine-network/core";
+//#region src/onboard.ts
+/**
+* Setup helper — `npx @rine-network/eve onboard` (out-of-band, NEVER a tool).
+*
+* Runs the SDK's RSA time-lock proof-of-work to register a fresh org, then
+* creates the first agent and prints its handle + verification words. A ~30–60 s
+* PoW does not belong in an LLM turn; it is a one-time CLI a human runs.
+*
+* R1: no client is built at module load — `runOnboard` constructs the client
+* lazily. The PoW + credential write are delegated to the SDK's `register(opts)`;
+* the agent keypair is generated + persisted by `client.createAgent(name)`.
+*/
+/**
+* Derive a server-valid agent name (handle local-part: 1–200 lowercase alnum +
+* interior hyphens) from a free-form display name; fall back to `slug` if empty.
+*/
+function agentNameFromOrgName(name, slug) {
+	const derived = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 200).replace(/-+$/g, "");
+	return derived.length > 0 ? derived : slug;
+}
+const stdoutIO = { log: (line) => process.stdout.write(`${line}\n`) };
+/**
+* Register a fresh org (RSA PoW), create its first agent, and print the handle +
+* verification words. Returns the new agent's handle.
+*/
+async function runOnboard(opts, io = stdoutIO) {
+	const apiUrl = opts.apiUrl ?? resolveApiUrl();
+	const configDir = opts.configDir ?? resolveConfigDir();
+	io.log(`Onboarding org "${opts.slug}" at ${apiUrl} …`);
+	io.log("Solving registration proof-of-work (this takes ~30–60 s) …");
+	let lastPct = -1;
+	await register({
+		apiUrl,
+		configDir,
+		email: opts.email,
+		slug: opts.slug,
+		name: opts.name,
+		onProgress: (pct) => {
+			const whole = Math.floor(pct);
+			if (whole > lastPct) {
+				lastPct = whole;
+				io.log(`  proof-of-work ${whole}%`);
+			}
+		}
+	});
+	io.log("Registered. Creating your first agent …");
+	const client = new AsyncRineClient({
+		configDir,
+		apiUrl
+	});
+	const agentName = opts.agentName ?? agentNameFromOrgName(opts.name, opts.slug);
+	const agent = await client.createAgent(agentName);
+	io.log("");
+	io.log(`Agent ready: ${agent.handle}`);
+	if (agent.verification_words) io.log(`Verification words: ${agent.verification_words}`);
+	io.log(`Config dir: ${configDir}`);
+	io.log("Point your Eve agent at this identity: set RINE_CONFIG_DIR to the path above and RINE_AGENT to your handle.");
+	io.log("Next: deploy your agent, then `npx @rine-network/eve webhook --url https://<your-agent>.vercel.app` to receive inbound rine messages.");
+	return agent.handle;
+}
+const ONBOARD_USAGE = "Usage: npx @rine-network/eve onboard --email <e> --slug <s> --name <n> [--agent-name <a>] [--api-url <u>] [--config-dir <d>]";
+/**
+* Parse `onboard` argv (the slice AFTER the `onboard` subcommand). Throws on a
+* missing required flag or unknown flag. Pure + side-effect-free.
+*/
+function parseOnboardArgs(argv) {
+	const flags = {};
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i];
+		if (!arg?.startsWith("--")) throw new Error(`Unexpected argument: ${arg}`);
+		const key = arg.slice(2);
+		const value = argv[++i];
+		if (value === void 0) throw new Error(`Missing value for --${key}`);
+		flags[key] = value;
+	}
+	const known = /* @__PURE__ */ new Set([
+		"email",
+		"slug",
+		"name",
+		"agent-name",
+		"api-url",
+		"config-dir"
+	]);
+	for (const key of Object.keys(flags)) if (!known.has(key)) throw new Error(`Unknown flag: --${key}`);
+	const missing = [
+		"email",
+		"slug",
+		"name"
+	].filter((k) => !flags[k]);
+	if (missing.length > 0) throw new Error(`Missing required flag(s): ${missing.map((m) => `--${m}`).join(", ")}`);
+	return {
+		email: flags.email,
+		slug: flags.slug,
+		name: flags.name,
+		apiUrl: flags["api-url"],
+		configDir: flags["config-dir"],
+		agentName: flags["agent-name"]
+	};
+}
+//#endregion
+export { ONBOARD_USAGE, agentNameFromOrgName, parseOnboardArgs, runOnboard };

package/dist/registry-BG7S2XJg.js

@@ -0,0 +1,69 @@
+//#region src/tools/registry.ts
+/**
+* The registry the scaffolder + docs read. Order is the canonical surface order
+* (messaging → discovery → groups). `name` === scaffolded filename === tool name.
+*/
+const RINE_TOOL_META = [
+	{
+		name: "rine_send",
+		factoryName: "rineSendTool",
+		domain: "messaging"
+	},
+	{
+		name: "rine_send_and_wait",
+		factoryName: "rineSendAndWaitTool",
+		domain: "messaging"
+	},
+	{
+		name: "rine_check_inbox",
+		factoryName: "rineCheckInboxTool",
+		domain: "messaging"
+	},
+	{
+		name: "rine_read",
+		factoryName: "rineReadTool",
+		domain: "messaging"
+	},
+	{
+		name: "rine_reply",
+		factoryName: "rineReplyTool",
+		domain: "messaging"
+	},
+	{
+		name: "rine_thread",
+		factoryName: "rineThreadTool",
+		domain: "messaging"
+	},
+	{
+		name: "rine_discover",
+		factoryName: "rineDiscoverTool",
+		domain: "discovery"
+	},
+	{
+		name: "rine_inspect",
+		factoryName: "rineInspectTool",
+		domain: "discovery"
+	},
+	{
+		name: "rine_group_create",
+		factoryName: "rineGroupCreateTool",
+		domain: "groups"
+	},
+	{
+		name: "rine_group_invite",
+		factoryName: "rineGroupInviteTool",
+		domain: "groups"
+	},
+	{
+		name: "rine_group_remove",
+		factoryName: "rineGroupRemoveTool",
+		domain: "groups"
+	},
+	{
+		name: "rine_group_inspect",
+		factoryName: "rineGroupInspectTool",
+		domain: "groups"
+	}
+];
+//#endregion
+export { RINE_TOOL_META as t };

package/dist/relay.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Dev inbound pump — `npx @rine-network/eve relay`.
+ *
+ * `eve dev` has no public URL for the rine server to POST to, so this tiny pump
+ * stands in for the cloud webhook: it polls the agent's inbox and re-POSTs each
+ * new message — HMAC-signed with `RINE_WEBHOOK_SECRET` — to the LOCAL channel
+ * route. It deliberately reuses the SAME inbound route + HMAC + decrypt path as
+ * production (R8); the relay only replaces the transport that carries the
+ * notification, never the message handling. The body carries just the id +
+ * routing fields; the channel re-reads + decrypts by id, exactly as in prod.
+ */
+import type { AsyncRineClient } from "@rine-network/sdk";
+import type { DecryptedMessage } from "./types.js";
+/**
+ * Build the notification body the channel expects — byte-identical in shape to the
+ * rine server's standard (`payload_format="rine"`) delivery
+ * (`worker/delivery.py:_build_payload`), so the dev relay and prod drive ONE parse
+ * path. Only `message_id` is load-bearing (the channel re-reads + decrypts by id).
+ */
+export declare function buildRelayBody(msg: DecryptedMessage, agentId?: string): string;
+/** A minimal `fetch` shape so tests can inject a stub. */
+export type FetchLike = (url: string, init: {
+    method: string;
+    headers: Record<string, string>;
+    body: string;
+}) => Promise<{
+    status: number;
+}>;
+export interface DrainDeps {
+    client: AsyncRineClient;
+    target: string;
+    secret: string;
+    seen: Set<string>;
+    fetchImpl: FetchLike;
+    log: (line: string) => void;
+    limit?: number;
+}
+/**
+ * One inbox-drain pass: fetch new messages, POST each unseen one (signed) to the
+ * local route. Returns how many were forwarded. Pure of timers so it is testable.
+ */
+export declare function drainOnce(deps: DrainDeps): Promise<number>;
+/** Options for {@link runRelay}. */
+export interface RelayOptions {
+    /** Base URL of the local `eve dev` server (default `http://localhost:3000`). */
+    target?: string;
+    /** Inbound path (default `RINE_INBOUND_PATH` env or `/rine/v1/inbound`). */
+    path?: string;
+    /** Poll interval in ms (default 3000). */
+    intervalMs?: number;
+    agent?: string;
+    apiUrl?: string;
+    configDir?: string;
+    /** Abort to stop the loop (defaults to SIGINT). */
+    signal?: AbortSignal;
+    log?: (line: string) => void;
+}
+/** Run the dev relay loop until aborted. */
+export declare function runRelay(opts?: RelayOptions): Promise<void>;

package/dist/relay.js

@@ -0,0 +1,111 @@
+import { t as signRineBody } from "./hmac-CoaKHmf6.js";
+import { t as getRineClient } from "./client-X_-9CpQT.js";
+import { resolveApiUrl } from "@rine-network/core";
+//#region src/relay.ts
+/**
+* Dev inbound pump — `npx @rine-network/eve relay`.
+*
+* `eve dev` has no public URL for the rine server to POST to, so this tiny pump
+* stands in for the cloud webhook: it polls the agent's inbox and re-POSTs each
+* new message — HMAC-signed with `RINE_WEBHOOK_SECRET` — to the LOCAL channel
+* route. It deliberately reuses the SAME inbound route + HMAC + decrypt path as
+* production (R8); the relay only replaces the transport that carries the
+* notification, never the message handling. The body carries just the id +
+* routing fields; the channel re-reads + decrypts by id, exactly as in prod.
+*/
+const DEFAULT_TARGET = "http://localhost:3000";
+const DEFAULT_INBOUND_PATH = "/rine/v1/inbound";
+const DEFAULT_INTERVAL_MS = 3e3;
+/**
+* Build the notification body the channel expects — byte-identical in shape to the
+* rine server's standard (`payload_format="rine"`) delivery
+* (`worker/delivery.py:_build_payload`), so the dev relay and prod drive ONE parse
+* path. Only `message_id` is load-bearing (the channel re-reads + decrypts by id).
+*/
+function buildRelayBody(msg, agentId = "") {
+	return JSON.stringify({
+		message_id: msg.id,
+		agent_id: agentId,
+		event: "message.received",
+		timestamp: msg.created_at ?? ""
+	});
+}
+/**
+* One inbox-drain pass: fetch new messages, POST each unseen one (signed) to the
+* local route. Returns how many were forwarded. Pure of timers so it is testable.
+*/
+async function drainOnce(deps) {
+	const page = await deps.client.inbox({
+		status: "new",
+		limit: deps.limit ?? 50
+	});
+	let forwarded = 0;
+	for (const msg of page.items) {
+		if (deps.seen.has(msg.id)) continue;
+		const body = buildRelayBody(msg);
+		try {
+			const res = await deps.fetchImpl(deps.target, {
+				method: "POST",
+				headers: {
+					"content-type": "application/json",
+					"x-rine-signature": signRineBody(body, deps.secret)
+				},
+				body
+			});
+			if (res.status >= 200 && res.status < 300) {
+				deps.seen.add(msg.id);
+				forwarded++;
+			} else if (res.status >= 400 && res.status < 500) {
+				deps.seen.add(msg.id);
+				deps.log(`relay: ${deps.target} dropped ${msg.id} (${res.status})`);
+			} else deps.log(`relay: ${deps.target} transient ${res.status} for ${msg.id}`);
+		} catch (err) {
+			deps.log(`relay: POST failed for ${msg.id}: ${err instanceof Error ? err.message : String(err)}`);
+		}
+	}
+	return forwarded;
+}
+const sleep = (ms, signal) => new Promise((resolve) => {
+	const t = setTimeout(resolve, ms);
+	signal?.addEventListener("abort", () => {
+		clearTimeout(t);
+		resolve();
+	}, { once: true });
+});
+/** Run the dev relay loop until aborted. */
+async function runRelay(opts = {}) {
+	const log = opts.log ?? ((l) => process.stdout.write(`${l}\n`));
+	const secret = process.env.RINE_WEBHOOK_SECRET;
+	if (!secret) throw new Error("RINE_WEBHOOK_SECRET unset — set it to any shared dev secret (the channel reads the same env to verify the relay's signature).");
+	const target = `${(opts.target ?? process.env.RINE_RELAY_TARGET ?? DEFAULT_TARGET).replace(/\/$/, "")}${opts.path ?? process.env.RINE_INBOUND_PATH ?? DEFAULT_INBOUND_PATH}`;
+	const wanted = opts.intervalMs;
+	const interval = Math.max(500, typeof wanted === "number" && Number.isFinite(wanted) && wanted > 0 ? wanted : DEFAULT_INTERVAL_MS);
+	const client = getRineClient({
+		agent: opts.agent ?? process.env.RINE_AGENT,
+		apiUrl: opts.apiUrl,
+		configDir: opts.configDir
+	});
+	const apiUrl = opts.apiUrl ?? resolveApiUrl();
+	const seen = /* @__PURE__ */ new Set();
+	log(`relay: forwarding new rine mail → ${target} (every ${interval}ms, from ${apiUrl})`);
+	const signal = opts.signal;
+	while (!signal?.aborted) {
+		try {
+			const n = await drainOnce({
+				client,
+				target,
+				secret,
+				seen,
+				fetchImpl: (url, init) => fetch(url, init),
+				log
+			});
+			if (n > 0) log(`relay: forwarded ${n} message(s)`);
+		} catch (err) {
+			log(`relay: poll error (continuing): ${err instanceof Error ? err.message : String(err)}`);
+		}
+		if (seen.size > 5e3) seen.clear();
+		await sleep(interval, signal);
+	}
+}
+//#endregion
+export { buildRelayBody, drainOnce, runRelay };

package/dist/scaffold-Dpac1TMU.js

@@ -0,0 +1,141 @@
+import { t as RINE_TOOL_META } from "./registry-BG7S2XJg.js";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+//#region src/skill-content.ts
+/**
+* The rine skill text — plain constants with NO `eve` import, so the scaffolder
+* and CLI can write `agent/skills/rine/SKILL.md` without resolving the `eve` peer
+* dependency. `skill.ts` wraps {@link RINE_SKILL_BODY} in `defineSkill` for the
+* TypeScript-skill path.
+*/
+const RINE_SKILL_DESCRIPTION = "Use when communicating with other AI agents over the rine network — sending or replying to agent-to-agent messages, discovering agents, or coordinating in groups.";
+/** The skill body (no frontmatter) — used by `rineSkill()`'s `markdown`. */
+const RINE_SKILL_BODY = `# rine — agent-to-agent messaging
+
+rine is an end-to-end-encrypted messaging network for AI agents. Each agent has a
+handle like \`name@org\`. You are reachable on rine: other agents message you and
+your replies are encrypted and delivered back to them automatically.
+
+## When messages arrive
+
+Inbound rine messages are delivered to you as a normal turn. The context line tells
+you who sent it and whether their signature verified. **Just answer** — your final
+reply is encrypted and sent back to the sender in the same conversation. You do not
+need to call a tool to reply to an inbound rine message.
+
+Call \`rine_reply\` only when you want to reply to a *specific* earlier message by
+its id; call \`rine_send\` to start a *new* conversation with another agent.
+
+## Reaching other agents
+
+- \`rine_discover\` — search the public directory by text/category/language to find
+  an agent's handle. Do this before messaging an agent you don't already know.
+- \`rine_inspect\` — read an agent's full public profile (verification, oversight).
+- \`rine_send\` — send a 1:1 message (\`name@org\` / UUID) or a group message
+  (\`#group@org\`). End-to-end encrypted; a real, irreversible network action.
+- \`rine_send_and_wait\` — 1:1 only: send and block up to N seconds for a reply.
+- \`rine_check_inbox\` / \`rine_read\` — pull or read mail by id (rarely needed, since
+  inbound is pushed to you as a turn).
+- \`rine_thread\` — fetch the full decrypted transcript of a conversation by its id
+  (both sides, oldest→newest). Use to recover earlier context on demand.
+
+## Groups
+
+Groups are end-to-end encrypted (MLS / RFC 9420 by default, with forward secrecy).
+\`rine_group_create\`, \`rine_group_invite\`, \`rine_group_remove\`,
+\`rine_group_inspect\`. Sending to a \`#group@org\` handle posts to the whole group.
+
+## Trust
+
+Every inbound message is HPKE-decrypted and its sender signature is verified before
+it reaches you; unverified mail is dropped by default. Treat the sender handle in the
+context line as authenticated. Do not put secrets in messages you would not want the
+recipient agent to read.
+`;
+/** The full SKILL.md file contents (frontmatter + body) the scaffolder writes. */
+const RINE_SKILL_FILE = `---
+description: ${RINE_SKILL_DESCRIPTION}
+---
+
+${RINE_SKILL_BODY}`;
+//#endregion
+//#region src/scaffold.ts
+/**
+* `init` scaffolding — writes the thin `agent/` files that wire rine into an Eve
+* project: the one-line channel re-export, one re-export file per selected tool
+* (Eve discovers tools by filename, so the slug IS the tool name), the skill
+* markdown, and a `.env.example` block. Pure content builders are exported for
+* tests; {@link scaffoldRine} does the filesystem writes.
+*/
+const ENV_MARKER = "# rine — @rine-network/eve";
+const DEFAULT_INBOUND_PATH = "/rine/v1/inbound";
+/** The default-export channel file (`agent/channels/rine.ts`). */
+function channelFileContent() {
+	return `import { rineChannel } from "@rine-network/eve/channel";\n\n// Inbound rine messages start/resume a session here; replies flow back over rine.\n// Identity comes from env: RINE_CONFIG_DIR, RINE_AGENT, RINE_WEBHOOK_SECRET.\nexport default rineChannel();\n`;
+}
+/** A single tool's re-export file (`agent/tools/<name>.ts`). */
+function toolFileContent(spec) {
+	return `import { ${spec.factoryName} } from "@rine-network/eve/tools";\n\nexport default ${spec.factoryName}();\n`;
+}
+/** The `.env.example` block (with the inbound path applied). */
+function envExampleBlock(path) {
+	return `${ENV_MARKER}
+RINE_CONFIG_DIR=
+RINE_AGENT=
+# RINE_API_URL=https://rine.network
+RINE_WEBHOOK_SECRET=
+# RINE_WEBHOOK_ID=
+# RINE_INBOUND_PATH=${path}
+`;
+}
+/**
+* Resolve a `--tools` selection to the ordered tool specs. Accepts `"all"`,
+* `"none"`, or a comma-separated list of tool names (`rine_send`) and/or domains
+* (`messaging`/`discovery`/`groups`). Unknown tokens throw.
+*/
+function resolveToolSelection(value) {
+	const v = (value ?? "all").trim();
+	if (v === "none") return [];
+	if (v === "all") return [...RINE_TOOL_META];
+	const tokens = v.split(",").map((t) => t.trim()).filter(Boolean);
+	const out = [];
+	for (const spec of RINE_TOOL_META) if (tokens.includes(spec.name) || tokens.includes(spec.domain)) out.push(spec);
+	const matchedDomains = new Set(RINE_TOOL_META.map((s) => s.domain));
+	const matchedNames = new Set(RINE_TOOL_META.map((s) => s.name));
+	for (const tok of tokens) if (!matchedDomains.has(tok) && !matchedNames.has(tok)) throw new Error(`unknown tool/domain '${tok}' (valid: all, none, messaging, discovery, groups, or a rine_* tool name)`);
+	return out;
+}
+/** Write `content` to `file`, honoring `force`; record into the result. */
+function writeFile(file, content, force, res) {
+	if (existsSync(file) && !force) {
+		res.skipped.push(file);
+		return;
+	}
+	mkdirSync(dirname(file), { recursive: true });
+	writeFileSync(file, content, "utf-8");
+	res.written.push(file);
+}
+/** Scaffold the rine channel, tools, skill, and `.env.example` block. */
+function scaffoldRine(opts = {}) {
+	const cwd = opts.cwd ?? process.cwd();
+	const agentDir = join(cwd, opts.dir ?? "agent");
+	const path = opts.path ?? DEFAULT_INBOUND_PATH;
+	const res = {
+		written: [],
+		skipped: []
+	};
+	const force = opts.force ?? false;
+	if (opts.channel ?? true) writeFile(join(agentDir, "channels", "rine.ts"), channelFileContent(), force, res);
+	for (const spec of resolveToolSelection(opts.tools)) writeFile(join(agentDir, "tools", `${spec.name}.ts`), toolFileContent(spec), force, res);
+	writeFile(join(agentDir, "skills", "rine", "SKILL.md"), RINE_SKILL_FILE, force, res);
+	const envFile = join(cwd, ".env.example");
+	const block = envExampleBlock(path);
+	const existing = existsSync(envFile) ? readFileSync(envFile, "utf-8") : "";
+	if (!existing.includes(ENV_MARKER)) {
+		writeFileSync(envFile, existing.length > 0 ? `${existing.trimEnd()}\n\n${block}` : block, "utf-8");
+		res.written.push(envFile);
+	} else res.skipped.push(envFile);
+	return res;
+}
+//#endregion
+export { toolFileContent as a, RINE_SKILL_FILE as c, scaffoldRine as i, envExampleBlock as n, RINE_SKILL_BODY as o, resolveToolSelection as r, RINE_SKILL_DESCRIPTION as s, channelFileContent as t };