@noodleseed/one 0.172.0 → 0.173.0

package/node_modules/@noodle-borg/cli-catalog/dist/catalog-data-solution-drafts.js

@@ -0,0 +1,141 @@
+/** Canonical source-draft operations; imported by the solutions family. Data only. */
+import { EXPECTED_REVISION, IDEMPOTENCY_KEY, OPTIONAL_FLAG, REQUIRED_ARGUMENT, SOLUTION_COMMON_FLAGS, } from './catalog-data-solution-flags.js';
+const common = [
+    ...SOLUTION_COMMON_FLAGS.map((flag) => flag.name === 'org' ? { ...flag, required: true } : flag),
+    {
+        ...OPTIONAL_FLAG,
+        name: 'app',
+        type: 'string',
+        value: '<slug>',
+        required: true,
+        summary: 'Application slug.',
+    },
+];
+const source = [
+    {
+        ...OPTIONAL_FLAG,
+        name: 'source-dir',
+        type: 'string',
+        value: '<directory>',
+        required: true,
+        summary: 'Directory containing bounded TypeScript application source; no symlinks or environment files.',
+    },
+    {
+        ...OPTIONAL_FLAG,
+        name: 'entrypoint',
+        type: 'string',
+        value: '<path>',
+        summary: 'Relative TypeScript entrypoint.',
+        constraints: { default: 'server.ts' },
+    },
+];
+const draftId = { ...REQUIRED_ARGUMENT, name: 'draft-id', summary: 'Saved draft identifier.' };
+const revision = { ...EXPECTED_REVISION, constraints: { minimum: 1, maximum: 2147483647 } };
+export const SOLUTION_DRAFTS = {
+    name: 'drafts',
+    summary: 'Save and inspect private application source without publishing it.',
+    arguments: [],
+    flags: [],
+    subcommands: [
+        {
+            name: 'history',
+            summary: 'List source-free revisions, newest first.',
+            arguments: [draftId],
+            flags: common,
+            jsonOutput: { mode: 'single' },
+        },
+        {
+            name: 'diff',
+            summary: 'Compare exact source and entrypoints at two revisions.',
+            arguments: [draftId],
+            flags: [
+                ...common,
+                { ...revision, name: 'from-revision', summary: 'Revision to compare from.' },
+                { ...revision, name: 'to-revision', summary: 'Revision to compare to.' },
+            ],
+            jsonOutput: { mode: 'single' },
+        },
+        {
+            name: 'list',
+            summary: 'List source-free draft summaries.',
+            arguments: [],
+            flags: common,
+            jsonOutput: { mode: 'single' },
+        },
+        {
+            name: 'show',
+            summary: 'Read an authorized exact draft revision.',
+            arguments: [draftId],
+            flags: [
+                ...common,
+                {
+                    ...revision,
+                    name: 'revision',
+                    required: false,
+                    summary: 'Revision to read; defaults to the current revision.',
+                },
+            ],
+            jsonOutput: { mode: 'single' },
+        },
+        {
+            name: 'create',
+            summary: 'Save a new private draft from TypeScript source.',
+            arguments: [],
+            flags: [
+                ...common,
+                ...source,
+                IDEMPOTENCY_KEY,
+                {
+                    ...OPTIONAL_FLAG,
+                    name: 'env',
+                    type: 'string',
+                    value: '<slug>',
+                    summary: 'Intended publish environment; saving does not deploy.',
+                    constraints: { default: 'prod' },
+                },
+            ],
+            jsonOutput: { mode: 'single' },
+        },
+        {
+            name: 'edit',
+            summary: 'Append a revision without overwriting concurrent work.',
+            arguments: [draftId],
+            flags: [...common, ...source, revision, IDEMPOTENCY_KEY],
+            jsonOutput: { mode: 'single' },
+        },
+        {
+            name: 'undo',
+            summary: 'Restore an earlier source revision as a new revision.',
+            arguments: [draftId],
+            flags: [
+                ...common,
+                revision,
+                IDEMPOTENCY_KEY,
+                {
+                    ...revision,
+                    name: 'target-revision',
+                    summary: 'Earlier revision whose source will be restored.',
+                },
+            ],
+            jsonOutput: { mode: 'single' },
+        },
+        {
+            name: 'delete',
+            summary: 'Erase a draft and its source history; published applications are unchanged.',
+            arguments: [draftId],
+            flags: [
+                ...common,
+                revision,
+                {
+                    ...OPTIONAL_FLAG,
+                    name: 'confirm',
+                    type: 'boolean',
+                    required: true,
+                    summary: 'Confirm erasing the draft source and history.',
+                },
+            ],
+            jsonOutput: { mode: 'single' },
+        },
+    ],
+};
+//# sourceMappingURL=catalog-data-solution-drafts.js.map

package/node_modules/@noodle-borg/cli-catalog/dist/catalog-data-solution-page.js

@@ -0,0 +1,57 @@
+/** Hosted-page operator catalog. Pure data; execution remains in the CLI. */
+import { EXPECTED_REVISION, INSTALLATION_ARGUMENT, OPTIONAL_FLAG, SOLUTION_COMMON_FLAGS, } from './catalog-data-solution-flags.js';
+const common = SOLUTION_COMMON_FLAGS.map((flag) => flag.name === 'org' ? { ...flag, required: true } : flag);
+const revision = {
+    ...EXPECTED_REVISION,
+    constraints: { minimum: 1, maximum: 2147483647 },
+};
+const confirm = {
+    ...OPTIONAL_FLAG,
+    name: 'confirm',
+    type: 'boolean',
+    required: true,
+    summary: 'Confirm changing public page availability.',
+};
+export const SOLUTION_PAGE = {
+    name: 'page',
+    summary: 'Edit and explicitly publish a Noodle Seed-hosted business page.',
+    arguments: [],
+    flags: [],
+    subcommands: [
+        {
+            name: 'show',
+            summary: 'Inspect the private page draft and its published snapshot.',
+            arguments: [INSTALLATION_ARGUMENT],
+            flags: common,
+            jsonOutput: { mode: 'single' },
+        },
+        {
+            name: 'save',
+            summary: 'Save page content without changing the published page.',
+            arguments: [INSTALLATION_ARGUMENT],
+            flags: [
+                ...common,
+                { ...revision, constraints: { minimum: 0, maximum: 2147483647 } },
+                {
+                    ...OPTIONAL_FLAG,
+                    name: 'data',
+                    type: 'string',
+                    value: '<json>',
+                    required: true,
+                    summary: 'Bounded JSON with introduction and sections containing title/text; plain text only.',
+                },
+            ],
+            jsonOutput: { mode: 'single' },
+        },
+        ...['publish', 'unpublish'].map((name) => ({
+            name,
+            summary: name === 'publish'
+                ? 'Publish the exact saved page after public-assistant readiness checks.'
+                : 'Remove the public page while retaining its private draft.',
+            arguments: [INSTALLATION_ARGUMENT],
+            flags: [...common, revision, confirm],
+            jsonOutput: { mode: 'single' },
+        })),
+    ],
+};
+//# sourceMappingURL=catalog-data-solution-page.js.map

package/node_modules/@noodle-borg/cli-catalog/dist/catalog-data-solutions.js

@@ -1,5 +1,7 @@
 /** Solution installation/operator catalog. Imports only dependency-free sibling data. */
+import { SOLUTION_DRAFTS } from './catalog-data-solution-drafts.js';
 import { AUTH_TOKEN, EXPECTED_REVISION, IDEMPOTENCY_KEY, INSTALLATION_ARGUMENT, JSON_FLAG, OPTIONAL_FLAG, PAGING_FLAGS, REQUIRED_ARGUMENT, SERVICE, SOLUTION_COMMON_FLAGS, } from './catalog-data-solution-flags.js';
+import { SOLUTION_PAGE } from './catalog-data-solution-page.js';
 const APP = {
     ...OPTIONAL_FLAG,
     name: 'app',
@@ -129,6 +131,8 @@ export const CATALOG_SOLUTIONS = {
     arguments: [],
     flags: [],
     subcommands: [
+        SOLUTION_DRAFTS,
+        SOLUTION_PAGE,
         {
             name: 'installation-options',
             summary: 'List organizations currently authorized to install solutions.',

package/node_modules/@noodle-borg/service/dist/application-drafts/contracts.js

@@ -0,0 +1,11 @@
+export class ApplicationDraftError extends Error {
+    code;
+    currentRevision;
+    constructor(code, currentRevision) {
+        super(code);
+        this.code = code;
+        this.currentRevision = currentRevision;
+        this.name = 'ApplicationDraftError';
+    }
+}
+//# sourceMappingURL=contracts.js.map

package/node_modules/@noodle-borg/service/dist/application-drafts/paths.js

@@ -0,0 +1,26 @@
+import { validateSlug } from '@noodle-borg/control-plane/portable';
+import { ApplicationDraftIdSchema } from '@noodle-borg/wire-contracts';
+export function parseApplicationDraftPath(path) {
+    const match = /^\/v1\/orgs\/([a-z0-9-]+)\/apps\/([a-z0-9-]+)\/drafts(?:\/([a-f0-9-]+)(?:\/(undo|history|diff))?)?$/.exec(path);
+    const org = match?.[1], app = match?.[2], id = match?.[3], action = match?.[4];
+    if (!org || !app || (id !== undefined && !ApplicationDraftIdSchema.safeParse(id).success))
+        return undefined;
+    try {
+        validateSlug('org', org);
+        validateSlug('app', app);
+    }
+    catch {
+        return undefined;
+    }
+    return { org, app, ...(id ? { id } : {}), ...(action ? { action } : {}) };
+}
+export function applicationDraftMethods(ref) {
+    return ref.action === 'undo'
+        ? ['POST']
+        : ref.action
+            ? ['GET']
+            : ref.id
+                ? ['GET', 'PATCH', 'DELETE']
+                : ['GET', 'POST'];
+}
+//# sourceMappingURL=paths.js.map

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

@@ -0,0 +1,14 @@
+export function parseBusinessPagePath(path) {
+    const match = /^\/v1\/orgs\/([a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?)\/solution-installations\/([a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?)\/page(?:\/(publish|unpublish))?$/.exec(path);
+    return match
+        ? {
+            org: match[1],
+            installationId: match[2],
+            ...(match[3] ? { operation: match[3] } : {}),
+        }
+        : undefined;
+}
+export function businessPageMethods(ref) {
+    return ref.operation ? ['POST'] : ['GET', 'PUT'];
+}
+//# sourceMappingURL=business-page-paths.js.map

package/node_modules/@noodle-borg/service/dist/business-information/business-page.d.ts

@@ -0,0 +1,39 @@
+import { type BusinessPageContent, type BusinessPagePublication } from '@noodle-borg/wire-contracts';
+import type { BusinessNoticeRecord } from './business-notice.js';
+import type { InstallationScope } from './contracts.js';
+export interface BusinessPageRecord {
+    readonly revision: number;
+    readonly draft: BusinessPageContent;
+    readonly published: BusinessPagePublication | null;
+    readonly updatedAt: string;
+    readonly updatedBySubject: string;
+}
+export type BusinessPageChange = {
+    readonly operation: 'save';
+    readonly expectedRevision: number;
+    readonly content: BusinessPageContent;
+} | {
+    readonly operation: 'publish' | 'unpublish';
+    readonly expectedRevision: number;
+};
+export interface BusinessPageInput {
+    readonly scope: InstallationScope;
+    readonly actorSubject: string;
+    readonly change: BusinessPageChange;
+}
+/** Server-only readiness check, never supplied by a browser or persisted as authority. */
+export type BusinessPageReadiness = () => Promise<{
+    readonly deploymentId: string;
+}>;
+export interface BusinessPageStore {
+    get(scope: InstallationScope): Promise<BusinessPageRecord | undefined>;
+    update(input: BusinessPageInput, assertReady?: BusinessPageReadiness): Promise<BusinessPageRecord>;
+}
+export declare class BusinessPageError extends Error {
+    readonly code: 'business_page_forbidden' | 'business_page_conflict' | 'business_page_not_ready';
+    constructor(code: 'business_page_forbidden' | 'business_page_conflict' | 'business_page_not_ready');
+}
+export declare function nextBusinessPage(current: BusinessPageRecord | undefined, input: BusinessPageInput, now: string, notice: BusinessNoticeRecord | undefined, assertReady?: BusinessPageReadiness): Promise<BusinessPageRecord>;
+/** Validate decrypted storage without surfacing parser excerpts or business text in errors. */
+export declare function decodeBusinessPage(value: unknown, expectedRevision: number): BusinessPageRecord;
+//# sourceMappingURL=business-page.d.ts.map

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

@@ -0,0 +1,81 @@
+import { BusinessPageContentSchema, BusinessPagePublicationSchema, BusinessPagePublishRequestSchema, BusinessPageSaveRequestSchema, } from '@noodle-borg/wire-contracts';
+export class BusinessPageError extends Error {
+    code;
+    constructor(code) {
+        super({
+            business_page_forbidden: 'An active business administrator is required.',
+            business_page_conflict: 'The page changed. Reload before trying again.',
+            business_page_not_ready: 'Complete the business details and enable the public assistant before publishing.',
+        }[code]);
+        this.code = code;
+        this.name = 'BusinessPageError';
+    }
+}
+export async function nextBusinessPage(current, input, now, notice, assertReady) {
+    const { operation, ...request } = input.change;
+    if (!['save', 'publish', 'unpublish'].includes(operation))
+        throw new Error('Invalid page operation.');
+    const save = operation === 'save' ? BusinessPageSaveRequestSchema.parse(request) : undefined;
+    const expectedRevision = save?.expectedRevision ?? BusinessPagePublishRequestSchema.parse(request).expectedRevision;
+    if ((current?.revision ?? 0) !== expectedRevision || expectedRevision === 2_147_483_647)
+        throw new BusinessPageError('business_page_conflict');
+    if (operation !== 'save' && !current)
+        throw new BusinessPageError('business_page_conflict');
+    const draft = save?.content ?? current?.draft;
+    if (!draft)
+        throw new BusinessPageError('business_page_conflict');
+    let published = current?.published ?? null;
+    if (operation === 'publish') {
+        if (!notice || !assertReady)
+            throw new BusinessPageError('business_page_not_ready');
+        const ready = await assertReady();
+        published = BusinessPagePublicationSchema.parse({
+            content: draft,
+            notice: notice.notice,
+            noticeRevision: notice.revision,
+            sourceRevision: expectedRevision,
+            deploymentId: ready.deploymentId,
+            publishedAt: now,
+        });
+    }
+    else if (operation === 'unpublish')
+        published = null;
+    return structuredClone({
+        revision: expectedRevision + 1,
+        draft,
+        published,
+        updatedAt: now,
+        updatedBySubject: input.actorSubject,
+    });
+}
+/** Validate decrypted storage without surfacing parser excerpts or business text in errors. */
+export function decodeBusinessPage(value, expectedRevision) {
+    try {
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            throw new Error();
+        const input = value;
+        if (Object.keys(input).sort().join(',') !==
+            'draft,published,revision,updatedAt,updatedBySubject' ||
+            input.revision !== expectedRevision ||
+            !Number.isInteger(expectedRevision) ||
+            expectedRevision < 1 ||
+            expectedRevision > 2_147_483_647 ||
+            typeof input.updatedAt !== 'string' ||
+            !Number.isFinite(Date.parse(input.updatedAt)) ||
+            typeof input.updatedBySubject !== 'string' ||
+            !input.updatedBySubject ||
+            input.updatedBySubject.length > 500)
+            throw new Error();
+        return {
+            revision: expectedRevision,
+            draft: BusinessPageContentSchema.parse(input.draft),
+            published: input.published === null ? null : BusinessPagePublicationSchema.parse(input.published),
+            updatedAt: input.updatedAt,
+            updatedBySubject: input.updatedBySubject,
+        };
+    }
+    catch {
+        throw new Error('Business page storage is unavailable.');
+    }
+}
+//# sourceMappingURL=business-page.js.map

package/node_modules/@noodle-borg/service/dist/business-information/contracts.d.ts

@@ -1,6 +1,7 @@
 import type { ArtifactVariableDeclaration, ManagedCollectionControls } from '@noodle-borg/compiler';
 import type { ManagedRecordQuery } from '@noodle-borg/wire-contracts';
 import type { BusinessNoticeStore } from './business-notice.js';
+import type { BusinessPageStore } from './business-page.js';
 import type { BusinessPrincipalProvider } from './principal-authority.js';
 export type JsonPrimitive = string | number | boolean | null;
 export type JsonValue = JsonPrimitive | JsonObject | readonly JsonValue[];
@@ -433,6 +434,7 @@ export interface ManagedRequestStore {
     }): Promise<number>;
 }
 export interface BusinessInformationStore extends SolutionInstallationStore, BusinessNoticeStore, BusinessGrantStore, ManagedRequestStore {
+    readonly pages: BusinessPageStore;
     configurePrincipalAuthority(provider: BusinessPrincipalProvider | undefined): void;
     listEligibleAssignees(scope: InstallationScope): Promise<readonly BusinessGrant[]>;
 }

package/node_modules/@noodle-borg/service/dist/business-information/in-memory-business-pages.js

@@ -0,0 +1,37 @@
+import { BusinessPageError, nextBusinessPage, } from './business-page.js';
+import { scopeKey } from './pagination.js';
+import { validateScalar, validateScope } from './validation.js';
+/** Process-local test/development adapter; shares installation grant authority and its locks. */
+export class InMemoryBusinessPages {
+    business;
+    locks;
+    principals;
+    now;
+    #records = new Map();
+    constructor(business, locks, principals, now) {
+        this.business = business;
+        this.locks = locks;
+        this.principals = principals;
+        this.now = now;
+    }
+    async get(scope) {
+        return structuredClone(this.#records.get(scopeKey(validateScope(scope))));
+    }
+    async update(input, assertReady) {
+        const scope = validateScope(input.scope);
+        const actorSubject = validateScalar('page actor', input.actorSubject, 500);
+        const key = scopeKey(scope);
+        return this.locks.run(`grants:${key}`, () => this.locks.run(`intake:${key}`, async () => {
+            const grant = await this.business.getGrant(scope, actorSubject);
+            if (!(await this.business.getInstallation(scope)) ||
+                grant?.role !== 'administrator' ||
+                grant.revokedAt ||
+                !(await this.principals.allows(actorSubject)))
+                throw new BusinessPageError('business_page_forbidden');
+            const next = await nextBusinessPage(this.#records.get(key), { ...input, scope, actorSubject }, this.now().toISOString(), await this.business.getBusinessNotice(scope), assertReady);
+            this.#records.set(key, structuredClone(next));
+            return next;
+        }));
+    }
+}
+//# sourceMappingURL=in-memory-business-pages.js.map

package/node_modules/@noodle-borg/service/dist/business-information/in-memory-store.js

@@ -1,6 +1,7 @@
 import { randomUUID } from 'node:crypto';
 import { memoryActivityPage } from './activity-pagination.js';
 import { collectionControlEnabled } from './collection-controls.js';
+import { InMemoryBusinessPages } from './in-memory-business-pages.js';
 import { InMemoryInstallationLifecycle, } from './in-memory-installation-lifecycle.js';
 import { InMemoryBusinessInvitations } from './in-memory-invitations.js';
 import { BusinessMemoryLocks } from './in-memory-locks.js';
@@ -14,6 +15,7 @@ import { BusinessPrincipalAuthority, } from './principal-authority.js';
 import { boundedExportPageSize, boundedPageSize, validateEmail, validateScalar, validateScope, } from './validation.js';
 /** Process-local development/test adapter. Hosted services must use the PostgreSQL adapter. */
 export class InMemoryBusinessInformationStore {
+    pages;
     #installations = new Map();
     #installationIds = new Map();
     #publicIds = new Map();
@@ -36,6 +38,7 @@ export class InMemoryBusinessInformationStore {
         this.#id = options.id ?? randomUUID;
         this.#publicId = options.publicId ?? (() => `sol_${randomUUID().replaceAll('-', '')}`);
         this.#managedDefinition = options.managedDefinition;
+        this.pages = new InMemoryBusinessPages(this, this.#locks, this.#principals, this.#now);
         this.#lifecycle = new InMemoryInstallationLifecycle({
             installations: this.#installations,
             getGrant: (scope, subject) => this.#grants.get(grantKey(scope, subject)),

package/node_modules/@noodle-borg/service/dist/business-information/managed-solution-executable.js

@@ -2,7 +2,15 @@ import { projectManagedCollectionControls, RECORD_OPERATION_SIGNATURES, } from '
 import { collectionToPublicWire } from '../routes/business-information-wire.js';
 import { managedSolutionBlueprint } from './managed-solution-blueprints.js';
 /** System-owned manifest data for an explicitly curated solution, admitted by the ordinary compiler. */
-export function managedSolutionManifest(definition) {
+export function managedSolutionManifest(definition, hostedPageOrigin) {
+    if (hostedPageOrigin !== undefined) {
+        const url = new URL(hostedPageOrigin);
+        if (url.origin !== hostedPageOrigin ||
+            !(url.protocol === 'https:' ||
+                (url.protocol === 'http:' && ['localhost', '127.0.0.1', '[::1]'].includes(url.hostname))))
+            throw new Error('Invalid hosted page origin');
+    }
+    const origins = ['${env.WEBSITE_ORIGIN}', ...(hostedPageOrigin ? [hostedPageOrigin] : [])];
     const ref = definition.reference;
     const blueprint = ref.kind === 'managed' ? managedSolutionBlueprint(ref.definitionId, ref.release) : undefined;
     if (blueprint === undefined)
@@ -40,11 +48,11 @@ export function managedSolutionManifest(definition) {
             })),
             assistant: {
                 model: { kind: 'noodle-managed' },
-                allowedOrigins: ['${env.WEBSITE_ORIGIN}'],
+                allowedOrigins: origins,
                 surfaces: [
                     {
                         mode: 'public',
-                        origins: ['${env.WEBSITE_ORIGIN}'],
+                        origins,
                         capabilities: [{ kind: 'tool', name: blueprint.tool }],
                     },
                 ],

package/node_modules/@noodle-borg/service/dist/channels/360dialog.js

@@ -131,13 +131,18 @@ export class Dialog360 {
         if (!response.ok)
             throw new ChannelError('provider_unavailable');
         const parsed = z
-            .object({ id: identifier, health_status: z.object({ can_send_message: z.string() }) })
+            .object({
+            id: identifier,
+            health_status: z.object({ can_send_message: z.enum(['AVAILABLE', 'LIMITED', 'BLOCKED']) }),
+        })
             .safeParse(await boundedJson(response));
         if (!parsed.success)
             throw new ChannelError('provider_response_invalid');
         return {
             phoneNumberId: parsed.data.id,
-            canSend: parsed.data.health_status.can_send_message === 'AVAILABLE',
+            // LIMITED meets provider messaging requirements; provider limits still govern each send.
+            canSend: parsed.data.health_status.can_send_message !== 'BLOCKED',
+            status: parsed.data.health_status.can_send_message,
         };
     }
     async webhook() {

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

@@ -56,8 +56,8 @@ export class WhatsAppRuntime {
         const checks = [];
         const check = async (name, work) => {
             try {
-                await work();
-                checks.push({ name, status: 'ready' });
+                const code = await work();
+                checks.push({ name, status: 'ready', ...(code ? { code } : {}) });
             }
             catch (error) {
                 checks.push({
@@ -98,7 +98,8 @@ export class WhatsAppRuntime {
             if (health.phoneNumberId !== binding.phoneNumberId)
                 throw new ChannelError('asset_mismatch');
             if (!health.canSend)
-                throw new ChannelError('provider_messaging_unavailable');
+                throw new ChannelError('provider_messaging_blocked');
+            return health.status === 'LIMITED' ? 'provider_messaging_limited' : undefined;
         });
         await check('webhook', async () => {
             const state = await this.webhook(id, req);