@noodleseed/one 0.170.0 → 0.171.0

package/node_modules/@noodle-borg/module-audit/dist/route.js

@@ -0,0 +1,66 @@
+export function createAuditEventsRoute(store) {
+    return {
+        id: 'audit.events',
+        match: (method, url) => method === 'GET' && url.pathname === '/v1/audit/events',
+        handle: async (req, res, ctx) => {
+            if (ctx.controlPlane === undefined) {
+                return sendJson(res, 401, { error: 'control-plane authentication required' });
+            }
+            const auth = await ctx.controlPlane.authorize(req);
+            if (!auth.ok) {
+                return sendJson(res, auth.status, { error: auth.message });
+            }
+            if (auth.identity === undefined) {
+                return sendJson(res, 401, { error: 'identity required' });
+            }
+            if (!auth.identity.superAdmin) {
+                return sendJson(res, 403, { error: 'forbidden' });
+            }
+            const url = new URL(req.url ?? '/', 'http://localhost');
+            const org = url.searchParams.get('org');
+            if (org === null || org.length === 0) {
+                return sendJson(res, 400, { error: 'org query parameter is required' });
+            }
+            try {
+                const filter = auditFilterFromQuery(url, org);
+                const events = await store.list(filter);
+                return sendJson(res, 200, { ok: true, events });
+            }
+            catch (error) {
+                return sendJson(res, 400, { error: error.message });
+            }
+        },
+    };
+}
+function auditFilterFromQuery(url, org) {
+    const app = optionalQuery(url, 'app');
+    const env = optionalQuery(url, 'env');
+    const eventType = optionalQuery(url, 'eventType');
+    const limit = parseLimit(optionalQuery(url, 'limit'));
+    return {
+        org,
+        ...(app !== undefined ? { app } : {}),
+        ...(env !== undefined ? { env } : {}),
+        ...(eventType !== undefined ? { eventType } : {}),
+        ...(limit !== undefined ? { limit } : {}),
+    };
+}
+function optionalQuery(url, key) {
+    const value = url.searchParams.get(key);
+    return value !== null && value.length > 0 ? value : undefined;
+}
+function parseLimit(value) {
+    if (value === undefined)
+        return undefined;
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 1 || parsed > 500) {
+        throw new Error('limit must be an integer from 1 to 500');
+    }
+    return parsed;
+}
+function sendJson(res, status, body) {
+    res.statusCode = status;
+    res.setHeader('content-type', 'application/json');
+    res.end(JSON.stringify(body));
+}
+//# sourceMappingURL=route.js.map

package/node_modules/@noodle-borg/runtime/dist/managed-origins.js

@@ -14,10 +14,12 @@ export function resolveManagedOrigins(artifact, variables, options = {}) {
             ...(assistant.surfaces === undefined
                 ? {}
                 : {
-                    surfaces: assistant.surfaces.map((surface, index) => ({
-                        ...surface,
-                        origins: resolveList(surface.origins, `server.assistant.surfaces.${index}.origins`, true),
-                    })),
+                    surfaces: assistant.surfaces.map((surface, index) => surface.kind === 'messaging'
+                        ? surface
+                        : {
+                            ...surface,
+                            origins: resolveList(surface.origins, `server.assistant.surfaces.${index}.origins`, true),
+                        }),
                 }),
         };
     const handoff = artifact.server.handoff;
@@ -29,6 +31,8 @@ export function resolveManagedOrigins(artifact, variables, options = {}) {
         };
     const owners = new Map();
     resolvedAssistant?.surfaces?.forEach((surface, index) => {
+        if (surface.kind === 'messaging')
+            return;
         for (const origin of surface.origins) {
             const prior = owners.get(origin);
             if (prior !== undefined && prior !== index)

package/node_modules/@noodle-borg/runtime/dist/postgres-state-handles.js

@@ -0,0 +1,311 @@
+import { assertExpectedStateRevision, assertNoSecretValue, assertSchemaValue, assertStateHandleNotCompleted, createMutableStateHandleRecord, stateHandleRecordForMutation, toPublicStateHandleRecord, } from './state-handles.js';
+/** Covers a request admitted just before the anonymous session's absolute expiry. */
+const STATE_OWNER_REDIRECT_GRACE_MS = 5 * 60 * 1000;
+export class PostgresStateHandleStore {
+    #pool;
+    #deploymentId;
+    #state;
+    #now;
+    constructor(pool, options) {
+        this.#pool = pool;
+        this.#deploymentId = options.deploymentId;
+        this.#state = options.state;
+        this.#now = options.now ?? (() => new Date());
+    }
+    async read(input) {
+        const def = this.#definition(input.handle);
+        const owner = ownerKey(def, input);
+        const key = input.key ?? 'default';
+        const read = async (client) => {
+            const nowDate = this.#now();
+            const resolvedOwner = def.claimOnAuthentication === true
+                ? await resolveOperationOwner(client, this.#deploymentId, input.handle, owner, nowDate)
+                : owner;
+            const row = await selectRow(client, this.#deploymentId, input.handle, resolvedOwner, key);
+            const now = nowDate.getTime();
+            if (row === undefined) {
+                return toPublicStateHandleRecord(createMutableStateHandleRecord(input.handle, key, def.ttlSeconds, now), now);
+            }
+            assertVersion(row, def);
+            return toPublicStateHandleRecord(mutableFromRow(row), now);
+        };
+        return def.claimOnAuthentication === true
+            ? this.#withTransaction((client) => read(client))
+            : read(this.#pool);
+    }
+    async patch(input) {
+        return this.#withTransaction(async (client) => {
+            const def = this.#definition(input.handle);
+            const owner = ownerKey(def, input);
+            const key = input.key ?? 'default';
+            const nowDate = this.#now();
+            const resolvedOwner = def.claimOnAuthentication === true
+                ? await resolveOperationOwner(client, this.#deploymentId, input.handle, owner, nowDate)
+                : owner;
+            const row = await selectRow(client, this.#deploymentId, input.handle, resolvedOwner, key, true);
+            if (row !== undefined)
+                assertVersion(row, def);
+            const now = nowDate.getTime();
+            const current = stateHandleRecordForMutation(row ? mutableFromRow(row) : undefined, input.handle, key, def.ttlSeconds, now);
+            assertStateHandleNotCompleted(current);
+            assertExpectedStateRevision(current, input.expectedRevision);
+            assertNoSecretValue(input.value);
+            const value = { ...current.value, ...input.value };
+            assertSchemaValue(def.schema, value);
+            const next = {
+                ...current,
+                value,
+                revision: current.revision + 1,
+                updatedAt: now,
+            };
+            await upsertRow(client, this.#deploymentId, resolvedOwner, def.version, next);
+            return toPublicStateHandleRecord(next, now);
+        });
+    }
+    async complete(input) {
+        return this.#withTransaction(async (client) => {
+            const def = this.#definition(input.handle);
+            const owner = ownerKey(def, input);
+            const key = input.key ?? 'default';
+            const nowDate = this.#now();
+            const resolvedOwner = def.claimOnAuthentication === true
+                ? await resolveOperationOwner(client, this.#deploymentId, input.handle, owner, nowDate)
+                : owner;
+            const row = await selectRow(client, this.#deploymentId, input.handle, resolvedOwner, key, true);
+            if (row !== undefined)
+                assertVersion(row, def);
+            const now = nowDate.getTime();
+            const current = stateHandleRecordForMutation(row ? mutableFromRow(row) : undefined, input.handle, key, def.ttlSeconds, now);
+            assertStateHandleNotCompleted(current);
+            assertExpectedStateRevision(current, input.expectedRevision);
+            const next = {
+                ...current,
+                status: 'completed',
+                revision: current.revision + 1,
+                updatedAt: now,
+            };
+            await upsertRow(client, this.#deploymentId, resolvedOwner, def.version, next);
+            return toPublicStateHandleRecord(next, now);
+        });
+    }
+    async pruneExpired() {
+        const result = await this.#pool.query(`DELETE FROM state_handle_records
+       WHERE deployment_id = $1 AND expires_at IS NOT NULL AND expires_at <= $2`, [this.#deploymentId, this.#now()]);
+        await this.#pool.query(`DELETE FROM state_handle_owner_redirects
+       WHERE deployment_id = $1 AND expires_at <= $2`, [this.#deploymentId, new Date(this.#now().getTime() - STATE_OWNER_REDIRECT_GRACE_MS)]);
+        return result.rowCount ?? 0;
+    }
+    #definition(handle) {
+        const def = this.#state.handles[handle];
+        if (def === undefined)
+            throw new Error(`unknown state handle "${handle}"`);
+        return def;
+    }
+    async #withTransaction(work) {
+        const client = await this.#pool.connect();
+        try {
+            await client.query('BEGIN');
+            const result = await work(client);
+            await client.query('COMMIT');
+            return result;
+        }
+        catch (err) {
+            await client.query('ROLLBACK');
+            throw err;
+        }
+        finally {
+            client.release();
+        }
+    }
+}
+export async function ensureStateHandleSchema(pool) {
+    await pool.query(`
+    CREATE TABLE IF NOT EXISTS state_handle_records (
+      deployment_id   text NOT NULL,
+      handle_name     text NOT NULL,
+      owner_key       text NOT NULL,
+      state_key       text NOT NULL,
+      handle_version  text NOT NULL,
+      value           jsonb NOT NULL,
+      revision        bigint NOT NULL,
+      status          text NOT NULL CHECK (status IN ('active', 'completed')),
+      created_at      timestamptz NOT NULL,
+      updated_at      timestamptz NOT NULL,
+      expires_at      timestamptz,
+      PRIMARY KEY (deployment_id, handle_name, owner_key, state_key)
+    )
+  `);
+    await pool.query(`
+    CREATE INDEX IF NOT EXISTS state_handle_records_expiry_idx
+    ON state_handle_records (expires_at)
+    WHERE expires_at IS NOT NULL
+  `);
+    await pool.query(`
+    CREATE TABLE IF NOT EXISTS state_handle_owner_redirects (
+      deployment_id   text NOT NULL,
+      handle_name     text NOT NULL,
+      source_owner_key text NOT NULL,
+      target_owner_key text NOT NULL,
+      created_at      timestamptz NOT NULL,
+      expires_at      timestamptz NOT NULL,
+      PRIMARY KEY (deployment_id, handle_name, source_owner_key),
+      CHECK (source_owner_key <> target_owner_key)
+    )
+  `);
+    await pool.query(`
+    CREATE INDEX IF NOT EXISTS state_handle_owner_redirects_expiry_idx
+    ON state_handle_owner_redirects (expires_at)
+  `);
+}
+/**
+ * Rebind opted-in caller state inside the elevation transaction supplied by assistant-gateway.
+ * Values are never decoded or rewritten: changing only `owner_key` preserves every lifecycle field.
+ */
+export async function adoptCallerState(client, input) {
+    if (input.sourceCallerSubject === input.targetCallerSubject) {
+        return { ok: true, adoptedHandles: [], adoptedRecords: 0 };
+    }
+    const handles = [...new Set(input.handles)].sort();
+    for (const handle of handles) {
+        // Anonymous -> authenticated is directional. Every opted state operation takes the source
+        // lock before following its redirect and then takes the target lock, so the adoption uses the
+        // same order while still serializing concurrent creates under either owner.
+        await lockOwner(client, input.deploymentId, handle, input.sourceCallerSubject);
+        await lockOwner(client, input.deploymentId, handle, input.targetCallerSubject);
+    }
+    if (handles.length === 0) {
+        return { ok: true, adoptedHandles: [], adoptedRecords: 0 };
+    }
+    const redirect = await client.query(`SELECT handle_name, target_owner_key
+     FROM state_handle_owner_redirects
+     WHERE deployment_id = $1
+       AND handle_name = ANY($2::text[])
+       AND source_owner_key = $3
+       AND expires_at > $4`, [
+        input.deploymentId,
+        handles,
+        input.sourceCallerSubject,
+        new Date(input.now.getTime() - STATE_OWNER_REDIRECT_GRACE_MS),
+    ]);
+    if (redirect.rows.some((row) => row.target_owner_key !== input.targetCallerSubject)) {
+        return { ok: false, reason: 'state_key_conflict' };
+    }
+    const collision = await client.query(`SELECT 1
+     FROM state_handle_records AS source
+     JOIN state_handle_records AS target
+       ON target.deployment_id = source.deployment_id
+      AND target.handle_name = source.handle_name
+      AND target.state_key = source.state_key
+     WHERE source.deployment_id = $1
+       AND source.handle_name = ANY($2::text[])
+       AND source.owner_key = $3
+       AND target.owner_key = $4
+     LIMIT 1`, [input.deploymentId, handles, input.sourceCallerSubject, input.targetCallerSubject]);
+    if ((collision.rowCount ?? 0) > 0) {
+        return { ok: false, reason: 'state_key_conflict' };
+    }
+    const moved = await client.query(`UPDATE state_handle_records
+     SET owner_key = $4
+     WHERE deployment_id = $1
+       AND handle_name = ANY($2::text[])
+       AND owner_key = $3`, [input.deploymentId, handles, input.sourceCallerSubject, input.targetCallerSubject]);
+    await client.query(`INSERT INTO state_handle_owner_redirects
+       (deployment_id, handle_name, source_owner_key, target_owner_key, created_at, expires_at)
+     SELECT $1, handle_name, $3, $4, $5, $6
+     FROM unnest($2::text[]) AS handle_name
+     ON CONFLICT (deployment_id, handle_name, source_owner_key) DO UPDATE SET
+       target_owner_key = EXCLUDED.target_owner_key,
+       created_at = EXCLUDED.created_at,
+       expires_at = EXCLUDED.expires_at`, [
+        input.deploymentId,
+        handles,
+        input.sourceCallerSubject,
+        input.targetCallerSubject,
+        input.now,
+        input.redirectExpiresAt,
+    ]);
+    return {
+        ok: true,
+        adoptedHandles: handles,
+        adoptedRecords: moved.rowCount ?? 0,
+    };
+}
+async function selectRow(client, deploymentId, handle, owner, key, forUpdate = false) {
+    const result = await client.query(`SELECT handle_name, state_key, handle_version, value, revision, status,
+            created_at, updated_at, expires_at
+     FROM state_handle_records
+     WHERE deployment_id = $1 AND handle_name = $2 AND owner_key = $3 AND state_key = $4
+     ${forUpdate ? 'FOR UPDATE' : ''}`, [deploymentId, handle, owner, key]);
+    return result.rows[0];
+}
+async function upsertRow(client, deploymentId, owner, version, record) {
+    await client.query(`INSERT INTO state_handle_records
+       (deployment_id, handle_name, owner_key, state_key, handle_version, value, revision,
+        status, created_at, updated_at, expires_at)
+     VALUES ($1, $2, $3, $4, $5, $6::jsonb, $7, $8, $9, $10, $11)
+     ON CONFLICT (deployment_id, handle_name, owner_key, state_key) DO UPDATE SET
+       handle_version = EXCLUDED.handle_version,
+       value          = EXCLUDED.value,
+       revision       = EXCLUDED.revision,
+       status         = EXCLUDED.status,
+       created_at     = EXCLUDED.created_at,
+       updated_at     = EXCLUDED.updated_at,
+       expires_at     = EXCLUDED.expires_at`, [
+        deploymentId,
+        record.handle,
+        owner,
+        record.key,
+        version,
+        JSON.stringify(record.value),
+        record.revision,
+        record.status,
+        new Date(record.createdAt),
+        new Date(record.updatedAt),
+        record.expiresAt === undefined ? null : new Date(record.expiresAt),
+    ]);
+}
+function ownerKey(def, input) {
+    return def.scope === 'caller' ? (input.callerSubject ?? 'anonymous') : 'deployment';
+}
+async function lockOwner(client, deploymentId, handle, owner) {
+    await client.query('SELECT pg_advisory_xact_lock(hashtextextended($1, 0))', [
+        stateOwnerLockKey(deploymentId, handle, owner),
+    ]);
+}
+/** PostgreSQL text rejects NUL, so length-prefix each untrusted segment instead of using a sentinel. */
+function stateOwnerLockKey(deploymentId, handle, owner) {
+    return `state-owner:${deploymentId.length}:${deploymentId}:${handle.length}:${handle}:${owner.length}:${owner}`;
+}
+async function resolveOperationOwner(client, deploymentId, handle, owner, now) {
+    await lockOwner(client, deploymentId, handle, owner);
+    const redirect = await client.query(`SELECT target_owner_key
+     FROM state_handle_owner_redirects
+     WHERE deployment_id = $1 AND handle_name = $2 AND source_owner_key = $3 AND expires_at > $4`, [deploymentId, handle, owner, new Date(now.getTime() - STATE_OWNER_REDIRECT_GRACE_MS)]);
+    const target = redirect.rows[0]?.target_owner_key;
+    if (target === undefined)
+        return owner;
+    await lockOwner(client, deploymentId, handle, target);
+    return target;
+}
+function assertVersion(row, def) {
+    if (row.handle_version !== def.version) {
+        throw new Error(`state handle version mismatch for "${row.handle_name}": stored ${row.handle_version}, current ${def.version}`);
+    }
+}
+function mutableFromRow(row) {
+    const value = typeof row.value === 'object' && row.value !== null && !Array.isArray(row.value)
+        ? row.value
+        : {};
+    const expiresAt = row.expires_at === null ? undefined : new Date(row.expires_at).getTime();
+    return {
+        handle: row.handle_name,
+        key: row.state_key,
+        value,
+        revision: Number(row.revision),
+        status: row.status,
+        createdAt: new Date(row.created_at).getTime(),
+        updatedAt: new Date(row.updated_at).getTime(),
+        ...(expiresAt !== undefined ? { expiresAt } : {}),
+    };
+}
+//# sourceMappingURL=postgres-state-handles.js.map

package/node_modules/@noodle-borg/runtime/dist/postgres.js

@@ -0,0 +1,4 @@
+/** PostgreSQL state-handle persistence for hosted composition. */
+export * from './postgres-state-handles.js';
+export * from './state-handle-ownership.js';
+//# sourceMappingURL=postgres.js.map

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

@@ -0,0 +1,18 @@
+/** Browser and messaging resolve model, execution and tenant policy from one composition. */
+export function assistantRouteDependencies(options, core) {
+    return {
+        ...core,
+        ...(options.publicEmbeds ? { publicEmbeds: options.publicEmbeds } : {}),
+        ...(options.elevations ? { elevations: options.elevations } : {}),
+        ...(options.elevationCoordinator ? { elevationCoordinator: options.elevationCoordinator } : {}),
+        ...(options.admissionCounters ? { admissionCounters: options.admissionCounters } : {}),
+        ...(options.admissionEnvelope ? { admissionEnvelope: options.admissionEnvelope } : {}),
+        ...(options.assistantModelFetch ? { modelFetch: options.assistantModelFetch } : {}),
+        ...(options.managedAssistantModelResolver
+            ? { managedModelResolver: options.managedAssistantModelResolver }
+            : {}),
+        ...(options.captureRequestEvent ? { captureRequestEvent: options.captureRequestEvent } : {}),
+        ...(options.clock ? { clock: options.clock } : {}),
+    };
+}
+//# sourceMappingURL=assistant-composition.js.map

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

@@ -1,10 +1,13 @@
 import { MIXED_CUSTOMER_AUTH_FEATURE_VERSION, serviceInfoResponseSchema, } from '@noodle-borg/wire-contracts';
-export function serviceInfoPayload(buildInfo, developerMcp) {
+export function serviceInfoPayload(buildInfo, developerMcp, whatsapp = false) {
     return serviceInfoResponseSchema.parse({
         ok: true,
         status: 'ok',
         ...buildInfo,
-        features: { mixedCustomerAuth: MIXED_CUSTOMER_AUTH_FEATURE_VERSION },
+        features: {
+            mixedCustomerAuth: MIXED_CUSTOMER_AUTH_FEATURE_VERSION,
+            ...(whatsapp ? { whatsapp: 1 } : {}),
+        },
         ...(developerMcp
             ? { developerPlugin: { mcpCapabilityVersion: DEVELOPER_MCP_CAPABILITY_VERSION } }
             : {}),

package/node_modules/@noodle-borg/service/dist/business-information/source-ingestion-coordinator.js

@@ -133,4 +133,11 @@ function boundedToken(label, value, maximum) {
     }
     return normalized;
 }
+export async function drainSourceIngestion(coordinator) {
+    for (let attempt = 0; attempt < 100; attempt += 1) {
+        const result = await coordinator.runOne();
+        if (result.disposition !== 'completed')
+            return;
+    }
+}
 //# sourceMappingURL=source-ingestion-coordinator.js.map