@sentropic/artifacts 0.1.2 → 0.1.4

package/README.md

@@ -4,6 +4,59 @@ Generic, host-independent artifact domain state for the Sentropic artifacts
 provider (`sentropic.artifacts`, spec-v8 §9), covering L-5a–5e. Version
 `0.1.2` adds UTF-8 text publication, exposes storage adapters and ships SQL migrations.
 Version `0.1.1` fixed activation ticket release and channel binding (FL-ACT).
+Version `0.1.4` hardens host authority, replay isolation, publication and content
+responses, and adds the platform-free `@sentropic/artifacts/mcp-core` entry.
+
+## Migrating to 0.1.4
+
+HTTP hosts must supply a trusted `HttpRequest.storageScopeId` for `/ensure`.
+MCP hosts configure `defaultStorageScopeId` or supply the trusted invocation's
+`ArtifactsInvokeInput.storageScopeId`; tool arguments cannot choose storage.
+Legacy body/tool `storageScopeId` and client `paramsHash` fields remain accepted
+but are ignored. Missing host scope now returns 400. Ensure hashes cover the
+validated parameters, binding, owner and scope; publication hashes cover release
+metadata, server-derived file digests and validated source provenance (including
+its absence and recipe step order). Source writes occur within the idempotent
+publication operation, so unchanged replays do not write provenance again.
+Direct service callers publishing a `source` pass their host `SourceStore` as
+the second argument to `publish`; the HTTP/MCP app supplies its configured store.
+Keys are isolated by operation and
+principal. A changed payload under the same key returns an explicit conflict.
+Persisted unscoped replay keys are no longer consulted after upgrading.
+
+Publication defaults to 128 files, 16 MiB per file and 64 MiB total. Hosts can
+override these positive integer limits through `createPublicationService({
+limits: { maxFiles, maxFileBytes, maxTotalBytes } })`; the HTTP decoder uses the
+same byte budgets before allocating bytes. Paths must be unique canonical
+relative paths, at most 1024 UTF-8 bytes: empty/dot segments, backslashes,
+percent escapes, URL delimiters, colons and control characters are rejected.
+Existing integrations using larger bundles or noncanonical paths must adjust
+their limits or filenames. Invalid publications fail before object-store effects.
+Upload sessions cap client `maxSize` by the host `maxUploadBytes` and publication
+file/total limits. Every append checks remaining cumulative capacity before
+decoding bytes or writing staging. Upload publication metadata is validated
+before the session is consumed; a rejected path or MIME type can be corrected
+and committed using the same staged bytes. Finalization validates, hashes and
+publishes one copied snapshot. Overlapping append/commit operations return 409;
+failed verification or metadata validation leaves the session retryable.
+
+Content `HEAD` responses have the corresponding GET headers and no body,
+including errors and activation. Errors and activation responses include the
+same security and no-store headers as content responses, with a restrictive CSP.
+
+Import `createArtifactsManifest`, `createArtifactsToolExecutor` or
+`createArtifactsAdapter` from `@sentropic/artifacts/mcp-core` when the platform
+is absent. This entry has no runtime platform import. Existing `/mcp` exports,
+including `createArtifactsRegistryDefinition`, retain their platform integration.
+The existing root barrel re-exports `/mcp` and also requires the platform.
+Platform types remain referenced in TypeScript declarations for adapter typing.
+`make probe-artifacts-packed-consumer ENV=test-artifacts-hardening` installs the
+tarball alone in a separate consumer, proves the platform is absent and runs the
+15-tool manifest and ensure/publish/get/list flow before the platform proof.
+
+Release coordination: #707 reserves 0.1.3 for optional platform peer widening;
+0.1.4 retains `>=0.3.0 <0.5.0` and fits cluster-mesh's current
+`>=0.1.0 <0.2.0` and #707's `>=0.1.3 <0.2.0` artifacts ranges.
 
 ## What's here (L-5a)
 
@@ -137,11 +190,11 @@ a registrable domain. Assets within the same artifact origin remain loadable.
   method/route/binding checks plus Origin/CSRF evidence for writes.
 - `src/server/templates.ts` — generic template kit + versioned API guide
   catalog port (hosts inject approved local assets).
-- `src/mcp.ts` — the `sentropic.artifacts` MCP provider: 15 exact
+- `src/mcp-core.ts` — the platform-free `sentropic.artifacts` MCP provider: 15 exact
   `artifacts_*` tools with closed schemas, a host-bindable invocation
-  scope, an executor over the same HTTP app, a platform adapter, and the
-  `@sentropic/mcp-platform` kernel registry definition (the platform is
-  an optional peer, required only by the `./mcp` subpath).
+  scope, an executor over the same HTTP app and a platform adapter.
+- `src/mcp.ts` — the compatible `@sentropic/mcp-platform` kernel registry
+  definition wrapper (the optional peer is required here and by the root barrel).
 
 Ticket issuance and redemption both require `subjectId`, `artifactId`,
 `releaseId` and `channel`. The handler checks the release resolved from the

package/dist/content/handler.js

@@ -13,8 +13,15 @@ import { errorBody } from '../http.js';
 import { CONTENT_GRANT_TTL_SECONDS } from './grants.js';
 import { contentHeaders, grantCookie, parseGrantCookie } from './headers.js';
 import { isServiceWorkerPath, parseContentHost, resolveContentPath } from './routing.js';
+function jsonResponse(status, body, extra = {}) {
+    return { status, body, headers: {
+            ...contentHeaders({ mimeType: 'application/json', size: Buffer.byteLength(JSON.stringify(body)) }),
+            'content-security-policy': "default-src 'none'; frame-ancestors 'none'; base-uri 'none'",
+            ...extra,
+        } };
+}
 function fail(status) {
-    return { status, headers: { 'content-type': 'application/json' }, body: errorBody(status) };
+    return jsonResponse(status, errorBody(status));
 }
 /** Create the content handler over injected host ports (no server). */
 export function createContentHandler(deps) {
@@ -52,78 +59,87 @@ export function createContentHandler(deps) {
             bytes,
         };
     }
-    return {
-        async handle(request) {
-            if (request.method !== 'GET' && request.method !== 'HEAD')
-                return fail(404);
-            const origin = parseContentHost(request.host, deps.baseDomain);
-            if (origin === undefined)
-                return fail(404);
-            let artifactId;
-            let release;
-            if (origin.kind === 'stable') {
-                artifactId = origin.artifactId;
-                release = await deps.publication.getCurrent(artifactId);
-            }
-            else {
-                release = await deps.publication.getRelease(origin.releaseId);
-                if (release === undefined)
-                    return fail(404);
-                const owner = JSON.parse(release.manifest).artifactId;
-                if (typeof owner !== 'string')
-                    return fail(404);
-                artifactId = owner;
-            }
+    async function handle(request) {
+        if (request.method !== 'GET' && request.method !== 'HEAD')
+            return fail(404);
+        const origin = parseContentHost(request.host, deps.baseDomain);
+        if (origin === undefined)
+            return fail(404);
+        let artifactId;
+        let release;
+        if (origin.kind === 'stable') {
+            artifactId = origin.artifactId;
+            release = await deps.publication.getCurrent(artifactId);
+        }
+        else {
+            release = await deps.publication.getRelease(origin.releaseId);
             if (release === undefined)
                 return fail(404);
-            if (request.ticket !== undefined) {
-                if (request.actorId === undefined || request.actorId.length === 0)
-                    return fail(401);
-                try {
-                    await deps.tickets.redeem(request.ticket, {
-                        subjectId: request.actorId, artifactId, releaseId: release.releaseId, channel: origin.kind,
-                    });
-                }
-                catch {
-                    return fail(401);
-                }
-                if (!(await canReadNow(artifactId, request.actorId)))
-                    return fail(404);
-                const token = deps.grants.issue({
-                    subjectId: request.actorId,
-                    artifactId,
-                    releaseId: release.releaseId,
+            const owner = JSON.parse(release.manifest).artifactId;
+            if (typeof owner !== 'string')
+                return fail(404);
+            artifactId = owner;
+        }
+        if (release === undefined)
+            return fail(404);
+        if (request.ticket !== undefined) {
+            if (request.actorId === undefined || request.actorId.length === 0)
+                return fail(401);
+            try {
+                await deps.tickets.redeem(request.ticket, {
+                    subjectId: request.actorId, artifactId, releaseId: release.releaseId, channel: origin.kind,
                 });
-                return {
-                    status: 200,
-                    headers: {
-                        'content-type': 'application/json',
-                        'set-cookie': grantCookie(token, CONTENT_GRANT_TTL_SECONDS),
-                    },
-                    body: { activated: true, artifactId, releaseId: release.releaseId },
-                };
             }
-            const token = parseGrantCookie(request.cookie);
-            if (token === undefined)
+            catch {
                 return fail(401);
-            let claims;
+            }
+            if (!(await canReadNow(artifactId, request.actorId)))
+                return fail(404);
+            const token = deps.grants.issue({
+                subjectId: request.actorId,
+                artifactId,
+                releaseId: release.releaseId,
+            });
+            return jsonResponse(200, { activated: true, artifactId, releaseId: release.releaseId }, {
+                'set-cookie': grantCookie(token, CONTENT_GRANT_TTL_SECONDS),
+            });
+        }
+        const token = parseGrantCookie(request.cookie);
+        if (token === undefined)
+            return fail(401);
+        let claims;
+        try {
+            claims = deps.grants.verify(token);
+        }
+        catch {
+            return fail(401);
+        }
+        if (claims.artifactId !== artifactId || claims.releaseId !== release.releaseId) {
+            return fail(401); // fresh version consent: activate this release
+        }
+        if (request.actorId !== undefined && request.actorId !== claims.subjectId)
+            return fail(401);
+        if (!(await canReadNow(artifactId, claims.subjectId)))
+            return fail(404);
+        const filePath = resolveContentPath(request.path);
+        if (filePath === undefined || isServiceWorkerPath(filePath))
+            return fail(404);
+        return serveFile(artifactId, release.manifest, filePath);
+    }
+    return {
+        async handle(request) {
+            let response;
             try {
-                claims = deps.grants.verify(token);
+                response = await handle(request);
             }
             catch {
-                return fail(401);
+                response = fail(500);
             }
-            if (claims.artifactId !== artifactId || claims.releaseId !== release.releaseId) {
-                return fail(401); // fresh version consent: activate this release
+            if (request.method === 'HEAD') {
+                const { bytes: _bytes, body: _body, ...head } = response;
+                return head;
             }
-            if (request.actorId !== undefined && request.actorId !== claims.subjectId)
-                return fail(401);
-            if (!(await canReadNow(artifactId, claims.subjectId)))
-                return fail(404);
-            const filePath = resolveContentPath(request.path);
-            if (filePath === undefined || isServiceWorkerPath(filePath))
-                return fail(404);
-            return serveFile(artifactId, release.manifest, filePath);
+            return response;
         },
     };
 }

package/dist/http.d.ts

@@ -12,6 +12,8 @@ export interface HttpRequest {
     path: string;
     body: unknown;
     actorId: string;
+    /** Trusted host context, resolved alongside actorId; never copy from the body. */
+    storageScopeId?: string;
 }
 export interface HttpResponse {
     status: number;

package/dist/http.js

@@ -20,6 +20,8 @@
  * 403 answers remain for actors who can already read the artifact.
  */
 import { buildEnsureRequest } from './client.js';
+import { DEFAULT_PUBLICATION_LIMITS } from './server/publication.js';
+import { validatePublicationFiles } from './server/publication-limits.js';
 import { createContentRuntime } from './server/runtime.js';
 import { evaluateAccess, grantAccess, revokeAccess } from './server/access.js';
 import { parseSourceRef } from './server/sources.js';
@@ -71,9 +73,11 @@ function needString(value, name) {
         throw new Error(`invalid request: missing ${name}`);
     return value;
 }
-function needBytes(value) {
+function needBytes(value, maxBytes) {
     if (!Array.isArray(value))
         throw new Error('invalid file bytes: must be an array');
+    if (value.length > maxBytes)
+        throw new Error('invalid publication byte budget');
     const bytes = new Uint8Array(value.length);
     for (let i = 0; i < value.length; i += 1) {
         const byte = value[i];
@@ -86,16 +90,18 @@ function needBytes(value) {
 }
 /** Canonical text MIME types; parameters are omitted (encoding is always UTF-8). */
 export const TEXT_MIME_PATTERN = '^(?:text/[a-z0-9!#$&^_.+-]+|application/(?:javascript|ecmascript|json|xml|[a-z0-9!#$&^_.+-]+\\+(?:json|xml))|image/svg\\+xml)(?![\\s\\S])';
-function needFileBytes(entry, mimeType) {
+function needFileBytes(entry, mimeType, maxBytes) {
     const hasBytes = 'bytes' in entry;
     const hasText = 'text' in entry;
     if (hasBytes === hasText)
         throw new Error('invalid file: supply exactly one of bytes or text');
     if (hasBytes)
-        return needBytes(entry['bytes']);
+        return needBytes(entry['bytes'], maxBytes);
     if (typeof entry['text'] !== 'string' || !new RegExp(TEXT_MIME_PATTERN).test(mimeType)) {
         throw new Error('invalid file text: expected a string and a canonical text MIME type');
     }
+    if (Buffer.byteLength(entry['text'], 'utf8') > maxBytes)
+        throw new Error('invalid publication byte budget');
     return new TextEncoder().encode(entry['text']);
 }
 /** Create the HTTP app over injected services (no server, no fetch). */
@@ -155,9 +161,9 @@ export function createHttpArtifactApp(deps) {
                 if (request.method === 'POST' && request.path === '/ensure') {
                     const ensured = buildEnsureRequest(deps.parameterSchema, {
                         bindingName: needString(body['bindingName'], 'bindingName'),
-                        storageScopeId: needString(body['storageScopeId'], 'storageScopeId'),
+                        storageScopeId: needString(request.storageScopeId, 'host storageScopeId'),
                         idempotencyKey: needString(body['idempotencyKey'], 'idempotencyKey'),
-                        paramsHash: typeof body['paramsHash'] === 'string' ? body['paramsHash'] : '',
+                        paramsHash: '',
                         parameters: (body['parameters'] ?? {}),
                     });
                     const result = await deps.artifacts.ensurePrivateView({
@@ -166,7 +172,7 @@ export function createHttpArtifactApp(deps) {
                         storageScopeId: ensured.storageScopeId,
                         bindingName: ensured.bindingName,
                         idempotencyKey: ensured.idempotencyKey,
-                        paramsHash: ensured.paramsHash,
+                        parameters: ensured.parameters,
                     });
                     if ((await deps.acls.getArtifactAcl(result.artifactId)) === undefined) {
                         await deps.acls.putArtifactAcl(result.artifactId, {
@@ -187,15 +193,20 @@ export function createHttpArtifactApp(deps) {
                     if (acl.storageScopeId === undefined)
                         throw new Error('invalid request: missing storage scope');
                     const rawFiles = body['files'];
-                    if (!Array.isArray(rawFiles))
-                        throw new Error('invalid request: missing files');
+                    const limits = deps.publication.limits ?? DEFAULT_PUBLICATION_LIMITS;
+                    if (!Array.isArray(rawFiles) || rawFiles.length === 0 || rawFiles.length > limits.maxFiles) {
+                        throw new Error('invalid publication file count budget');
+                    }
+                    let remaining = limits.maxTotalBytes;
                     const files = rawFiles.map((file) => {
                         const entry = needObject(file);
                         const mimeType = needString(entry['mimeType'], 'file.mimeType');
+                        const bytes = needFileBytes(entry, mimeType, Math.min(limits.maxFileBytes, remaining));
+                        remaining -= bytes.byteLength;
                         return {
                             path: needString(entry['path'], 'file.path'),
                             mimeType,
-                            bytes: needFileBytes(entry, mimeType),
+                            bytes,
                         };
                     });
                     const source = body['source'];
@@ -206,11 +217,10 @@ export function createHttpArtifactApp(deps) {
                         artifactId,
                         profile: (body['profile'] ?? {}),
                         files,
+                        source: attached,
                         idempotencyKey: typeof body['idempotencyKey'] === 'string' ? body['idempotencyKey'] : undefined,
                         paramsHash: typeof body['paramsHash'] === 'string' ? body['paramsHash'] : undefined,
-                    });
-                    if (attached !== undefined)
-                        await deps.sources.putSource(artifactId, attached);
+                    }, deps.sources);
                     await deps.lifecycle.trackRelease(artifactId, result.releaseId);
                     return { status: 201, body: result };
                 }
@@ -415,12 +425,13 @@ export function createHttpArtifactApp(deps) {
                     const acl = await requireVisible(artifactId, request.actorId);
                     assertArtifactAccess({ actorUserId: request.actorId, artifactOwnerId: acl.ownerId, action: 'mutate' });
                     const maxSize = body['maxSize'];
-                    if (maxSize !== undefined && (!Number.isInteger(maxSize) || maxSize < 1)) {
+                    if (maxSize !== undefined && (!Number.isSafeInteger(maxSize) || maxSize < 1)) {
                         throw new Error('invalid request: maxSize must be a positive integer');
                     }
+                    const limits = deps.publication.limits ?? DEFAULT_PUBLICATION_LIMITS;
                     const begun = await uploads.begin({
                         mimeType: needString(body['mimeType'], 'mimeType'),
-                        maxSize: maxSize,
+                        maxSize: Math.min(maxSize ?? Infinity, limits.maxFileBytes, limits.maxTotalBytes),
                     });
                     uploadOwners.set(begun.uploadId, { artifactId, ownerId: request.actorId });
                     return { status: 201, body: begun };
@@ -430,10 +441,12 @@ export function createHttpArtifactApp(deps) {
                     const uploadId = needString(body['uploadId'], 'uploadId');
                     requireUploadOwner(uploadId, request.actorId);
                     const offset = body['offset'];
-                    if (!Number.isInteger(offset) || offset < 0) {
+                    if (!Number.isSafeInteger(offset) || offset < 0) {
                         throw new Error('invalid request: offset must be a non-negative integer');
                     }
-                    const appended = await uploads.append(uploadId, offset, needBytes(body['bytes']));
+                    const limits = deps.publication.limits ?? DEFAULT_PUBLICATION_LIMITS;
+                    const remaining = Math.min(uploads.remainingBytes(uploadId, offset), limits.maxFileBytes - offset, limits.maxTotalBytes - offset);
+                    const appended = await uploads.append(uploadId, offset, needBytes(body['bytes'], remaining));
                     return { status: 200, body: appended };
                 }
                 if (request.method === 'POST' && request.path === '/uploads/commit') {
@@ -452,21 +465,24 @@ export function createHttpArtifactApp(deps) {
                     if (!Number.isInteger(size) || size < 0) {
                         throw new Error('invalid request: size must be a non-negative integer');
                     }
+                    const files = [{
+                            path: needString(body['path'], 'path'),
+                            mimeType: needString(body['mimeType'], 'mimeType'),
+                            bytes: new Uint8Array(0),
+                        }];
                     await uploads.commit(uploadId, {
                         digest: needString(body['digest'], 'digest'),
                         size: size,
+                    }, (bytes) => {
+                        files[0].bytes = bytes;
+                        validatePublicationFiles(files, deps.publication.limits ?? DEFAULT_PUBLICATION_LIMITS);
                     });
-                    const bytes = await staging.read(uploadId);
                     const result = await deps.publication.publish({
                         ownerId: acl.ownerId,
                         storageScopeId: acl.storageScopeId,
                         artifactId,
                         profile: (body['profile'] ?? {}),
-                        files: [{
-                                path: needString(body['path'], 'path'),
-                                mimeType: needString(body['mimeType'], 'mimeType'),
-                                bytes,
-                            }],
+                        files,
                         idempotencyKey: typeof body['idempotencyKey'] === 'string' ? body['idempotencyKey'] : undefined,
                         paramsHash: typeof body['paramsHash'] === 'string' ? body['paramsHash'] : undefined,
                     });

package/dist/mcp-core.d.ts

@@ -0,0 +1,62 @@
+/**
+ * L-5e — reusable artifacts MCP provider (spec-v8 §9 5e, review B3).
+ *
+ * Part 1: identity, the 15 exact `artifacts_*` tool specs with closed input
+ * schemas, and the platform manifest. The logical provider ID is
+ * `sentropic.artifacts`; the generic provider hardcodes no application
+ * OAuth vocabulary — a host binds its invocation scope through the
+ * manifest factory before digests freeze (§3.5). Part 2 adds the tool
+ * executor over the same HTTP app direct calls use; part 3 adds the
+ * platform adapter and the kernel registry definition (§3).
+ */
+import type { AppConnectorProviderAdapter, AppMcpProviderManifest, CapabilityTool } from '@sentropic/mcp-platform';
+import type { ProviderParameterSchema } from '@sentropic/mcp-platform/registry';
+import type { HttpRequest, HttpResponse } from './http.js';
+export declare const ARTIFACTS_PROVIDER_ID = "sentropic.artifacts";
+export declare const ARTIFACTS_APP_ID = "sentropic-artifacts";
+export declare const ARTIFACTS_PROVIDER_VERSION = "0.1.4";
+export declare const ARTIFACTS_TOOL_NAMES: readonly ["artifacts_get_template", "artifacts_get_api_guide", "artifacts_ensure", "artifacts_publish", "artifacts_create_upload", "artifacts_commit_upload", "artifacts_list", "artifacts_get", "artifacts_get_source", "artifacts_fork", "artifacts_set_access", "artifacts_promote", "artifacts_renew", "artifacts_delete", "artifacts_restore"];
+export type ArtifactsToolName = (typeof ARTIFACTS_TOOL_NAMES)[number];
+type Schema = Record<string, unknown>;
+interface ToolSpec {
+    name: ArtifactsToolName;
+    description: string;
+    inputSchema: Schema;
+    mutability: CapabilityTool['mutability'];
+    idempotent?: boolean;
+    confirm?: boolean;
+}
+export declare const ARTIFACTS_TOOL_SPECS: readonly ToolSpec[];
+/** Kernel provider parameter schema (typed non-secret host settings). */
+export declare const ARTIFACTS_PARAMETER_SCHEMA: ProviderParameterSchema;
+export interface ArtifactsManifestOptions {
+    /** Host authorization profile: scope bound to every tool invocation. */
+    invocationScope?: string;
+    displayName?: string;
+}
+/** Build the sentropic.artifacts manifest (host scope bound pre-freeze). */
+export declare function createArtifactsManifest(options?: ArtifactsManifestOptions): AppMcpProviderManifest;
+export interface ArtifactsApp {
+    handle(request: HttpRequest): Promise<HttpResponse>;
+}
+export interface ArtifactsInvokeInput {
+    tool: string;
+    actorId: string;
+    /** Trusted host scope; tool arguments cannot select storage. */
+    storageScopeId?: string;
+    args: Record<string, unknown>;
+}
+/** Create the 15-tool executor over any conforming artifacts HTTP app. */
+export declare function createArtifactsToolExecutor(deps: {
+    app: ArtifactsApp;
+    defaultStorageScopeId?: string;
+}): {
+    invoke(input: ArtifactsInvokeInput): Promise<HttpResponse>;
+};
+export interface ArtifactsAdapterOptions extends ArtifactsManifestOptions {
+    app: ArtifactsApp;
+    defaultStorageScopeId?: string;
+}
+/** Create the platform adapter driving the 15 tools over the shared app. */
+export declare function createArtifactsAdapter(options: ArtifactsAdapterOptions): AppConnectorProviderAdapter;
+export {};