@wtfalch/foundry 0.78.1 → 0.79.0

package/dist/mcp-resources/schema.js

@@ -0,0 +1,253 @@
+import { z } from 'zod';
+export const MCP_RESOURCE_CONTRACT_VERSION = 1;
+const opaqueId = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/);
+const revision = z.number().int().min(1).max(Number.MAX_SAFE_INTEGER);
+const epoch = z.number().int().min(0).max(Number.MAX_SAFE_INTEGER);
+const exactIdentifier = z
+    .string()
+    .min(1)
+    .max(512)
+    .regex(/^[^\s\p{Cc}<>]+$/u);
+const text = (max) => z
+    .string()
+    .refine((value) => value.trim().length > 0)
+    .min(1)
+    .max(max)
+    .regex(/^[^\p{Cc}<>]+$/u);
+const httpsUrl = z
+    .string()
+    .max(2048)
+    .refine((value) => {
+    try {
+        const url = new URL(value);
+        return (url.protocol === 'https:' &&
+            !value.includes('?') &&
+            !value.includes('#') &&
+            !url.username &&
+            !url.password &&
+            !url.search &&
+            !url.hash &&
+            url.href === value);
+    }
+    catch {
+        return false;
+    }
+});
+// Auth may identify an issuer by its exact origin without a trailing slash.
+// Accept that spelling without transforming it into a different issuer identifier.
+const httpsIssuer = httpsUrl.or(z
+    .string()
+    .max(2048)
+    .refine((value) => {
+    try {
+        const url = new URL(value);
+        return url.protocol === 'https:' && url.origin === value;
+    }
+    catch {
+        return false;
+    }
+}));
+export const McpResourceNamespaceSchema = z.strictObject({
+    providerTenantId: opaqueId,
+    appId: opaqueId,
+    copyId: opaqueId,
+});
+export const McpResourceKeySchema = McpResourceNamespaceSchema.extend({ resourceId: opaqueId });
+export const McpResourceScopeSchema = z.strictObject({
+    id: z
+        .string()
+        .min(1)
+        .max(128)
+        .regex(/^[\x21\x23-\x5b\x5d-\x7e]+$/),
+    title: text(120).optional(),
+    description: text(1000),
+});
+export const McpResourceBrandingSchema = z.strictObject({
+    displayName: text(120),
+    description: text(1000).optional(),
+    locale: z
+        .string()
+        .min(2)
+        .max(35)
+        .regex(/^[A-Za-z]{2,8}(?:-[A-Za-z0-9]{1,8})*$/)
+        .optional(),
+});
+export const McpResourceAdmissionSchema = z.discriminatedUnion('mode', [
+    z.strictObject({ mode: z.literal('unrestricted') }),
+    z.strictObject({
+        mode: z.literal('application-approval'),
+        policyId: opaqueId,
+        requiredEvidence: z
+            .array(z.enum(['provider', 'authentication-method', 'authentication-time', 'groups']))
+            .max(4)
+            .refine((items) => new Set(items).size === items.length),
+        returnPath: z
+            .string()
+            .max(200)
+            .regex(/^\/[a-zA-Z0-9_-]+(?:\/[a-zA-Z0-9_-]+)*$/),
+    }),
+]);
+export const McpResourceDesiredSchema = z
+    .strictObject({
+    state: z.enum(['active', 'suspended', 'retired']),
+    configurationRevision: revision,
+    policyRevision: revision,
+    denyEpoch: epoch,
+    scopes: z
+        .array(McpResourceScopeSchema)
+        .max(128)
+        .refine((scopes) => new Set(scopes.map((scope) => scope.id)).size === scopes.length),
+    admission: McpResourceAdmissionSchema,
+    branding: McpResourceBrandingSchema.optional(),
+})
+    .refine((desired) => desired.state !== 'active' || desired.scopes.length > 0);
+export const McpResourceIdentitySchema = z.strictObject({
+    registrationId: exactIdentifier,
+    resourceUri: httpsUrl,
+    audience: exactIdentifier,
+    issuer: httpsIssuer,
+});
+export const McpResourcePhaseSchema = z.enum([
+    'registration',
+    'discovery',
+    'registry',
+    'runtime',
+    'revocation',
+    'cleanup',
+    'complete',
+]);
+export const McpResourceObservedSchema = z.strictObject({
+    state: z.enum(['absent', 'applying', 'active', 'suspended', 'retiring', 'retired']),
+    configurationRevision: revision.nullable(),
+    policyRevision: revision.nullable(),
+    denyEpoch: epoch,
+    phase: McpResourcePhaseSchema,
+    revocation: z.enum(['not-required', 'pending', 'complete']),
+    cleanup: z.enum(['not-required', 'pending', 'complete']),
+});
+export const McpResourceSnapshotSchema = z.strictObject({
+    version: z.literal(MCP_RESOURCE_CONTRACT_VERSION),
+    key: McpResourceKeySchema,
+    generation: revision,
+    identity: McpResourceIdentitySchema.nullable(),
+    desired: McpResourceDesiredSchema,
+    observed: McpResourceObservedSchema,
+});
+export const McpResourceApplyRequestSchema = z.strictObject({
+    version: z.literal(MCP_RESOURCE_CONTRACT_VERSION),
+    key: McpResourceKeySchema,
+    operationId: opaqueId,
+    expectedGeneration: revision.nullable(),
+    desired: McpResourceDesiredSchema,
+});
+export const McpResourceReadRequestSchema = z.strictObject({
+    version: z.literal(MCP_RESOURCE_CONTRACT_VERSION),
+    key: McpResourceKeySchema,
+});
+export const McpResourceListRequestSchema = z.strictObject({
+    version: z.literal(MCP_RESOURCE_CONTRACT_VERSION),
+    namespace: McpResourceNamespaceSchema,
+    cursor: opaqueId.optional(),
+});
+export const McpResourceOperationRequestSchema = McpResourceReadRequestSchema.extend({
+    operationId: opaqueId,
+});
+export const McpResourceFailureSchema = z.strictObject({
+    code: z.enum([
+        'forbidden',
+        'invalid-request',
+        'generation-mismatch',
+        'idempotency-mismatch',
+        'retired',
+        'revision-regression',
+        'backend-unsupported',
+        'backend-unavailable',
+        'provider-failure',
+        'invalid-response',
+        'transport-failure',
+    ]),
+    phase: McpResourcePhaseSchema,
+});
+export const McpResourceRecoverySchema = z.discriminatedUnion('action', [
+    z.strictObject({
+        action: z.literal('poll-operation'),
+        afterMs: z.number().int().min(0).max(86_400_000),
+    }),
+    z.strictObject({
+        action: z.literal('retry-same-operation'),
+        afterMs: z.number().int().min(0).max(86_400_000),
+    }),
+    z.strictObject({ action: z.literal('read-resource') }),
+    z.strictObject({ action: z.literal('operator-intervention') }),
+    z.strictObject({ action: z.literal('none') }),
+]);
+const outcome = { version: z.literal(MCP_RESOURCE_CONTRACT_VERSION) };
+const operation = { ...outcome, operationId: opaqueId };
+const problem = { failure: McpResourceFailureSchema, recovery: McpResourceRecoverySchema };
+export const McpResourceApplyResultSchema = z.discriminatedUnion('outcome', [
+    z.strictObject({
+        ...operation,
+        outcome: z.literal('applied'),
+        snapshot: McpResourceSnapshotSchema,
+    }),
+    z.strictObject({
+        ...operation,
+        outcome: z.literal('pending'),
+        snapshot: McpResourceSnapshotSchema,
+        recovery: McpResourceRecoverySchema,
+    }),
+    z.strictObject({
+        ...operation,
+        outcome: z.literal('partial'),
+        snapshot: McpResourceSnapshotSchema,
+        ...problem,
+    }),
+    z.strictObject({
+        ...operation,
+        outcome: z.literal('conflict'),
+        snapshot: McpResourceSnapshotSchema.nullable(),
+        ...problem,
+    }),
+    z.strictObject({ ...operation, outcome: z.literal('refused'), ...problem }),
+    z.strictObject({ ...operation, outcome: z.literal('unavailable'), ...problem }),
+]);
+export const McpResourceReadResultSchema = z.discriminatedUnion('outcome', [
+    z.strictObject({ ...outcome, outcome: z.literal('found'), snapshot: McpResourceSnapshotSchema }),
+    z.strictObject({ ...outcome, outcome: z.literal('not-found') }),
+    z.strictObject({ ...outcome, outcome: z.literal('refused'), ...problem }),
+    z.strictObject({ ...outcome, outcome: z.literal('unavailable'), ...problem }),
+]);
+export const McpResourceListResultSchema = z.discriminatedUnion('outcome', [
+    z.strictObject({
+        ...outcome,
+        outcome: z.literal('listed'),
+        resources: z.array(McpResourceSnapshotSchema).max(100),
+        nextCursor: opaqueId.nullable(),
+    }),
+    z.strictObject({ ...outcome, outcome: z.literal('refused'), ...problem }),
+    z.strictObject({ ...outcome, outcome: z.literal('unavailable'), ...problem }),
+]);
+export const McpResourceOperationResultSchema = z.union([
+    McpResourceApplyResultSchema,
+    z.strictObject({ ...operation, outcome: z.literal('not-found') }),
+]);
+export const McpResourceIntegrationSchema = z.strictObject({
+    version: z.literal(MCP_RESOURCE_CONTRACT_VERSION),
+    pathPrefix: z
+        .string()
+        .max(160)
+        .regex(/^\/[a-z0-9_-]+(?:\/[a-z0-9_-]+)*$/),
+});
+export const MCP_RESOURCE_ENV = {
+    managementUrl: 'MCP_MANAGEMENT_URL',
+    managementCredential: 'MCP_MANAGEMENT_CREDENTIAL',
+    namespace: 'MCP_RESOURCE_NAMESPACE',
+    pathPrefix: 'MCP_RESOURCE_PATH_PREFIX',
+};
+/** Non-secret bootstrap. The management credential is delivered separately as a server secret. */
+export const McpResourceBootstrapSchema = z.strictObject({
+    version: z.literal(MCP_RESOURCE_CONTRACT_VERSION),
+    managementUrl: httpsUrl,
+    namespace: McpResourceNamespaceSchema,
+    pathPrefix: McpResourceIntegrationSchema.shape.pathPrefix,
+});

package/dist/mcp-resources/validation.d.ts

@@ -0,0 +1,21 @@
+import { type McpResourceApplyRequest, type McpResourceDesired, type McpResourceFailure, type McpResourceKey, type McpResourceNamespace, type McpResourceSnapshot } from './schema.js';
+export type McpResourceManagementAction = 'apply' | 'read' | 'list' | 'get-operation';
+/** Created by the server from authenticated installation authority, never from the request body. */
+export interface McpResourceManagementAuthority {
+    namespace: McpResourceNamespace;
+    actions: readonly McpResourceManagementAction[];
+}
+export declare function sameMcpResourceNamespace(a: McpResourceNamespace, b: McpResourceNamespace): boolean;
+export declare function sameMcpResourceKey(a: McpResourceKey, b: McpResourceKey): boolean;
+export declare function admitsMcpResourceManagement(authority: McpResourceManagementAuthority, action: McpResourceManagementAction, target: McpResourceNamespace): boolean;
+/** Check the stored operation receipt BEFORE this guard: a replay recovers its original result. */
+export declare function checkMcpResourceApply(request: McpResourceApplyRequest, current: McpResourceSnapshot | null): McpResourceFailure | null;
+export declare function sameMcpResourceDesired(a: McpResourceDesired, b: McpResourceDesired): boolean;
+/** Canonical non-secret payload for a durable (key, apply, operationId) idempotency receipt. */
+export declare function mcpResourceApplyFingerprint(request: McpResourceApplyRequest): string;
+/** Exact canonical runtime path; the hosting installation selects the immutable origin separately. */
+export declare function mcpResourcePath(pathPrefix: string, resourceId: string): string;
+export declare function mcpResourceUrls(origin: string, pathPrefix: string, resourceId: string): {
+    resourceUri: string;
+    protectedResourceMetadataUri: string;
+};

package/dist/mcp-resources/validation.js

@@ -0,0 +1,97 @@
+import { McpResourceApplyRequestSchema, McpResourceIntegrationSchema, McpResourceKeySchema, McpResourceNamespaceSchema, } from './schema.js';
+export function sameMcpResourceNamespace(a, b) {
+    return a.providerTenantId === b.providerTenantId && a.appId === b.appId && a.copyId === b.copyId;
+}
+export function sameMcpResourceKey(a, b) {
+    return sameMcpResourceNamespace(a, b) && a.resourceId === b.resourceId;
+}
+export function admitsMcpResourceManagement(authority, action, target) {
+    return (McpResourceNamespaceSchema.safeParse(authority.namespace).success &&
+        (McpResourceNamespaceSchema.safeParse(target).success ||
+            McpResourceKeySchema.safeParse(target).success) &&
+        sameMcpResourceNamespace(authority.namespace, target) &&
+        authority.actions.includes(action));
+}
+/** Check the stored operation receipt BEFORE this guard: a replay recovers its original result. */
+export function checkMcpResourceApply(request, current) {
+    if (!McpResourceApplyRequestSchema.safeParse(request).success) {
+        return { code: 'invalid-request', phase: 'registration' };
+    }
+    if (current && !sameMcpResourceKey(request.key, current.key)) {
+        return { code: 'forbidden', phase: 'registration' };
+    }
+    if (request.expectedGeneration !== (current?.generation ?? null)) {
+        return { code: 'generation-mismatch', phase: 'registration' };
+    }
+    if (current?.desired.state === 'retired' || current?.observed.state === 'retired') {
+        return { code: 'retired', phase: 'registration' };
+    }
+    if (current &&
+        (request.desired.denyEpoch < current.desired.denyEpoch ||
+            request.desired.configurationRevision < current.desired.configurationRevision ||
+            request.desired.policyRevision < current.desired.policyRevision))
+        return { code: 'revision-regression', phase: 'registration' };
+    if (current) {
+        const before = current.desired;
+        const after = request.desired;
+        const sameDefinition = JSON.stringify(ordered([before.scopes, before.admission, before.branding])) ===
+            JSON.stringify(ordered([after.scopes, after.admission, after.branding]));
+        const admissionChanged = JSON.stringify(ordered(before.admission)) !== JSON.stringify(ordered(after.admission));
+        const restrictive = (after.state !== 'active' && after.state !== before.state) ||
+            before.scopes.some((scope) => !after.scopes.some((next) => next.id === scope.id)) ||
+            (admissionChanged && after.admission.mode === 'application-approval');
+        if ((!sameDefinition && after.configurationRevision <= before.configurationRevision) ||
+            (admissionChanged && after.policyRevision <= before.policyRevision) ||
+            (restrictive &&
+                (after.denyEpoch <= before.denyEpoch || after.policyRevision <= before.policyRevision))) {
+            return { code: 'revision-regression', phase: 'registration' };
+        }
+    }
+    return null;
+}
+const ordered = (value) => {
+    if (Array.isArray(value))
+        return value.map(ordered);
+    if (value !== null && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([key, item]) => [key, ordered(item)]));
+    }
+    return value;
+};
+export function sameMcpResourceDesired(a, b) {
+    return JSON.stringify(ordered(a)) === JSON.stringify(ordered(b));
+}
+/** Canonical non-secret payload for a durable (key, apply, operationId) idempotency receipt. */
+export function mcpResourceApplyFingerprint(request) {
+    const checked = McpResourceApplyRequestSchema.safeParse(request);
+    if (!checked.success)
+        throw new Error('Invalid MCP resource apply request');
+    const { operationId: _operationId, ...payload } = checked.data;
+    return JSON.stringify(ordered(payload));
+}
+/** Exact canonical runtime path; the hosting installation selects the immutable origin separately. */
+export function mcpResourcePath(pathPrefix, resourceId) {
+    const integration = McpResourceIntegrationSchema.safeParse({ version: 1, pathPrefix });
+    const key = McpResourceKeySchema.shape.resourceId.safeParse(resourceId);
+    if (!integration.success || !key.success)
+        throw new Error('Invalid MCP resource path');
+    return `${integration.data.pathPrefix}/${key.data}`;
+}
+export function mcpResourceUrls(origin, pathPrefix, resourceId) {
+    let url;
+    try {
+        url = new URL(origin);
+    }
+    catch {
+        throw new Error('Invalid MCP resource origin');
+    }
+    if (url.protocol !== 'https:' || url.origin !== origin || url.username || url.password) {
+        throw new Error('Invalid MCP resource origin');
+    }
+    const path = mcpResourcePath(pathPrefix, resourceId);
+    return {
+        resourceUri: `${origin}${path}`,
+        protectedResourceMetadataUri: `${origin}/.well-known/oauth-protected-resource${path}`,
+    };
+}

package/dist/modules/ai.js

@@ -1,5 +1,5 @@
 import { AI_ENTRY_PERMISSIONS, AI_WEBHOOK_PATH } from '../entry-rules.js';
-import { list, setUse, text } from './entry-parts.js';
+import { list, problem, setUse, text } from './entry-parts.js';
 /**
  * Plain words for every permission an app's AI key may hold. A `Record` over the permission list, so a
  * permission added to {@link AI_ENTRY_PERMISSIONS} fails the typecheck until it has words here.
@@ -22,7 +22,7 @@ export const ai = {
         line: 'The app uses AI to do work for people, such as writing a summary or reading a document.',
         category: 'AI',
         icon: 'sparkles',
-        runtimes: ['server'],
+        runtimes: ['server', 'worker'],
         requires: [],
         availability: 'ready',
         fields: [
@@ -52,14 +52,25 @@ export const ai = {
         ],
         adds: [{ name: 'AI tasks', hint: "Run on your company's own AI account." }],
     },
+    check(values, _modules, ctx) {
+        if (ctx.runtime !== 'worker')
+            return null;
+        if (text(values, 'webhookPath'))
+            return problem('webhookPath', 'Worker apps cannot receive an organisation-wide AI callback. Leave this empty.');
+        if ((list(values, 'permissions') ?? []).includes('ai.runs:create'))
+            return problem('permissions', 'Worker apps use AI tasks that answer at once. Longer work needs an app-specific callback or a scoped result reader.');
+        return null;
+    },
     toEntry(entry, values) {
         if (values === null)
             return setUse(entry, 'ai', undefined);
         const next = { offerings: list(values, 'offerings') ?? [] };
         const permissions = list(values, 'permissions');
         const webhookPath = text(values, 'webhookPath');
-        if (permissions)
+        if (permissions?.length)
             next.permissions = permissions;
+        else if (entry.workerApp)
+            next.permissions = ['ai.offerings:invoke'];
         if (webhookPath !== undefined)
             next.webhookPath = webhookPath;
         return setUse(entry, 'ai', next);

package/dist/modules/customer-grants.js

@@ -7,7 +7,7 @@ export const customerGrants = {
         line: 'Your team gives each customer the permissions they need in the app, and we keep them in step.',
         category: 'People',
         icon: 'shield',
-        runtimes: ['server'],
+        runtimes: ['server', 'worker'],
         requires: ['sign-in'],
         availability: 'ready',
         fields: [],

package/dist/modules/email.d.ts

@@ -3,6 +3,7 @@ import type { AppModule } from './types.js';
  * `uses.mail`: the app sends mail from the company's mail domain. With every setting at its default the entry
  * holds `uses.mail: true`, as before; otherwise an {@link EntryMail} holding only the settings that differ.
  * The sender name and reply-to go to the app's env (`entrySettingsEnv`); the bounce settings are for the
- * company's mail service.
+ * company's mail service. A Worker app may declare it too: foundry delivers nothing to a Worker (it has no
+ * Coolify app), and Boule's managed install gives its live copy the company's mail token and sender.
  */
 export declare const email: AppModule;

package/dist/modules/email.js

@@ -4,7 +4,8 @@ import { problem, setUse, text } from './entry-parts.js';
  * `uses.mail`: the app sends mail from the company's mail domain. With every setting at its default the entry
  * holds `uses.mail: true`, as before; otherwise an {@link EntryMail} holding only the settings that differ.
  * The sender name and reply-to go to the app's env (`entrySettingsEnv`); the bounce settings are for the
- * company's mail service.
+ * company's mail service. A Worker app may declare it too: foundry delivers nothing to a Worker (it has no
+ * Coolify app), and Boule's managed install gives its live copy the company's mail token and sender.
  */
 export const email = {
     view: {
@@ -13,7 +14,7 @@ export const email = {
         line: "The app sends email from your company's address, such as receipts and notices.",
         category: 'Messages',
         icon: 'mail',
-        runtimes: ['server'],
+        runtimes: ['server', 'worker'],
         requires: [],
         availability: 'ready',
         fields: [

package/dist/modules/files.js

@@ -34,7 +34,8 @@ export const files = {
         line: 'The app keeps files people upload, such as documents and pictures.',
         category: 'Data',
         icon: 'folder',
-        runtimes: ['server'],
+        // A Worker app's keys come from its Boule (`files-apps-minter.ts`), not from foundry.
+        runtimes: ['server', 'worker'],
         requires: [],
         availability: 'ready',
         fields: [
@@ -73,6 +74,7 @@ export const files = {
                 label: 'Email the owners when this much of the space is used',
                 help: `In percent, from ${PERCENT_MIN} to ${PERCENT_MAX}.`,
                 kind: 'number',
+                runtimes: ['server'],
                 default: FILES_SPACE_ALERT_DEFAULT,
                 min: PERCENT_MIN,
                 max: PERCENT_MAX,
@@ -82,6 +84,7 @@ export const files = {
                 label: 'Share links on your own address',
                 help: 'Links to shared files start with share. and your domain. Needs your own domain.',
                 kind: 'switch',
+                runtimes: ['server'],
                 advanced: true,
                 default: false,
             },

package/dist/modules/index.js

@@ -9,6 +9,7 @@ import { email } from './email.js';
 import { clone, isProblem } from './entry-parts.js';
 import { files } from './files.js';
 import { jobs } from './jobs.js';
+import { mcpResources } from './mcp-resources.js';
 import { organisations } from './organisations.js';
 import { SECRET_OUTPUTS, referenceProblem } from './outputs.js';
 import { reporting } from './reporting.js';
@@ -24,6 +25,7 @@ export { databaseAddressesOf } from './database.js';
 export const MODULES = [
     signIn,
     assistants,
+    mcpResources,
     workspaces,
     database,
     signedRecords,
@@ -165,7 +167,8 @@ export function checkModules(modules, ctx) {
         }
         for (const field of view.fields) {
             if (field.runtimes && !field.runtimes.includes(ctx.runtime)) {
-                if (isEmpty(values[field.key]))
+                // A default the module fills in is not a setting the app made: only what was given counts.
+                if (isEmpty(modules[id]?.[field.key]))
                     continue;
                 return refuse(field.key, `"${field.label}" can only be set for ${field.runtimes.map((r) => RUNTIME_WORDS[r]).join(' or ')}. This app is ${RUNTIME_WORDS[ctx.runtime]}.`);
             }

package/dist/modules/jobs.js

@@ -12,7 +12,7 @@ export const jobs = {
         line: 'The app runs tasks on a timer or later, such as a nightly report or a reminder.',
         category: 'In the background',
         icon: 'clock',
-        runtimes: ['server'],
+        runtimes: ['server', 'worker'],
         requires: [],
         availability: 'ready',
         fields: [

package/dist/modules/mcp-resources.d.ts

@@ -0,0 +1,2 @@
+import type { AppModule } from './types.js';
+export declare const mcpResources: AppModule;

package/dist/modules/mcp-resources.js

@@ -0,0 +1,61 @@
+import { McpResourceIntegrationSchema } from '../mcp-resources/schema.js';
+import { problem, setAuthPart } from './entry-parts.js';
+export const mcpResources = {
+    view: {
+        id: 'mcp-resources',
+        name: 'Configurable MCP resources',
+        line: 'Your app manages independent assistant connections configured by its customers.',
+        category: 'AI',
+        icon: 'bot',
+        runtimes: ['server', 'worker'],
+        requires: ['sign-in'],
+        availability: 'ready',
+        fields: [
+            {
+                key: 'version',
+                label: 'Integration version',
+                kind: 'number',
+                default: 1,
+                min: 1,
+                max: 1,
+                hidden: true,
+            },
+            {
+                key: 'pathPrefix',
+                label: 'Where configured assistants connect',
+                kind: 'path',
+                default: '/mcp/resources',
+                max: 160,
+                pattern: '^/[a-z0-9_-]+(?:/[a-z0-9_-]+)*$',
+                help: 'Each configured connection gets an independent path below this address.',
+            },
+        ],
+        adds: [
+            {
+                name: 'Resource management integration',
+                hint: 'Provisioning requires compatible platform and identity services.',
+            },
+        ],
+    },
+    check(values, modules) {
+        if (modules['sign-in']?.users !== 'customers' || modules['sign-in']?.team === true) {
+            return problem(null, 'Configurable MCP resources needs Sign-in for customers only.');
+        }
+        if (!McpResourceIntegrationSchema.safeParse(values).success) {
+            return problem(null, 'Configurable MCP resources needs version 1 and an absolute path prefix of lowercase letters, digits, dashes and underscores.');
+        }
+        return null;
+    },
+    toEntry(entry, values) {
+        if (values === null)
+            return setAuthPart(entry, 'mcpResources', undefined);
+        const checked = McpResourceIntegrationSchema.safeParse(values);
+        if (!checked.success || !entry.uses?.auth)
+            return problem(null, 'Invalid configurable MCP integration.');
+        return setAuthPart(entry, 'mcpResources', checked.data);
+    },
+    fromEntry(entry) {
+        const integration = entry.uses?.auth?.mcpResources;
+        return integration ? { ...integration } : null;
+    },
+};

package/dist/modules/outputs.js

@@ -5,6 +5,7 @@
 export const OUTPUTS = {
     'sign-in': ['issuer', 'client-id'],
     assistants: ['mcp-url'],
+    'mcp-resources': [],
     workspaces: [],
     database: ['address', 'owner-address'],
     'signed-records': ['registrar-url'],

package/dist/modules/repository.d.ts

@@ -2,5 +2,7 @@ import type { AppModule } from './types.js';
 /**
  * `uses.repo`: the app gets a key for its own repository. The entry's `repo` names the repository (it comes
  * from the install, not from this module); `access` says whether the app may only read or also push.
+ * Worker apps keep entry.repo null: Boule binds their HTTPS credential to the trusted installed source
+ * and access, and handles renewal; foundry never creates a server SSH deploy key for a Worker.
  */
 export declare const repository: AppModule;

package/dist/modules/repository.js

@@ -2,6 +2,8 @@ import { setUse } from './entry-parts.js';
 /**
  * `uses.repo`: the app gets a key for its own repository. The entry's `repo` names the repository (it comes
  * from the install, not from this module); `access` says whether the app may only read or also push.
+ * Worker apps keep entry.repo null: Boule binds their HTTPS credential to the trusted installed source
+ * and access, and handles renewal; foundry never creates a server SSH deploy key for a Worker.
  */
 export const repository = {
     view: {
@@ -10,7 +12,7 @@ export const repository = {
         line: 'The app reads or updates the files in its repository, such as the pages it keeps there.',
         category: 'Data',
         icon: 'git-branch',
-        runtimes: ['server'],
+        runtimes: ['server', 'worker'],
         requires: [],
         availability: 'ready',
         fields: [

package/dist/modules/workspaces.js

@@ -8,7 +8,7 @@ export const workspaces = {
         line: 'Your customers make a shared space, invite the people they work with and give each one a role.',
         category: 'People',
         icon: 'users',
-        runtimes: ['server'],
+        runtimes: ['server', 'worker'],
         requires: ['sign-in'],
         availability: 'ready',
         fields: [

package/dist/org.d.ts

@@ -1,3 +1,4 @@
+import { type McpResourceIntegration } from './mcp-resources/schema.js';
 import { type WorkerAppConfig } from './worker-app-config.js';
 export type { WorkerAppConfig } from './worker-app-config.js';
 export { AI_ENTRY_PERMISSIONS, FILES_ENTRY_PERMISSIONS, MCP_PATH, ONBOARDING_PATH_MAX_LENGTH, ROOM_STEPS_MAX, ROOM_STEPS_MIN, ROOM_TEXT_MAX, WORKSPACE_ROLE, WORKSPACE_ROLES_MAX, } from './entry-rules.js';
@@ -640,6 +641,8 @@ export interface EntryAuth {
         };
         managePath?: string;
     };
+    /** Integration bootstrap only. Customer MCP definitions are runtime application data. */
+    mcpResources?: McpResourceIntegration;
     /**
      * How the customer proves who they are. `password` is the default.
      * `email-code` has the sign-in page mail a one-time code instead of asking