omp-onlyne 0.1.0 → 0.3.0

package/src/node.ts

@@ -1,127 +0,0 @@
-import { networkInterfaces } from "node:os";
-import { FetchTransport, OnlyneError, OnlyneNode, trustPhase, type Action, type AdmissionContext, type Auth, type Json, type KeyHook, type KeyMaterial, type MaintenanceClock, type MsgInput, type Runtime, type SigningTransportOptions, type Storage, type Target } from "@onlyne/lib";
-import { loadOrCreateKey, writeKeyMaterial } from "@onlyne/node-host/keys";
-import { hostText as t } from "./host-text.ts";
-import { canAnswer, type ContextRegistry } from "./store.ts";
-import type { OnlyneConfig } from "./types.ts";
-
-export interface NodeDeps {
-	config: OnlyneConfig;
-	endpoint: string;
-	instanceId: string;
-	storage: Storage;
-	contexts: ContextRegistry;
-	decide(input: MsgInput): Promise<Action>;
-	runtime: Runtime;
-	/** The timer primitives of the library's own maintenance loop (RFC 0017 §6). */
-	clock: MaintenanceClock;
-	/** The directory the host resolved for this node's identity key; absent keeps the loopback development binding. */
-	keyDir?: string;
-	keys?: KeyHook;
-}
-
-export function advertisedHost(bind: string): string {
-	if (bind !== "0.0.0.0" && bind !== "::") return bind;
-	for (const addresses of Object.values(networkInterfaces())) {
-		for (const address of addresses ?? []) {
-			if (!address.internal && address.family === "IPv4") return address.address;
-		}
-	}
-	throw new OnlyneError("unavailable", t("addressUnavailable"));
-}
-
-export function createOnlyneNode(deps: NodeDeps): OnlyneNode {
-	const { config } = deps;
-	if (config.node.key_ref && deps.keys === undefined) throw new OnlyneError("unsupported_delivery", t("keyProvider"));
-	// Without a key directory the node keeps the loopback development binding (RFC 0001 §1).
-	if (deps.keys === undefined && deps.keyDir === undefined && !["127.0.0.1", "::1", "localhost"].includes(config.server.bind)) {
-		throw new OnlyneError("unsupported_delivery", t("loopbackBind"));
-	}
-	let node: OnlyneNode;
-	const authenticate = async (request: Request): Promise<Auth | null> => {
-		const actor = request.headers.get("Onlyne-Actor");
-		if (!actor || !/^[A-Za-z][A-Za-z0-9+.-]*:[^\s]+$/.test(actor)) return null;
-		if (actor === config.node.id) throw new OnlyneError("forbidden", t("managementIdentity"));
-		return { actor };
-	};
-	const resolve = async (id: string): Promise<Target> => {
-		const target = id === config.node.id
-			? { node_id: id, base_url: deps.endpoint }
-			: await node.discovery.resolve(id);
-		return { ...target, headers: { "Onlyne-Actor": config.node.id } };
-	};
-	/**
-	 * Admission reads the trust projection, never the discovery catalog (design §1.1): a discovered
-	 * peer is a clue (RFC 0017 §4), and `discovery.known` is process-local, so a restart would refuse
-	 * a peer whose exchange already completed.
-	 */
-	const admitted = async (id: string, context: AdmissionContext): Promise<boolean> => {
-		if (id === config.node.id) return true;
-		return await context.trust(id) === "exchanged";
-	};
-	const keyDir = deps.keyDir;
-	const keys: KeyHook | undefined = deps.keys ?? (keyDir === undefined ? undefined : Object.assign(
-		() => loadOrCreateKey(keyDir, config.node.id),
-		{ replace: (material: KeyMaterial) => writeKeyMaterial(keyDir, material, { replace: true }) },
-	));
-	// The library's own signing transport, built here for one reason: a missing trust row has to
-	// end at this host's menu. Signing still happens only for a keyed node, and the trust reads
-	// resolve lazily because the service exists only once the node is built.
-	const signing: SigningTransportOptions | undefined = keys === undefined ? undefined : {
-		trust: {
-			entry: id => node.trust.entry(id),
-			signRequest: (request, target, raw) => node.trust.signRequest(request, target, raw),
-			verifyResponse: (target, request, response, body) => node.trust.verifyResponse(target, request, response, body),
-		},
-		guidance: details => ({
-			entry: details.required_action === "confirm_exchange"
-				? ["/onlyne", t("guideContacts"), t("guidePending"), t("guideAccept")]
-				: ["/onlyne", t("guideDiscover"), t("guideRequestExchange")],
-		}),
-	};
-	node = new OnlyneNode({
-		node_id: config.node.id, base_url: deps.endpoint, instance_id: deps.instanceId,
-		now: () => Date.now(), id: () => crypto.randomUUID(),
-		authentication: keys === undefined ? ["none"] : ["signature"], plugins: {
-			storage: deps.storage, authenticate, resolve, decide: deps.decide, runtime: deps.runtime, maintenanceClock: deps.clock,
-			...(keys === undefined ? {} : { keys }),
-			...(signing === undefined ? {} : { transport: new FetchTransport(resolve, fetch, signing) }),
-			...(config.trust === undefined ? {} : { trust_seeds: config.trust }),
-			domainCandidates: id => node.discovery.candidates(id),
-			// The keyless development binding checks no identity (RFC 0001 §1): every declared
-			// actor may open a thread. A keyed node admits only peers whose exchange completed.
-			mayAdmit: async (actor, _thread, context) => keys === undefined || await admitted(actor, context),
-			inboundThread: async (actor, context) => keys === undefined || await admitted(actor, context),
-			// A context that cannot answer is not a continuation target: publishing one lets a
-			// sender aim a message at a session that can never reply (caerulea report 4, problem 7).
-			executionContexts: async () => (await deps.contexts.list()).filter(canAnswer)
-				.map(record => ({ alias: record.alias, summary: record.summary, state: record.state })) as Json,
-			mention: async alias => {
-				const name = alias.replace(/^@/, "");
-				if (name === "self" || name === config.node.id) return config.node.id;
-				const matches = (await node.discovery.listRecords()).filter(record => record.node_id === name || record.node_id.split(":").at(-1) === name);
-				const ids = [...new Set(matches.map(record => record.node_id))];
-				if (ids.length !== 1) throw new OnlyneError(ids.length ? "ambiguous_target" : "not_found", t("mentionNotFound", { name }));
-				return ids[0]!;
-			},
-			directory: async () => ({ node: config.node.id, region: config.region, endpoint: deps.endpoint, peers: await node.discovery.listRecords(), contexts: await deps.contexts.list() }) as unknown as Json,
-			// The same rows onlyne://neighbors renders: every observed node with its trust state.
-			neighbors: async () => {
-				const records = await node.discovery.listRecords();
-				const trust = new Map((await node.trust.list(node.auth)).map(entry => [entry.node_id, entry]));
-				return records.map(record => {
-					const entry = trust.get(record.node_id);
-					return {
-						node_id: record.node_id, base_url: record.base_url,
-						...(record.membership?.domain_id === undefined ? {} : { region: record.membership.domain_id }),
-						...(record.last_seen === undefined ? {} : { last_seen: record.last_seen }),
-						verified: record.verified_at !== undefined && Date.parse(record.expires_at) > Date.now(),
-						phase: entry === undefined ? "no_exchange" : trustPhase(entry),
-						fingerprint: entry?.fingerprint ?? null,
-					};
-				});
-			},
-		},
-	});
-	return node;
-}

package/src/store.ts

@@ -1,189 +0,0 @@
-import { Database } from "bun:sqlite";
-import { chmodSync, existsSync, mkdirSync } from "node:fs";
-import { dirname } from "node:path";
-import type { Entry, Storage, ThreadRef, Transaction } from "@onlyne/lib";
-import type { ContextRecord } from "./types.ts";
-import { bridgeText as t } from "./bridge-text.ts";
-
-/** Key/value rows under one SQLite file; the library's durable state and the plugin's registry share it. */
-export class SqliteStorage implements Storage {
-	readonly guarantee = "durable" as const;
-	readonly #db: Database;
-	#tail: Promise<unknown> = Promise.resolve();
-	#closed = false;
-
-	constructor(path: string) {
-		// The store carries trust rows and, while a rotation is unacknowledged, the old private
-		// key that proves it. It is secret material: 0700 for the directory, 0600 for the files,
-		// including the WAL and shared-memory sidecars SQLite creates beside them.
-		const dir = dirname(path);
-		mkdirSync(dir, { recursive: true, mode: 0o700 });
-		chmodSync(dir, 0o700);
-		this.#db = new Database(path, { create: true });
-		this.#db.exec("PRAGMA journal_mode = WAL");
-		this.#db.exec("PRAGMA synchronous = FULL");
-		this.#db.exec("PRAGMA busy_timeout = 5000");
-		this.#db.exec("CREATE TABLE IF NOT EXISTS kv (key TEXT PRIMARY KEY, value TEXT NOT NULL)");
-		for (const file of [path, `${path}-wal`, `${path}-shm`]) {
-			if (existsSync(file)) chmodSync(file, 0o600);
-		}
-	}
-
-	/** Serialize every transaction; SQLite's own BEGIN IMMEDIATE would otherwise race across awaits. */
-	transaction<T>(work: (tx: Transaction) => Promise<T>): Promise<T> {
-		const run = () => this.#execute(work);
-		const result = this.#tail.then(run, run);
-		this.#tail = result.then(
-			() => undefined,
-			() => undefined,
-		);
-		return result;
-	}
-
-	async #execute<T>(work: (tx: Transaction) => Promise<T>): Promise<T> {
-		if (this.#closed) throw new Error(t("storeClosed"));
-		this.#db.exec("BEGIN IMMEDIATE");
-		const tx: Transaction = {
-			get: async <V>(key: string) => this.#get<V>(key),
-			put: async <V>(key: string, value: V) => this.#put(key, value),
-			delete: async (key: string) => {
-				this.#db.query("DELETE FROM kv WHERE key = ?").run(key);
-			},
-			scan: async <V>(prefix: string) => this.#scan<V>(prefix),
-		};
-		try {
-			const value = await work(tx);
-			this.#db.exec("COMMIT");
-			return value;
-		} catch (error) {
-			try {
-				this.#db.exec("ROLLBACK");
-			} catch {
-				// The transaction may already be gone; preserve the original failure.
-			}
-			throw error;
-		}
-	}
-
-	#get<T>(key: string): T | undefined {
-		const row = this.#db.query<{ value: string }, [string]>("SELECT value FROM kv WHERE key = ?").get(key);
-		return row === null ? undefined : (JSON.parse(row.value) as T);
-	}
-
-	#put(key: string, value: unknown): void {
-		this.#db
-			.query("INSERT INTO kv (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value")
-			.run(key, JSON.stringify(value));
-	}
-
-	#scan<T>(prefix: string): Array<{ key: string; value: T }> {
-		const rows = this.#db
-			.query<{ key: string; value: string }, [number, string]>(
-				"SELECT key, value FROM kv WHERE substr(key, 1, ?) = ? ORDER BY key",
-			)
-			.all(prefix.length, prefix);
-		return rows.map(row => ({ key: row.key, value: JSON.parse(row.value) as T }));
-	}
-
-	close(): void {
-		if (this.#closed) return;
-		this.#closed = true;
-		this.#db.close();
-	}
-}
-
-const COUNTER_KEY = "meta/context-counter";
-const CONTEXT_PREFIX = "context/";
-
-/**
- * Whether a registered context can answer a delivery. Only the session holding this node's
- * own send right can: a subagent context reads and drafts, never sends. Advertising one as a
- * continuation target hands the sender a message nobody there can reply to, and the sender
- * has no way to see that from the alias (caerulea report 4, problem 7).
- */
-export function canAnswer(record: ContextRecord): boolean {
-	return record.agent_id !== undefined && record.agent_id === record.main_agent_id;
-}
-
-/** Alias allocation and binding for execution contexts; the store is the authority across restarts. */
-export class ContextRegistry {
-	constructor(private readonly storage: Storage, private readonly nodeId: string, private readonly mainAgentId: string) {}
-
-	/** The main OMP session is addressable like a registered execution context. */
-	async ensureMain(): Promise<ContextRecord> {
-		return this.storage.transaction(async tx => {
-			const key = `${CONTEXT_PREFIX}main`;
-			const current = await tx.get<ContextRecord>(key);
-			if (current !== undefined) return current;
-			const record: ContextRecord = {
-				alias: "main", node_id: this.nodeId, main_agent_id: this.mainAgentId, agent_id: this.mainAgentId,
-				summary: t("mainSummary"), state: "idle", created_at: new Date().toISOString(),
-			};
-			await tx.put(key, record);
-			return record;
-		});
-	}
-
-	async allocate(thread_ref: ThreadRef | undefined, summary: string, source?: Entry["message"]): Promise<ContextRecord> {
-		return this.storage.transaction(async tx => {
-			const counter = (await tx.get<number>(COUNTER_KEY)) ?? 0;
-			const next = counter + 1;
-			await tx.put(COUNTER_KEY, next);
-			const alias = `c-${String(next)}`;
-			const record: ContextRecord = {
-				alias,
-				node_id: this.nodeId,
-				main_agent_id: this.mainAgentId,
-				...(source === undefined ? {} : { source: { sender: source.sender, id: source.id } }),
-				...(thread_ref === undefined ? {} : { thread_ref }),
-				summary,
-				state: "unbound",
-				created_at: new Date().toISOString(),
-			};
-			await tx.put(`${CONTEXT_PREFIX}${alias}`, record);
-			return record;
-		});
-	}
-
-	async bind(
-		alias: string,
-		binding: { agent_id: string; session_file?: string; parent_id?: string },
-	): Promise<ContextRecord> {
-		return this.storage.transaction(async tx => {
-			const key = `${CONTEXT_PREFIX}${alias}`;
-			const current = await tx.get<ContextRecord>(key);
-			if (current === undefined) throw new Error(t("contextNotRegistered", { alias }));
-			const next: ContextRecord = {
-				...current,
-				agent_id: binding.agent_id,
-				...(binding.session_file === undefined ? {} : { session_file: binding.session_file }),
-				...(binding.parent_id === undefined ? {} : { parent_id: binding.parent_id }),
-				state: current.agent_id === binding.agent_id ? current.state : "idle",
-				bound_at: new Date().toISOString(),
-			};
-			await tx.put(key, next);
-			return next;
-		});
-	}
-
-	async find(alias: string): Promise<ContextRecord | undefined> {
-		return this.storage.transaction(tx => tx.get<ContextRecord>(`${CONTEXT_PREFIX}${alias}`));
-	}
-
-	async list(): Promise<ContextRecord[]> {
-		return this.storage.transaction(async tx =>
-			(await tx.scan<ContextRecord>(CONTEXT_PREFIX)).map(row => row.value),
-		);
-	}
-
-	async updateState(alias: string, state: ContextRecord["state"]): Promise<ContextRecord | undefined> {
-		return this.storage.transaction(async tx => {
-			const key = `${CONTEXT_PREFIX}${alias}`;
-			const current = await tx.get<ContextRecord>(key);
-			if (current === undefined) return undefined;
-			const next = { ...current, state };
-			await tx.put(key, next);
-			return next;
-		});
-	}
-}