@noodleseed/one 0.176.0 → 0.177.0

package/node_modules/@noodle-borg/service/dist/conversation-history/operator.js

@@ -0,0 +1,184 @@
+import { createHmac } from 'node:crypto';
+import { canonicalJson } from '@noodle-borg/compiler';
+import { ConversationExportResponseSchema, ConversationForgetRequestSchema, ConversationForgetResponseSchema, ConversationIdSchema, ConversationListResponseSchema, ConversationShowResponseSchema, } from '@noodle-borg/wire-contracts';
+const runLocal = (operation) => operation();
+const MESSAGES = {
+    conversation_invalid: 'Invalid conversation request.',
+    conversation_not_found: 'Conversation not found.',
+    conversation_unavailable: 'Conversation history is unavailable.',
+};
+export class ConversationHistoryError extends Error {
+    code;
+    constructor(code) {
+        super(MESSAGES[code]);
+        this.code = code;
+    }
+}
+const PAGE = { list: { default: 50, maximum: 100 }, export: { default: 25, maximum: 25 } };
+/**
+ * The staff projection of conversation history (ADR 0241). Callers authorize before and after, and every
+ * read, export and forget returns identifier-only audit details; message text never reaches audit.
+ */
+export class ApplicationConversations {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async project(scope, action, input, local = runLocal) {
+        const tenant = { org: scope.org, app: scope.app, env: scope.env };
+        const allowed = action === 'list' || action === 'export' ? ['limit', 'cursor', 'channel'] : [];
+        const parameters = new Map();
+        for (const [key, value] of input.parameters) {
+            if (!allowed.includes(key) || parameters.has(key))
+                throw invalid();
+            parameters.set(key, value);
+        }
+        const audit = (eventType, details) => ({
+            eventType,
+            details,
+        });
+        if (action === 'forget') {
+            const parsed = ConversationForgetRequestSchema.safeParse(input.body);
+            if (!parsed.success)
+                throw invalid();
+            const request = parsed.data;
+            const forgotten = await local(() => 'conversationId' in request
+                ? this.options.store.forget(tenant, request.conversationId)
+                : this.options.store.forgetSubject(tenant, request.subject));
+            return {
+                response: ConversationForgetResponseSchema.parse({ ok: true, data: { forgotten } }),
+                audit: audit('conversation.forgotten', {
+                    conversations: forgotten.conversations,
+                    items: forgotten.items,
+                    kind: 'conversationId' in request ? 'conversation' : request.subject.kind,
+                }),
+            };
+        }
+        if (action === 'show') {
+            const id = ConversationIdSchema.safeParse(input.conversationId);
+            if (!id.success)
+                throw new ConversationHistoryError('conversation_not_found');
+            const conversation = await local(() => this.options.store.read(tenant, id.data, this.#now()));
+            if (!conversation)
+                throw new ConversationHistoryError('conversation_not_found');
+            return {
+                response: ConversationShowResponseSchema.parse({
+                    ok: true,
+                    data: { conversation: detail(conversation) },
+                }),
+                audit: audit('conversation.read', { conversationId: id.data }),
+            };
+        }
+        const page = await this.#page(scope, tenant, action, parameters, local);
+        if (action === 'list')
+            return {
+                response: ConversationListResponseSchema.parse({
+                    ok: true,
+                    data: {
+                        conversations: page.summaries.map(summary),
+                        ...(page.nextCursor ? { nextCursor: page.nextCursor } : {}),
+                    },
+                }),
+            };
+        const conversations = await local(async () => {
+            const now = this.#now();
+            const read = await Promise.all(page.summaries.map((row) => this.options.store.read(tenant, row.id, now)));
+            return read.filter((row) => row !== undefined).map(detail);
+        });
+        return {
+            response: ConversationExportResponseSchema.parse({
+                ok: true,
+                data: {
+                    conversations,
+                    ...(page.nextCursor ? { nextCursor: page.nextCursor } : {}),
+                },
+            }),
+            audit: audit('conversation.exported', { count: conversations.length }),
+        };
+    }
+    async #page(scope, tenant, purpose, parameters, local) {
+        const bounds = PAGE[purpose];
+        const limit = parameters.has('limit') ? Number(parameters.get('limit')) : bounds.default;
+        const channel = parameters.get('channel');
+        const cursor = parameters.get('cursor');
+        if (!Number.isInteger(limit) ||
+            limit < 1 ||
+            limit > bounds.maximum ||
+            (channel !== undefined && channel !== 'website' && channel !== 'whatsapp') ||
+            (cursor !== undefined && (!cursor || cursor.length > 2048)))
+            throw invalid();
+        const binding = this.#hash({
+            purpose: `conversations-${purpose}-v1`,
+            scope,
+            limit,
+            channel: channel ?? null,
+        });
+        const after = decodeConversationCursor(cursor, binding);
+        const rows = await local(() => this.options.store.list(tenant, {
+            now: this.#now(),
+            limit: limit + 1,
+            ...(after ? { after } : {}),
+            ...(channel ? { channel: channel } : {}),
+        }));
+        const summaries = rows.slice(0, limit);
+        const last = summaries.at(-1);
+        return {
+            summaries,
+            nextCursor: rows.length > limit && last
+                ? Buffer.from(JSON.stringify({ binding, lastMessageAt: last.lastMessageAt, id: last.id })).toString('base64url')
+                : undefined,
+        };
+    }
+    #now() {
+        return this.options.now?.() ?? Date.now();
+    }
+    #hash(value) {
+        return createHmac('sha256', this.options.identityKey)
+            .update(canonicalJson(value))
+            .digest('hex');
+    }
+}
+function invalid() {
+    return new ConversationHistoryError('conversation_invalid');
+}
+function summary(row) {
+    return {
+        id: row.id,
+        channel: row.channel,
+        subject: row.subject.kind === 'anonymous' ? { kind: 'anonymous' } : row.subject,
+        startedAt: new Date(row.startedAt).toISOString(),
+        lastMessageAt: new Date(row.lastMessageAt).toISOString(),
+        itemCount: row.itemCount,
+    };
+}
+function detail(conversation) {
+    return {
+        ...summary({ ...conversation, itemCount: conversation.items.length }),
+        items: conversation.items.map((item) => item.kind === 'message'
+            ? { kind: item.kind, role: item.role, text: item.text, at: new Date(item.at).toISOString() }
+            : {
+                kind: item.kind,
+                interactionId: item.interactionId,
+                tool: item.tool,
+                status: item.status,
+                at: new Date(item.at).toISOString(),
+            }),
+    };
+}
+function decodeConversationCursor(raw, binding) {
+    if (raw === undefined)
+        return undefined;
+    try {
+        const value = JSON.parse(Buffer.from(raw, 'base64url').toString());
+        if (value.binding !== binding ||
+            !Number.isSafeInteger(value.lastMessageAt) ||
+            value.lastMessageAt < 0 ||
+            !ConversationIdSchema.safeParse(value.id).success)
+            throw new Error();
+        return { lastMessageAt: value.lastMessageAt, id: value.id };
+    }
+    catch {
+        throw invalid();
+    }
+}
+//# sourceMappingURL=operator.js.map

package/node_modules/@noodle-borg/service/dist/routes/business-information-conversations.js

@@ -0,0 +1,65 @@
+import { readJsonBody, sendJson } from '@noodle-borg/transport-http';
+import { ConversationHistoryError, } from '../conversation-history/operator.js';
+import { requireIdentity, requireInstallationPermission, } from './business-information.js';
+/** ADR 0241 decision 10: readers see text; only export and erasure need Owner/Administrator authority. */
+const PERMISSIONS = {
+    list: 'records:read',
+    show: 'records:read',
+    export: 'records:export',
+    forget: 'records:delete',
+};
+export async function handleApplicationConversations(req, res, url, ref, deps) {
+    const action = ref.conversationAction ?? 'list';
+    const method = action === 'forget' ? 'POST' : 'GET';
+    if (req.method !== method) {
+        res.setHeader('allow', method);
+        return sendJson(res, 405, { error: 'method not allowed' });
+    }
+    const identity = await requireIdentity(req, res, deps);
+    if (identity === false)
+        return;
+    const permission = PERMISSIONS[action];
+    const authorize = () => requireInstallationPermission(res, ref, identity, permission, deps);
+    const authorized = await authorize();
+    if (!authorized)
+        return;
+    res.setHeader('cache-control', 'private, no-store');
+    try {
+        if (!deps.conversations)
+            throw new ConversationHistoryError('conversation_unavailable');
+        let body;
+        if (method === 'POST') {
+            const parsed = await readJsonBody(req, deps.maxBody);
+            if (!parsed.ok)
+                return sendJson(res, parsed.status, { error: parsed.error });
+            body = parsed.value;
+            if (!(await authorize()))
+                return;
+        }
+        const result = await deps.conversations.project(authorized.scope, action, {
+            parameters: [...url.searchParams.entries()],
+            ...(ref.conversationId === undefined ? {} : { conversationId: ref.conversationId }),
+            body,
+        }, (operation) => deps.store.staff.run(authorized.scope, identity.subject, permission, operation));
+        if ('audit' in result && result.audit)
+            await deps.audit?.emit({
+                ...result.audit,
+                org: ref.org,
+                app: authorized.scope.app,
+                env: authorized.scope.env,
+                actorSubject: identity.subject,
+            });
+        if (await authorize())
+            sendJson(res, 200, result.response);
+    }
+    catch (error) {
+        if (!(error instanceof ConversationHistoryError))
+            throw error;
+        sendJson(res, error.code === 'conversation_not_found'
+            ? 404
+            : error.code === 'conversation_unavailable'
+                ? 503
+                : 400, { code: error.code, error: error.message });
+    }
+}
+//# sourceMappingURL=business-information-conversations.js.map

package/node_modules/@noodle-borg/service/dist/routes/business-information-dispatch.js

@@ -12,6 +12,7 @@ import { handleBusinessGrants, handleManagedRecords, handleSolutionCatalog, hand
 import { handleApplicationActivity, } from './business-information-activity.js';
 import { handleBusinessChannels, } from './business-information-channels.js';
 import { handleApplicationConnectionCallback, handleApplicationConnections, } from './business-information-connections.js';
+import { handleApplicationConversations, } from './business-information-conversations.js';
 import { handleBusinessNotice, handleOrganizationAgreement, } from './business-information-notice.js';
 import { handleSolutionInstallationOptions } from './business-information-onboarding.js';
 import { handleBusinessPage, handlePublicBusinessPage } from './business-information-pages.js';
@@ -81,6 +82,8 @@ export function dispatchBusinessInformationRoutes(req, res, url, deps) {
     if ((installationRef.action === 'activity' || installationRef.action === 'coordination') &&
         installationRef.collection === undefined)
         return run(req, res, deps, () => handleApplicationActivity(req, res, url, installationRef, deps));
+    if (installationRef.action === 'conversations')
+        return run(req, res, deps, () => handleApplicationConversations(req, res, url, installationRef, deps));
     if (installationRef.action === 'connections')
         return run(req, res, deps, () => handleApplicationConnections(req, res, installationRef, deps));
     if (installationRef.action === 'settings') {

package/node_modules/@noodle-borg/service/dist/routes/business-information-paths.js

@@ -27,6 +27,22 @@ export function parseSolutionInstallationPath(pathname) {
                 ...(connectionAction === undefined ? {} : { connectionAction }),
             };
     }
+    const conversations = /^\/v1\/orgs\/([^/]+)\/solution-installations\/([^/]+)\/conversations(?:\/(export|forget|cv_[A-Za-z0-9_-]{8,64}))?$/.exec(pathname);
+    if (conversations !== null) {
+        const org = decoded(conversations, 1), installationId = decoded(conversations, 2), segment = conversations[3];
+        return org === undefined || installationId === undefined
+            ? undefined
+            : {
+                org,
+                installationId,
+                action: 'conversations',
+                ...(segment === undefined
+                    ? { conversationAction: 'list' }
+                    : segment === 'export' || segment === 'forget'
+                        ? { conversationAction: segment }
+                        : { conversationAction: 'show', conversationId: segment }),
+            };
+    }
     const application = /^\/v1\/orgs\/([^/]+)\/solution-installations\/([^/]+)\/(activate|settings|notice|record-lifecycle|channels|operations\/coordination(?:\/resolve)?|activity(?:\/(?:settings|export|preview))?)$/.exec(pathname);
     if (application !== null) {
         const org = decoded(application, 1);

package/node_modules/@noodle-borg/service/dist/service-history-projections.js

@@ -0,0 +1,24 @@
+import { randomBytes } from 'node:crypto';
+import { ApplicationActivity } from './application-activity.js';
+import { ApplicationConversations } from './conversation-history/operator.js';
+/** Installation history projections over the optional durable stores the service was given. */
+export function createHistoryProjections(options, moduleHost) {
+    const activity = options.operationEvidence === undefined
+        ? undefined
+        : new ApplicationActivity({
+            ...options.operationEvidence,
+            allowance: async (org, request) => moduleHost.resolveActivityHistoryAllowance?.(org, request),
+        });
+    const history = options.conversationHistory;
+    const conversations = history === undefined
+        ? undefined
+        : new ApplicationConversations({
+            store: history.store,
+            identityKey: history.identityKey ?? randomBytes(32).toString('hex'),
+            ...(options.clock === undefined
+                ? {}
+                : { now: () => options.clock?.().getTime() ?? Date.now() }),
+        });
+    return { activity, conversations };
+}
+//# sourceMappingURL=service-history-projections.js.map

package/node_modules/@noodle-borg/service/dist/service.js

@@ -6,7 +6,6 @@ import { capabilityOperatorRoute } from '@noodle-borg/managed-capabilities';
 import { OPENAI_APPS_CHALLENGE_PATH } from '@noodle-borg/module';
 import { applySecurityHeaders, createMcpRouter, enforceHttps, noopLogger, sendJson, } from '@noodle-borg/transport-http';
 import { AnonymousConsumerLimiter, createAdmissionGate } from './admission.js';
-import { ApplicationActivity } from './application-activity.js';
 import { createApplicationServingRuntime } from './application-runtime-target.js';
 import { createArchivePreflight } from './archive-preflight.js';
 import { ArchiveSweeper, resolveArchiveRetentionDays } from './archive-sweeper.js';
@@ -55,6 +54,7 @@ import { handleRollback } from './routes/rollback.js';
 import { createServicePrincipalDispatcher } from './routes/service-principals-dispatch.js';
 import { createServiceProbeDispatcher } from './routes/service-probes.js';
 import { dispatchWhatsAppRoutes } from './routes/whatsapp.js';
+import { createHistoryProjections } from './service-history-projections.js';
 import { servicePrincipalDataPlaneHooks } from './service-principal-data-plane.js';
 import { InMemoryAlertRuleStore } from './store/alert-rules.js';
 import { StdoutAuditSink } from './store/audit.js';
@@ -95,12 +95,7 @@ export function createServiceHandler(registry, options = {}) {
     activeAudit = audit;
     const { publicTenantRouting } = mcp.mcpRoutingOptions(options, controlPlane);
     const resolveEndpointOptions = (org) => mcp.endpointUrlOptionsForOrg(options, controlPlane, org);
-    const activity = options.operationEvidence === undefined
-        ? undefined
-        : new ApplicationActivity({
-            ...options.operationEvidence,
-            allowance: async (org, request) => moduleHost.resolveActivityHistoryAllowance?.(org, request),
-        });
+    const { activity, conversations } = createHistoryProjections(options, moduleHost);
     const withIntentMode = createIntentTargetResolver(intentSettings, intentPreviewOrgs);
     const { activateInstallation, readInstallationActivation, resolveRuntimeTarget, businessOnboarding, } = createApplicationServingRuntime(registry, providerOptions, controlPlane, audit, activity);
     const runtimeTarget = async (target) => target === undefined ? undefined : resolveRuntimeTarget(target);
@@ -314,6 +309,7 @@ export function createServiceHandler(registry, options = {}) {
                 activateInstallation,
                 readInstallationActivation,
                 ...(activity === undefined ? {} : { activity }),
+                ...(conversations === undefined ? {} : { conversations }),
                 ...(options.connectionRuntime === undefined
                     ? {}
                     : {