@fungi.computer/oyster 0.4.1 → 0.6.0

package/dist/channels/visitor-edge.js

@@ -0,0 +1,582 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { Hono } from "hono";
+import { html } from "hono/html";
+import * as Schema from "effect/Schema";
+import * as Option from "effect/Option";
+import { z } from "zod";
+import { sameOriginReadRequest, sameOriginRequest } from "../request-origin.js";
+import { channelIds } from "./ids.js";
+import { originAllowed } from "./binding.js";
+import { visitorBearerSchema } from "./visitors.js";
+import { visitorRequestSchema } from "./visitor-request.js";
+/**
+ * The public web-channel edge. The host owns address lookup, visitor identity
+ * and Agent selection. Current conversation operations authenticate their
+ * bearer before asking the host to resolve an Agent for that visitor. The
+ * retained legacy GET /conversation keeps its site-owner path.
+ */
+const siteKeySchema = z
+    .string()
+    .refine((value) => channelIds.site.is(value));
+const messageSchema = visitorRequestSchema.extend({
+    text: z.string().trim().min(1).max(16_000),
+});
+const refreshSchema = z.strictObject({ refreshSecret: visitorBearerSchema });
+const sessionReadSchema = z
+    .strictObject({
+    limit: z.number().int().min(1).max(200).optional(),
+    before: z.string().min(1).max(2048).optional(),
+})
+    .transform((value) => {
+    if (value.limit === undefined)
+        return value.before === undefined ? {} : { before: value.before };
+    if (value.before === undefined)
+        return { limit: value.limit };
+    return { limit: value.limit, before: value.before };
+});
+const decodeJson = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Json));
+const DENIAL_STATUS = {
+    unmapped: 404,
+    suspended: 403,
+    banned: 403,
+    too_long: 413,
+    party_daily_limit: 429,
+    new_party_limit: 429,
+    rate_limited: 429,
+    address_limit: 429,
+    stream_limit: 429,
+    event_conflict: 409,
+    refresh_invalid: 401,
+    refresh_reused: 401,
+};
+function denied(reason) {
+    return Response.json({ error: reason }, { status: DENIAL_STATUS[reason], headers: { "cache-control": "no-store" } });
+}
+/** Browsers always send Origin on POST; only the embed document may call. */
+function sameOrigin(context) {
+    return sameOriginRequest(context.req.raw);
+}
+function bearer(context) {
+    const header = context.req.header("authorization") ?? "";
+    const parsed = visitorBearerSchema.safeParse(header.startsWith("Bearer ") ? header.slice("Bearer ".length) : "");
+    return parsed.success && parsed.data.startsWith("vt_") ? parsed.data : null;
+}
+function intakeResponse(result) {
+    return result.kind === "accepted" || result.kind === "held"
+        ? Response.json(result.kind === "accepted"
+            ? {
+                status: "accepted",
+                commandId: result.commandId,
+                delivery: result.delivery,
+            }
+            : { status: "recorded", delivery: result.delivery }, { status: 202, headers: { "cache-control": "no-store" } })
+        : denied(result.reason);
+}
+/** Only exact embed-safe origins reach the CSP header. */
+function frameAncestors(origins) {
+    return origins
+        .filter((origin) => /^https?:\/\/(\*\.)?[a-z0-9.:[\]-]+$/u.test(origin))
+        .join(" ");
+}
+/** Both values are already parsed: a site key and an optional `#rrggbb`. */
+async function embedDocument(siteKey, facts, assets) {
+    return (await html `<!doctype html>
+      <html lang="en">
+        <head>
+          <meta charset="utf-8" />
+          <meta name="viewport" content="width=device-width, initial-scale=1" />
+          <meta name="referrer" content="no-referrer" />
+          <title>${facts.name}</title>
+          <link rel="stylesheet" href="${assets("styles")}" />
+        </head>
+        <body class="caps-embed">
+          <div
+            id="fungi-embed"
+            data-site="${siteKey}"
+            data-accent="${facts.accent ?? ""}"
+            data-name="${facts.name}"
+            data-avatar="${JSON.stringify(facts.avatar)}"
+          ></div>
+          <script type="module" src="${assets("widget")}"></script>
+        </body>
+      </html>`).toString();
+}
+export function createVisitorEdge(host) {
+    async function route(context) {
+        const siteKey = siteKeySchema.safeParse(context.req.param("siteKey"));
+        if (!siteKey.success)
+            return null;
+        return host.resolveSite(context, siteKey.data);
+    }
+    async function visitorChannel(context, site, token) {
+        const visitor = await host.authenticateVisitor(context, site, token);
+        if (visitor === null)
+            return null;
+        return host.openChannel(context, site, visitor);
+    }
+    return new Hono()
+        .onError(host.onError)
+        .get("/embed/v1/s/:siteKey", async (context) => {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            const site = await route(context);
+            if (site === null)
+                return context.text("Not found", 404);
+            const siteKey = context.req.param("siteKey");
+            const channels = __addDisposableResource(env_1, await host.openSite(context, site), false);
+            const facts = await channels.readChannelSite({
+                bindingId: site.bindingId,
+                siteKey,
+            });
+            if (facts === null)
+                return context.text("Not found", 404);
+            return new Response(await embedDocument(siteKey, facts, host.assetPath), {
+                headers: {
+                    "content-type": "text/html; charset=utf-8",
+                    "cache-control": "no-store",
+                    "referrer-policy": "no-referrer",
+                    "x-content-type-options": "nosniff",
+                    "content-security-policy": [
+                        "default-src 'none'",
+                        "script-src 'self'",
+                        "style-src 'self'",
+                        "font-src 'self'",
+                        "img-src 'self' data:",
+                        "connect-src 'self'",
+                        "base-uri 'none'",
+                        "form-action 'none'",
+                        `frame-ancestors ${frameAncestors(facts.origins) || "'none'"}`,
+                    ].join("; "),
+                },
+            });
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            __disposeResources(env_1);
+        }
+    })
+        .get("/api/embed/v1/sites/:siteKey/theme", async (context) => {
+        const env_2 = { stack: [], error: void 0, hasError: false };
+        try {
+            // Public chrome and an advisory address check. CSP still admits the frame.
+            const headers = {
+                "access-control-allow-origin": "*",
+                "cache-control": "no-store",
+                vary: "Origin",
+            };
+            const site = await route(context);
+            if (site === null)
+                return context.json({ error: "unmapped" }, 404, headers);
+            const channels = __addDisposableResource(env_2, await host.openSite(context, site), false);
+            const facts = await channels.readChannelSite({
+                bindingId: site.bindingId,
+                siteKey: context.req.param("siteKey"),
+            });
+            return facts === null
+                ? context.json({ error: "unmapped" }, 404, headers)
+                : context.json({
+                    accent: facts.accent ?? null,
+                    originAllowed: originAllowed(facts.origins, context.req.header("origin") ?? new URL(context.req.url).origin),
+                }, 200, headers);
+        }
+        catch (e_2) {
+            env_2.error = e_2;
+            env_2.hasError = true;
+        }
+        finally {
+            __disposeResources(env_2);
+        }
+    })
+        .post("/api/embed/v1/sites/:siteKey/visitors", async (context) => {
+        const env_3 = { stack: [], error: void 0, hasError: false };
+        try {
+            if (!sameOrigin(context))
+                return context.json({ error: "forbidden" }, 403);
+            // Validate the host's address-key configuration before touching owners.
+            const hash = await host.addressHash(context);
+            const site = await route(context);
+            if (site === null)
+                return denied("unmapped");
+            const channels = __addDisposableResource(env_3, await host.openSite(context, site), false);
+            const grant = await channels.mintChannelVisitor({
+                bindingId: site.bindingId,
+                siteKey: context.req.param("siteKey"),
+                addressHash: hash,
+            });
+            return grant.kind === "granted"
+                ? Response.json(grant.credentials, {
+                    status: 201,
+                    headers: { "cache-control": "no-store" },
+                })
+                : denied(grant.reason);
+        }
+        catch (e_3) {
+            env_3.error = e_3;
+            env_3.hasError = true;
+        }
+        finally {
+            __disposeResources(env_3);
+        }
+    })
+        .post("/api/embed/v1/sites/:siteKey/visitors/refresh", async (context) => {
+        const env_4 = { stack: [], error: void 0, hasError: false };
+        try {
+            if (!sameOrigin(context))
+                return context.json({ error: "forbidden" }, 403);
+            const site = await route(context);
+            if (site === null)
+                return denied("unmapped");
+            const decoded = await context.req.json().then((value) => ({
+                kind: "decoded",
+                result: refreshSchema.safeParse(value),
+            }), (cause) => ({ kind: "malformed", cause }));
+            if (decoded.kind === "malformed" || !decoded.result.success)
+                return context.json({ error: "invalid_input" }, 400);
+            const body = decoded.result;
+            const channels = __addDisposableResource(env_4, await host.openSite(context, site), false);
+            const grant = await channels.refreshChannelVisitor({
+                bindingId: site.bindingId,
+                refreshSecret: body.data.refreshSecret,
+            });
+            return grant.kind === "granted"
+                ? Response.json(grant.credentials, {
+                    headers: { "cache-control": "no-store" },
+                })
+                : denied(grant.reason);
+        }
+        catch (e_4) {
+            env_4.error = e_4;
+            env_4.hasError = true;
+        }
+        finally {
+            __disposeResources(env_4);
+        }
+    })
+        .post("/api/embed/v1/sites/:siteKey/visitors/rotate", async (context) => {
+        const env_5 = { stack: [], error: void 0, hasError: false };
+        try {
+            if (!sameOrigin(context))
+                return context.json({ error: "forbidden" }, 403);
+            const token = bearer(context);
+            if (token === null)
+                return context.json({ error: "unauthorized" }, 401);
+            const site = await route(context);
+            if (site === null)
+                return denied("unmapped");
+            const channels = __addDisposableResource(env_5, await host.openSite(context, site), false);
+            const grant = await channels.rotateChannelVisitor({
+                bindingId: site.bindingId,
+                siteKey: context.req.param("siteKey"),
+                accessToken: token,
+                addressHash: await host.addressHash(context),
+            });
+            if (grant.kind === "unauthorized")
+                return context.json({ error: "unauthorized" }, 401);
+            return grant.kind === "granted"
+                ? Response.json(grant.credentials, {
+                    status: 201,
+                    headers: { "cache-control": "no-store" },
+                })
+                : denied(grant.reason);
+        }
+        catch (e_5) {
+            env_5.error = e_5;
+            env_5.hasError = true;
+        }
+        finally {
+            __disposeResources(env_5);
+        }
+    })
+        .post("/api/embed/v1/sites/:siteKey/messages", async (context) => {
+        const env_6 = { stack: [], error: void 0, hasError: false };
+        try {
+            if (!sameOrigin(context))
+                return context.json({ error: "forbidden" }, 403);
+            const token = bearer(context);
+            if (token === null)
+                return context.json({ error: "unauthorized" }, 401);
+            const site = await route(context);
+            if (site === null)
+                return denied("unmapped");
+            const raw = await context.req.text();
+            if (raw.length > 32_000)
+                return denied("too_long");
+            const json = decodeJson(raw);
+            if (Option.isNone(json))
+                return context.json({ error: "invalid_input" }, 400);
+            const body = messageSchema.safeParse(json.value);
+            if (!body.success)
+                return context.json({ error: "invalid_input" }, 400);
+            const opened = await visitorChannel(context, site, token);
+            if (opened === null)
+                return context.json({ error: "unauthorized" }, 401);
+            const channels = __addDisposableResource(env_6, opened, false);
+            const result = await channels.sendAsChannelVisitor({
+                bindingId: site.bindingId,
+                accessToken: token,
+                requestId: body.data.requestId,
+                text: body.data.text,
+            });
+            return result.kind === "unauthorized"
+                ? context.json({ error: "unauthorized" }, 401)
+                : intakeResponse(result);
+        }
+        catch (e_6) {
+            env_6.error = e_6;
+            env_6.hasError = true;
+        }
+        finally {
+            __disposeResources(env_6);
+        }
+    })
+        .post("/api/embed/v1/sites/:siteKey/requests/withdraw", async (context) => {
+        const env_7 = { stack: [], error: void 0, hasError: false };
+        try {
+            if (!sameOrigin(context))
+                return context.json({ error: "forbidden" }, 403);
+            const token = bearer(context);
+            if (token === null)
+                return context.json({ error: "unauthorized" }, 401);
+            const site = await route(context);
+            if (site === null)
+                return denied("unmapped");
+            const raw = await context.req.text();
+            if (raw.length > 2_048)
+                return denied("too_long");
+            const json = decodeJson(raw);
+            if (Option.isNone(json))
+                return context.json({ error: "invalid_input" }, 400);
+            const body = visitorRequestSchema.safeParse(json.value);
+            if (!body.success)
+                return context.json({ error: "invalid_input" }, 400);
+            const opened = await visitorChannel(context, site, token);
+            if (opened === null)
+                return context.json({ error: "unauthorized" }, 401);
+            const channels = __addDisposableResource(env_7, opened, false);
+            const result = await channels.withdrawAsChannelVisitor({
+                bindingId: site.bindingId,
+                accessToken: token,
+                requestId: body.data.requestId,
+            });
+            if ("kind" in result)
+                return result.kind === "unauthorized"
+                    ? context.json({ error: "unauthorized" }, 401)
+                    : denied(result.reason);
+            return Response.json(result, {
+                headers: { "cache-control": "no-store" },
+            });
+        }
+        catch (e_7) {
+            env_7.error = e_7;
+            env_7.hasError = true;
+        }
+        finally {
+            __disposeResources(env_7);
+        }
+    })
+        .get("/api/embed/v1/sites/:siteKey/conversation/pending/latest", async (context) => {
+        const env_8 = { stack: [], error: void 0, hasError: false };
+        try {
+            if (!sameOriginReadRequest(context.req.raw))
+                return context.json({ error: "forbidden" }, 403);
+            const token = bearer(context);
+            if (token === null)
+                return context.json({ error: "unauthorized" }, 401);
+            const site = await route(context);
+            if (site === null)
+                return denied("unmapped");
+            const opened = await visitorChannel(context, site, token);
+            if (opened === null)
+                return context.json({ error: "unauthorized" }, 401);
+            const channels = __addDisposableResource(env_8, opened, false);
+            const result = await channels.latestPendingAsChannelVisitor({
+                bindingId: site.bindingId,
+                accessToken: token,
+            });
+            if (result !== null && "kind" in result)
+                return context.json({ error: "unauthorized" }, 401);
+            return Response.json(result, {
+                headers: { "cache-control": "no-store" },
+            });
+        }
+        catch (e_8) {
+            env_8.error = e_8;
+            env_8.hasError = true;
+        }
+        finally {
+            __disposeResources(env_8);
+        }
+    })
+        .get("/api/embed/v1/sites/:siteKey/conversation/events", async (context) => {
+        const env_9 = { stack: [], error: void 0, hasError: false };
+        try {
+            if (!sameOriginReadRequest(context.req.raw))
+                return context.json({ error: "forbidden" }, 403);
+            const token = bearer(context);
+            if (token === null)
+                return context.json({ error: "unauthorized" }, 401);
+            const site = await route(context);
+            if (site === null)
+                return denied("unmapped");
+            const channel = await visitorChannel(context, site, token);
+            if (channel === null)
+                return context.json({ error: "unauthorized" }, 401);
+            const channels = __addDisposableResource(env_9, channel, false);
+            const opened = await channels.watchAsChannelVisitor({
+                bindingId: site.bindingId,
+                accessToken: token,
+            });
+            if (opened.kind === "unauthorized")
+                return context.json({ error: "unauthorized" }, 401);
+            if (opened.kind === "denied")
+                return denied(opened.reason);
+            if (opened.kind === "empty")
+                return context.body(null, 204);
+            return new Response(opened.body, {
+                headers: {
+                    "content-type": "text/event-stream",
+                    "cache-control": "no-store",
+                    "x-accel-buffering": "no",
+                },
+            });
+        }
+        catch (e_9) {
+            env_9.error = e_9;
+            env_9.hasError = true;
+        }
+        finally {
+            __disposeResources(env_9);
+        }
+    })
+        .post("/api/embed/v1/sites/:siteKey/session", async (context) => {
+        const env_10 = { stack: [], error: void 0, hasError: false };
+        try {
+            if (!sameOrigin(context))
+                return context.json({ error: "forbidden" }, 403);
+            const token = bearer(context);
+            if (token === null)
+                return context.json({ error: "unauthorized" }, 401);
+            const site = await route(context);
+            if (site === null)
+                return denied("unmapped");
+            const raw = await context.req.text();
+            if (raw.length > 4096)
+                return context.json({ error: "invalid_input" }, 400);
+            const json = decodeJson(raw);
+            if (Option.isNone(json))
+                return context.json({ error: "invalid_input" }, 400);
+            const decoded = sessionReadSchema.safeParse(json.value);
+            if (!decoded.success)
+                return context.json({ error: "invalid_input" }, 400);
+            const channel = await visitorChannel(context, site, token);
+            if (channel === null)
+                return context.json({ error: "unauthorized" }, 401);
+            const channels = __addDisposableResource(env_10, channel, false);
+            const opened = await channels.openVisitorSession({
+                bindingId: site.bindingId,
+                accessToken: token,
+                options: decoded.data,
+            });
+            if (opened.kind === "unauthorized")
+                return context.json({ error: "unauthorized" }, 401);
+            if (opened.kind === "denied")
+                return denied(opened.reason);
+            return new Response(opened.snapshot, {
+                headers: {
+                    "content-type": "application/json",
+                    "cache-control": "no-store",
+                },
+            });
+        }
+        catch (e_10) {
+            env_10.error = e_10;
+            env_10.hasError = true;
+        }
+        finally {
+            __disposeResources(env_10);
+        }
+    })
+        .get("/api/embed/v1/sites/:siteKey/conversation", async (context) => {
+        const env_11 = { stack: [], error: void 0, hasError: false };
+        try {
+            const token = bearer(context);
+            if (token === null)
+                return context.json({ error: "unauthorized" }, 401);
+            const site = await route(context);
+            if (site === null)
+                return denied("unmapped");
+            // Retained legacy read: do not change its site-owner path in this slice.
+            const channels = __addDisposableResource(env_11, await host.openSite(context, site), false);
+            const result = await channels.readAsChannelVisitor({
+                bindingId: site.bindingId,
+                accessToken: token,
+            });
+            return result.kind === "unauthorized"
+                ? context.json({ error: "unauthorized" }, 401)
+                : Response.json(result.view, {
+                    headers: { "cache-control": "no-store" },
+                });
+        }
+        catch (e_11) {
+            env_11.error = e_11;
+            env_11.hasError = true;
+        }
+        finally {
+            __disposeResources(env_11);
+        }
+    });
+}

package/dist/channels/visitor-request.d.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+/** The original caller key, carried separately from channel and owner identities. */
+export declare const visitorRequestSchema: z.ZodObject<{
+    requestId: z.ZodLazy<z.ZodString>;
+}, z.core.$strict>;
+/** Native hashing keeps the existing channel identity; it is never an inverse correlation. */
+export declare function visitorMessageId(requestId: string): Promise<string>;

package/dist/channels/visitor-request.js

@@ -0,0 +1,17 @@
+import { z } from "zod";
+import { FungiMessageMetaSchema } from "@fungi.computer/agar/agents";
+import { channelIds } from "./ids.js";
+/** The original caller key, carried separately from channel and owner identities. */
+export const visitorRequestSchema = z.strictObject({
+    requestId: FungiMessageMetaSchema.shape.sourceRequestId.unwrap(),
+});
+/** Native hashing keeps the existing channel identity; it is never an inverse correlation. */
+export async function visitorMessageId(requestId) {
+    const input = visitorRequestSchema.parse({ requestId });
+    const hash = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(input.requestId));
+    const suffix = BigInt(`0x${Array.from(new Uint8Array(hash), (byte) => byte.toString(16).padStart(2, "0")).join("")}`)
+        .toString(36)
+        .padStart(21, "0")
+        .slice(0, 21);
+    return channelIds.message.schema.parse(`msg_${suffix}`);
+}

package/dist/channels/visitor-stream-slots.d.ts

@@ -0,0 +1,2 @@
+/** Shared stream caps, independent of the host's Session watch and SSE pump. */
+export declare function createVisitorStreamSlots(): (bindingId: string, visitorId: string, addressHash: string) => (() => void) | null;

package/dist/channels/visitor-stream-slots.js

@@ -0,0 +1,33 @@
+/** Shared stream caps, independent of the host's Session watch and SSE pump. */
+export function createVisitorStreamSlots() {
+    const visitors = new Map();
+    const bindings = new Map();
+    const addresses = new Map();
+    return (bindingId, visitorId, addressHash) => {
+        const address = bindingId + ":" + addressHash;
+        if ((visitors.get(visitorId) ?? 0) >= 2 ||
+            (bindings.get(bindingId) ?? 0) >= 32 ||
+            (addresses.get(address) ?? 0) >= 8)
+            return null;
+        const entries = [
+            [visitors, visitorId],
+            [bindings, bindingId],
+            [addresses, address],
+        ];
+        for (const [counts, key] of entries)
+            counts.set(key, (counts.get(key) ?? 0) + 1);
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            for (const [counts, key] of entries) {
+                const remaining = (counts.get(key) ?? 1) - 1;
+                if (remaining === 0)
+                    counts.delete(key);
+                else
+                    counts.set(key, remaining);
+            }
+        };
+    };
+}