hoi4-agent-tools 0.1.7 → 1.0.0

package/dist/hoi4_agent_tools/map/service.js

@@ -1,17 +1,135 @@
 import path from 'node:path';
 import fg from 'fast-glob';
-import { ArtifactStore, boundedSourceHashEvidence, } from '../core/artifacts.js';
+import { ArtifactStore, boundedSourceHashEvidence, publicArtifactLink, } from '../core/artifacts.js';
 import { canonicalJson, compareCodeUnits, hashCanonical, sha256Bytes } from '../core/canonical.js';
 import { sortDiagnostics } from '../core/diagnostics.js';
 import { CoreEngine } from '../core/engine.js';
 import { RenderBudget } from '../core/render-budget.js';
+import { ServiceError } from '../core/result.js';
 import { WorkspaceScanner } from '../core/scanner.js';
 import { readDependenciesFromScannedFiles, } from '../core/transactions.js';
 import { PACKAGE_VERSION } from '../version.js';
-import { defaultMapSelectorValue, MapWorkspaceIndex } from './model.js';
+import { MAP_PROVINCE_GEOMETRY_SELECTOR_LIMIT, MAP_SELECTED_OFFSET_BYTES, MAP_SELECTED_PIXEL_LIMIT, } from './limits.js';
+import { defaultMapSelectorValue, MapWorkspaceIndex, } from './model.js';
 import { planMapOperationsAsync } from './operations.js';
 import { renderMap, renderMapDiff, } from './render.js';
 import { validateMapAsync } from './validation.js';
+function compareNumbers(left, right) {
+    return left - right;
+}
+function exactGeometryBounds(geometry) {
+    return {
+        minX: geometry.minX,
+        minY: geometry.minY,
+        maxXExclusive: geometry.maxX + 1,
+        maxYExclusive: geometry.maxY + 1,
+    };
+}
+function assertProvinceGeometryExportPixelBudget(pixelCount) {
+    if (!Number.isSafeInteger(pixelCount) || pixelCount < 0) {
+        throw new ServiceError('MAP_SELECTED_PIXEL_BUDGET_BLOCKED', 'Province geometry export declares an invalid selected-pixel count', {
+            source: 'Province geometry export',
+            selectedPixels: pixelCount,
+            maximumSelectedPixels: MAP_SELECTED_PIXEL_LIMIT,
+        });
+    }
+    if (pixelCount > MAP_SELECTED_PIXEL_LIMIT) {
+        throw new ServiceError('MAP_SELECTED_PIXEL_BUDGET_BLOCKED', 'Province geometry export exceeds the fixed selected-pixel memory budget', {
+            source: 'Province geometry export',
+            selectedPixels: pixelCount,
+            maximumSelectedPixels: MAP_SELECTED_PIXEL_LIMIT,
+            maximumOffsetBytes: MAP_SELECTED_PIXEL_LIMIT * MAP_SELECTED_OFFSET_BYTES,
+        });
+    }
+}
+/**
+ * Export maximal, canonical row runs from the same raster used by map rewrites.
+ * Runs are collected in raster order, so every province's tuples are sorted by
+ * y and then startX without a second, memory-heavy sort.
+ */
+export async function exportProvinceGeometryRowRuns(source, provinceIds, signal) {
+    signal?.throwIfAborted();
+    if (provinceIds.length > MAP_PROVINCE_GEOMETRY_SELECTOR_LIMIT) {
+        throw new ServiceError('MAP_PROVINCE_GEOMETRY_SELECTOR_LIMIT', `Province geometry inspection accepts at most ${MAP_PROVINCE_GEOMETRY_SELECTOR_LIMIT} IDs`, {
+            requestedProvinceCount: provinceIds.length,
+            maximumProvinceCount: MAP_PROVINCE_GEOMETRY_SELECTOR_LIMIT,
+        });
+    }
+    if (provinceIds.some((provinceId) => !Number.isSafeInteger(provinceId) || provinceId < 0)) {
+        throw new ServiceError('MAP_PROVINCE_GEOMETRY_SELECTOR_INVALID', 'Province geometry inspection IDs must be non-negative safe integers');
+    }
+    const raster = source.raster;
+    if (raster === undefined) {
+        throw new ServiceError('MAP_PROVINCE_BITMAP_MISSING', 'Exact province geometry inspection requires provinces.bmp');
+    }
+    const requestedProvinceIds = [...new Set(provinceIds)].sort(compareNumbers);
+    const unknownProvinceIds = requestedProvinceIds.filter((provinceId) => !source.definitionsById.has(provinceId));
+    const missingGeometryProvinceIds = requestedProvinceIds.filter((provinceId) => source.definitionsById.has(provinceId) && !raster.geometry.has(provinceId));
+    const exportableProvinceIds = requestedProvinceIds.filter((provinceId) => source.definitionsById.has(provinceId) && raster.geometry.has(provinceId));
+    let pixelCount = 0;
+    for (const provinceId of exportableProvinceIds) {
+        const geometry = raster.geometry.get(provinceId);
+        if (geometry === undefined)
+            continue;
+        pixelCount += geometry.pixelCount;
+        assertProvinceGeometryExportPixelBudget(pixelCount);
+    }
+    const rowRunsByProvince = new Map(exportableProvinceIds.map((provinceId) => [provinceId, []]));
+    const observedPixelCounts = new Map(exportableProvinceIds.map((provinceId) => [provinceId, 0]));
+    for (let y = 0; y < raster.height; y += 1) {
+        if (y % 32 === 0) {
+            await new Promise((resolve) => setImmediate(resolve));
+            signal?.throwIfAborted();
+        }
+        let x = 0;
+        while (x < raster.width) {
+            const provinceId = raster.provinceIds[y * raster.width + x] ?? -1;
+            const startX = x;
+            x += 1;
+            while (x < raster.width && (raster.provinceIds[y * raster.width + x] ?? -1) === provinceId) {
+                x += 1;
+            }
+            const runs = rowRunsByProvince.get(provinceId);
+            if (runs === undefined)
+                continue;
+            runs.push([y, startX, x]);
+            observedPixelCounts.set(provinceId, (observedPixelCounts.get(provinceId) ?? 0) + x - startX);
+        }
+    }
+    signal?.throwIfAborted();
+    const provinces = exportableProvinceIds.map((provinceId) => {
+        const geometry = raster.geometry.get(provinceId);
+        if (geometry === undefined) {
+            throw new ServiceError('MAP_RASTER_GEOMETRY_MISMATCH', 'Province geometry disappeared during exact row-run export', { provinceId });
+        }
+        const observedPixelCount = observedPixelCounts.get(provinceId) ?? 0;
+        if (observedPixelCount !== geometry.pixelCount) {
+            throw new ServiceError('MAP_RASTER_GEOMETRY_MISMATCH', 'Exact province row runs do not match the indexed province pixel count', {
+                provinceId,
+                expectedPixelCount: geometry.pixelCount,
+                observedPixelCount,
+            });
+        }
+        const rowRuns = rowRunsByProvince.get(provinceId) ?? [];
+        return {
+            provinceId,
+            pixelCount: observedPixelCount,
+            bounds: exactGeometryBounds(geometry),
+            rowRunCount: rowRuns.length,
+            rowRuns,
+        };
+    });
+    return {
+        width: raster.width,
+        height: raster.height,
+        requestedProvinceIds,
+        unknownProvinceIds,
+        missingGeometryProvinceIds,
+        pixelCount,
+        rowRunCount: provinces.reduce((count, province) => count + province.rowRunCount, 0),
+        provinces,
+    };
+}
 const provinceOperationKinds = new Set([
     'split_province',
     'create_province',
@@ -181,7 +299,7 @@ export function attributeMapValidationDiagnostics(input) {
             attributed.push({
                 code: 'MAP_VALIDATION_OPERATION_UNOWNED',
                 severity: 'blocker',
-                category: 'transaction',
+                category: 'validation',
                 message: `${diagnostic.code} already existed before the manifest and has no originating operation`,
                 ...(diagnostic.location === undefined ? {} : { location: diagnostic.location }),
                 ...(diagnostic.related === undefined ? {} : { related: diagnostic.related }),
@@ -238,7 +356,7 @@ export function attributeMapValidationDiagnostics(input) {
         attributed.push({
             code: 'MAP_VALIDATION_OPERATION_UNOWNED',
             severity: 'blocker',
-            category: 'transaction',
+            category: 'validation',
             message: `${diagnostic.code} cannot be attributed to any manifest operation`,
             ...(diagnostic.location === undefined ? {} : { location: diagnostic.location }),
             ...(diagnostic.related === undefined ? {} : { related: diagnostic.related }),
@@ -390,14 +508,14 @@ export class AgentNudger {
             validation: await validateMapAsync(snapshot.index, signal === undefined ? {} : { signal }),
         };
     }
-    async plan(input) {
-        input.signal?.throwIfAborted();
-        const snapshot = await this.scan(input.workspaceId, input.principal, input.signal);
-        const plan = await planMapOperationsAsync(snapshot.index, input.operations, input.signal);
-        const baselineValidation = await validateMapAsync(snapshot.index, input.signal === undefined ? {} : { signal: input.signal });
+    async prepareOperations(workspaceId, operations, principal, signal) {
+        signal?.throwIfAborted();
+        const snapshot = await this.scan(workspaceId, principal, signal);
+        const plan = await planMapOperationsAsync(snapshot.index, operations, signal);
+        const baselineValidation = await validateMapAsync(snapshot.index, signal === undefined ? {} : { signal });
         const rawValidation = await validateMapAsync(plan.finalIndex, {
             baseline: snapshot.index,
-            ...(input.signal === undefined ? {} : { signal: input.signal }),
+            ...(signal === undefined ? {} : { signal }),
             ...(plan.expectedChangedBounds === undefined
                 ? {}
                 : { expectedChangedBounds: plan.expectedChangedBounds }),
@@ -411,7 +529,22 @@ export class AgentNudger {
                 baselineDiagnostics: baselineValidation.diagnostics,
             }),
         };
-        const validation = validationWithPlan(attributedValidation, plan);
+        return {
+            snapshot,
+            plan,
+            validation: validationWithPlan(attributedValidation, plan),
+        };
+    }
+    async plan(input) {
+        const prepared = await this.prepareOperations(input.workspaceId, input.operations, input.principal, input.signal);
+        return this.planPrepared(input, prepared);
+    }
+    async planPrepared(input, prepared) {
+        input.signal?.throwIfAborted();
+        const { snapshot, plan, validation } = prepared;
+        if (snapshot.workspaceId !== input.workspaceId) {
+            throw new ServiceError('MAP_PREPARED_WORKSPACE_MISMATCH', 'Prepared map operations belong to another workspace');
+        }
         const transaction = await this.transactions.plan({
             workspaceId: input.workspaceId,
             ...(input.principal === undefined ? {} : { principal: input.principal }),
@@ -424,15 +557,21 @@ export class AgentNudger {
             validate: (proposed, signal) => {
                 signal?.throwIfAborted();
                 const expected = new Map(plan.changes.map((change) => [change.relativePath, change.content]));
-                const exactProposedBytes = proposed.size === expected.size &&
-                    [...proposed].every(([relativePath, content]) => {
-                        const planned = expected.get(relativePath);
-                        if (planned === undefined)
+                const current = new Map(snapshot.files
+                    .filter(({ rootKind, shadowedBy }) => rootKind === 'mod' && shadowedBy === undefined)
+                    .map(({ relativePath, bytes }) => [relativePath, bytes]));
+                const exactProposedBytes = proposed.size <= expected.size &&
+                    [...expected].every(([relativePath, planned]) => {
+                        const content = proposed.has(relativePath)
+                            ? proposed.get(relativePath)
+                            : (current.get(relativePath) ?? null);
+                        if (content === undefined)
                             return false;
                         if (content === null || planned === null)
                             return content === planned;
                         return Buffer.from(content).equals(Buffer.from(planned));
-                    });
+                    }) &&
+                    [...proposed.keys()].every((relativePath) => expected.has(relativePath));
                 const diagnostics = exactProposedBytes
                     ? validation.diagnostics
                     : [
@@ -440,7 +579,7 @@ export class AgentNudger {
                         {
                             code: 'MAP_TRANSACTION_BYTES_MISMATCH',
                             severity: 'blocker',
-                            category: 'transaction',
+                            category: 'validation',
                             message: 'Transaction dry-run bytes differ from the validated map operation plan',
                         },
                     ];
@@ -515,26 +654,32 @@ export class AgentNudger {
         };
     }
     async renderDiffAndStore(workspaceId, operations, options = {}) {
-        const budget = new RenderBudget();
-        const snapshot = await this.scan(workspaceId, options.principal, options.signal);
-        const plan = await planMapOperationsAsync(snapshot.index, operations, options.signal);
-        const baselineValidation = await validateMapAsync(snapshot.index, options.signal === undefined ? {} : { signal: options.signal });
-        const rawValidation = await validateMapAsync(plan.finalIndex, {
-            baseline: snapshot.index,
-            ...(options.signal === undefined ? {} : { signal: options.signal }),
-            ...(plan.expectedChangedBounds === undefined
-                ? {}
-                : { expectedChangedBounds: plan.expectedChangedBounds }),
+        const prepared = await this.prepareOperations(workspaceId, operations, options.principal, options.signal);
+        return this.renderPreparedDiffAndStore(prepared, operations, options);
+    }
+    /**
+     * Build review evidence and a hash-bound transaction from one immutable scan and operation plan.
+     * Any source edit after this preparation is rejected by the transaction read-dependency checks.
+     */
+    async planRewriteWithDiff(input) {
+        const prepared = await this.prepareOperations(input.workspaceId, input.operations, input.principal, input.signal);
+        const diff = await this.renderPreparedDiffAndStore(prepared, input.operations, {
+            ...(input.diffScale === undefined ? {} : { scale: input.diffScale }),
+            ...(input.principal === undefined ? {} : { principal: input.principal }),
+            ...(input.signal === undefined ? {} : { signal: input.signal }),
         });
-        const validation = validationWithPlan({
-            ...rawValidation,
-            diagnostics: attributeMapValidationDiagnostics({
-                diagnostics: rawValidation.diagnostics,
-                operations: plan.operations,
-                changes: plan.changes,
-                baselineDiagnostics: baselineValidation.diagnostics,
-            }),
-        }, plan);
+        const planned = await this.planPrepared({
+            workspaceId: input.workspaceId,
+            operations: input.operations,
+            artifacts: diff.artifacts.map(publicArtifactLink),
+            ...(input.principal === undefined ? {} : { principal: input.principal }),
+            ...(input.signal === undefined ? {} : { signal: input.signal }),
+        }, prepared);
+        return { ...diff, ...planned };
+    }
+    async renderPreparedDiffAndStore(prepared, operations, options) {
+        const budget = new RenderBudget();
+        const { snapshot, plan, validation } = prepared;
         const review = {
             operationIds: plan.operations.map(({ id }) => id),
             affectedFiles: plan.changes.map(({ relativePath, operationIds, mediaType, content }) => ({
@@ -593,7 +738,7 @@ export class AgentNudger {
         const bundle = mapBundleWithSourceHashes(rawBundle, completeSourceHashes);
         const beforeBundle = mapBundleWithSourceHashes(rawBeforeBundle, completeSourceHashes);
         const proposedBundle = mapBundleWithSourceHashes(rawProposedBundle, completeSourceHashes);
-        const workspace = this.resolver.get(workspaceId, options.principal);
+        const workspace = this.resolver.get(snapshot.workspaceId, options.principal);
         const provenance = {
             kind: 'map-diff-render',
             toolVersion: PACKAGE_VERSION,
@@ -692,4 +837,3 @@ export class AgentNudger {
         };
     }
 }
-//# sourceMappingURL=service.js.map

package/dist/hoi4_agent_tools/map/validation.js

@@ -1174,4 +1174,3 @@ export function validateMap(index, options = {}) {
 export async function validateMapAsync(index, options = {}) {
     return completeCooperatively(validateMapSteps(index, options), options.signal);
 }
-//# sourceMappingURL=validation.js.map

package/dist/hoi4_agent_tools/mcp/resources/register.js

@@ -1,11 +1,30 @@
 import { ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { readFile } from 'node:fs/promises';
-import path from 'node:path';
 import { canonicalJson } from '../../core/canonical.js';
 import { ServiceError } from '../../core/result.js';
-import { compactWorkspaceStatus } from '../server/base-tools.js';
 const artifactResourceLimit = 1_048_576;
+const artifactChunkMetadataKey = 'io.github.klimpaskov/hoi4-agent-tools.artifact-byte-range';
 const fatalUtf8Decoder = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
+const artifactResourceMetadata = {
+    title: 'HOI4 review artifact',
+    description: 'Complete plans, diagnostics, layouts, previews, and diffs. Reads accept zero-based byte offset and positive byte length query selectors; each response reports its exact byte range and continuation URI in _meta.',
+    _meta: {
+        [artifactChunkMetadataKey]: {
+            version: 1,
+            unit: 'byte',
+            maxChunkSize: artifactResourceLimit,
+            selectors: {
+                offset: { type: 'integer', minimum: 0, default: 0 },
+                length: {
+                    type: 'integer',
+                    minimum: 1,
+                    maximum: artifactResourceLimit,
+                    default: artifactResourceLimit,
+                },
+                metadata: { type: 'string', enum: ['manifest'], optional: true },
+            },
+        },
+    },
+};
 function assertResourceSelectors(uri, allowed) {
     if (uri.hash !== '' || uri.username !== '' || uri.password !== '' || uri.port !== '') {
         throw new ServiceError('RESOURCE_URI_INVALID', 'Resource URI is not canonical');
@@ -28,31 +47,6 @@ function contentArtifactUri(uri) {
     contentUri.hash = '';
     return contentUri.href;
 }
-function transactionResourceIdentity(uri) {
-    let segments;
-    try {
-        segments = uri.pathname.split('/').filter(Boolean).map(decodeURIComponent);
-    }
-    catch {
-        throw new ServiceError('TRANSACTION_ID_INVALID', 'Invalid transaction resource URI');
-    }
-    if (uri.protocol !== 'hoi4-agent:' ||
-        uri.hostname !== 'workspace' ||
-        segments.length !== 3 ||
-        segments[1] !== 'transaction' ||
-        !/^[a-z][a-z0-9_-]{0,63}$/u.test(segments[0]) ||
-        !/^txn_[0-9a-f-]{36}$/u.test(segments[2])) {
-        throw new ServiceError('TRANSACTION_ID_INVALID', 'Invalid transaction resource URI');
-    }
-    const canonical = `hoi4-agent://workspace/${encodeURIComponent(segments[0])}/transaction/${encodeURIComponent(segments[2])}`;
-    const queryless = new URL(uri);
-    queryless.search = '';
-    queryless.hash = '';
-    if (queryless.href !== canonical) {
-        throw new ServiceError('TRANSACTION_ID_INVALID', 'Transaction resource URI is not canonical');
-    }
-    return { workspaceId: segments[0], transactionId: segments[2] };
-}
 function exactUtf8Text(bytes) {
     try {
         const text = fatalUtf8Decoder.decode(bytes);
@@ -62,7 +56,7 @@ function exactUtf8Text(bytes) {
         return undefined;
     }
 }
-function artifactRangeParameter(uri, name, fallback, minimum) {
+function artifactRangeParameter(uri, name, fallback, minimum, maximum = Number.MAX_SAFE_INTEGER) {
     const raw = uri.searchParams.get(name);
     if (raw === null)
         return fallback;
@@ -70,44 +64,40 @@ function artifactRangeParameter(uri, name, fallback, minimum) {
         throw new ServiceError('ARTIFACT_RANGE_INVALID', 'Artifact byte range is invalid');
     }
     const value = Number(raw);
-    if (!Number.isSafeInteger(value) || value < minimum) {
+    if (!Number.isSafeInteger(value) || value < minimum || value > maximum) {
         throw new ServiceError('ARTIFACT_RANGE_INVALID', 'Artifact byte range is invalid');
     }
     return value;
 }
+function artifactChunkMetadata(uri, metadata, totalSize, offset, returnedLength, requestedLength) {
+    const endExclusive = offset + returnedLength;
+    let continuationUri = null;
+    if (endExclusive < totalSize) {
+        const continuation = new URL(contentArtifactUri(uri));
+        continuation.searchParams.set('offset', String(endExclusive));
+        continuation.searchParams.set('length', String(requestedLength));
+        if (metadata !== null)
+            continuation.searchParams.set('metadata', metadata);
+        continuationUri = continuation.href;
+    }
+    return {
+        [artifactChunkMetadataKey]: {
+            version: 1,
+            unit: 'byte',
+            totalSize,
+            returnedRange: { offset, length: returnedLength, endExclusive },
+            complete: offset === 0 && returnedLength === totalSize,
+            continuationUri,
+        },
+    };
+}
 export function registerMcpResources(server, engine, context) {
-    server.registerResource('workspace-summary', new ResourceTemplate('hoi4-agent://workspace/{workspaceId}/summary', {
-        list: () => ({
-            resources: engine.list(context.principal).map((workspace) => ({
-                uri: `hoi4-agent://workspace/${workspace.id}/summary`,
-                name: `${workspace.name} summary`,
-                mimeType: 'application/json',
-            })),
-        }),
-    }), {
-        title: 'Workspace summary',
-        description: 'Registered workspace capabilities',
-        mimeType: 'application/json',
-    }, (uri, { workspaceId }) => {
-        assertResourceSelectors(uri, []);
-        return {
-            contents: [
-                {
-                    uri: uri.href,
-                    mimeType: 'application/json',
-                    text: `${canonicalJson(compactWorkspaceStatus(engine.status(String(workspaceId), context.principal)))}\n`,
-                },
-            ],
-        };
-    });
-    server.registerResource('artifact', new ResourceTemplate('hoi4-agent://workspace/{workspaceId}/artifact/{sha256}/{provenanceHash}/{name}', {
-        list: undefined,
-    }), { title: 'Generated artifact', description: 'Content-addressed workspace artifact' }, async (uri, { workspaceId }, extra) => {
+    server.registerResource('artifact', new ResourceTemplate('hoi4-agent://workspace/{workspaceId}/artifact/{sha256}/{provenanceHash}/{name}', { list: undefined }), artifactResourceMetadata, async (uri, { workspaceId }, extra) => {
         extra.signal.throwIfAborted();
         assertResourceSelectors(uri, ['offset', 'length', 'metadata']);
         const workspace = engine.resolver.get(String(workspaceId), context.principal);
         const offset = artifactRangeParameter(uri, 'offset', 0, 0);
-        const length = Math.min(artifactResourceLimit, artifactRangeParameter(uri, 'length', artifactResourceLimit, 1));
+        const length = artifactRangeParameter(uri, 'length', artifactResourceLimit, 1, artifactResourceLimit);
         const metadata = uri.searchParams.get('metadata');
         if (metadata !== null && metadata !== 'manifest') {
             throw new ServiceError('ARTIFACT_METADATA_INVALID', 'Artifact metadata selector is invalid');
@@ -119,161 +109,45 @@ export function registerMcpResources(server, engine, context) {
             const manifestBytes = Buffer.from(`${canonicalJson(publicManifest)}\n`, 'utf8');
             const start = Math.min(offset, manifestBytes.length);
             const selected = manifestBytes.subarray(start, Math.min(manifestBytes.length, start + length));
-            extra.signal.throwIfAborted();
             const complete = start === 0 && selected.length === manifestBytes.length;
+            const _meta = artifactChunkMetadata(uri, metadata, manifestBytes.length, start, selected.length, length);
             return {
                 contents: [
                     complete
-                        ? { uri: uri.href, mimeType: 'application/json', text: selected.toString('utf8') }
+                        ? {
+                            uri: uri.href,
+                            mimeType: 'application/json',
+                            text: selected.toString('utf8'),
+                            _meta,
+                        }
                         : {
                             uri: uri.href,
                             mimeType: 'application/json',
                             blob: selected.toString('base64'),
+                            _meta,
                         },
                 ],
             };
         }
         const artifact = await engine.artifacts.read(workspace, contentArtifactUri(uri), { offset, length }, extra.signal);
-        extra.signal.throwIfAborted();
         const textual = artifact.mimeType.startsWith('text/') ||
             artifact.mimeType === 'application/json' ||
             artifact.mimeType === 'image/svg+xml';
-        const complete = offset === 0 && artifact.bytes.length === artifact.totalSize;
+        const start = Math.min(offset, artifact.totalSize);
+        const complete = start === 0 && artifact.bytes.length === artifact.totalSize;
         const text = textual && complete ? exactUtf8Text(artifact.bytes) : undefined;
+        const _meta = artifactChunkMetadata(uri, metadata, artifact.totalSize, start, artifact.bytes.length, length);
         return {
             contents: [
                 text !== undefined
-                    ? { uri: uri.href, mimeType: artifact.mimeType, text }
+                    ? { uri: uri.href, mimeType: artifact.mimeType, text, _meta }
                     : {
                         uri: uri.href,
                         mimeType: artifact.mimeType,
                         blob: artifact.bytes.toString('base64'),
+                        _meta,
                     },
             ],
         };
     });
-    server.registerResource('transaction-manifest', new ResourceTemplate('hoi4-agent://workspace/{workspaceId}/transaction/{transactionId}', {
-        list: undefined,
-    }), {
-        title: 'Transaction manifest',
-        description: 'Declarative transaction and rollback status',
-        mimeType: 'application/json',
-    }, async (uri, { workspaceId }, extra) => {
-        extra.signal.throwIfAborted();
-        assertResourceSelectors(uri, ['offset', 'length']);
-        const identity = transactionResourceIdentity(uri);
-        if (identity.workspaceId !== String(workspaceId)) {
-            throw new ServiceError('TRANSACTION_WORKSPACE_MISMATCH', 'Transaction resource does not belong to this workspace');
-        }
-        const offset = artifactRangeParameter(uri, 'offset', 0, 0);
-        const length = Math.min(artifactResourceLimit, artifactRangeParameter(uri, 'length', artifactResourceLimit, 1));
-        const manifestRange = await engine.transactions.readManifestRange(identity.workspaceId, identity.transactionId, { offset, length }, context.principal, extra.signal);
-        extra.signal.throwIfAborted();
-        const complete = offset === 0 && manifestRange.bytes.length === manifestRange.totalSize;
-        return {
-            contents: [
-                complete
-                    ? {
-                        uri: uri.href,
-                        mimeType: 'application/json',
-                        text: manifestRange.bytes.toString('utf8'),
-                    }
-                    : {
-                        uri: uri.href,
-                        mimeType: 'application/json',
-                        blob: manifestRange.bytes.toString('base64'),
-                    },
-            ],
-        };
-    });
-    const packageRoot = path.resolve(import.meta.dirname, '../../../..');
-    const documentation = new Map([
-        ['agent-integration', 'docs/agent-integration.md'],
-        ['architecture', 'docs/architecture.md'],
-        ['artifacts', 'docs/artifacts.md'],
-        ['compatibility', 'docs/compatibility.md'],
-        ['configuration', 'docs/configuration.md'],
-        ['focus-workflow', 'docs/focus-workflow.md'],
-        ['gui-workflow', 'docs/gui-workflow.md'],
-        ['limitations', 'docs/limitations.md'],
-        ['map-workflow', 'docs/map-workflow.md'],
-        ['security', 'docs/security.md'],
-        ['self-hosting', 'docs/self-hosting.md'],
-        ['testing', 'docs/testing.md'],
-        ['transactions', 'docs/transactions.md'],
-        ['troubleshooting', 'docs/troubleshooting.md'],
-    ]);
-    server.registerResource('documentation', new ResourceTemplate('hoi4-agent://docs/{name}', {
-        list: () => ({
-            resources: [...documentation.keys()].map((name) => ({
-                uri: `hoi4-agent://docs/${name}`,
-                name: `${name} documentation`,
-                mimeType: 'text/markdown',
-            })),
-        }),
-    }), {
-        title: 'HOI4 Agent Tools documentation',
-        description: 'Versioned package documentation for coding agents',
-        mimeType: 'text/markdown',
-    }, async (uri, { name }, extra) => {
-        extra.signal.throwIfAborted();
-        assertResourceSelectors(uri, []);
-        const relative = documentation.get(String(name));
-        if (relative === undefined)
-            throw new ServiceError('RESOURCE_NOT_FOUND', 'Unknown document');
-        const contents = await readFile(path.join(packageRoot, relative), 'utf8');
-        extra.signal.throwIfAborted();
-        return {
-            contents: [
-                {
-                    uri: uri.href,
-                    mimeType: 'text/markdown',
-                    text: contents,
-                },
-            ],
-        };
-    });
-    const schemas = new Map([
-        ['configuration', 'schemas/configuration.schema.json'],
-        ['continuous-focus-palette', 'schemas/continuous-focus-palette.schema.json'],
-        ['focus-plan', 'schemas/focus-plan.schema.json'],
-        ['focus-planning-sidecar', 'schemas/focus-planning-sidecar.schema.json'],
-        ['gui-animation-source', 'schemas/gui-animation-source.schema.json'],
-        ['gui-helper', 'schemas/gui-helper.schema.json'],
-        ['gui-scenario', 'schemas/gui-scenario.schema.json'],
-        ['map-operation', 'schemas/map-operation.schema.json'],
-        ['operation-result', 'schemas/operation-result.schema.json'],
-        ['transaction-manifest', 'schemas/transaction-manifest.schema.json'],
-    ]);
-    server.registerResource('schema', new ResourceTemplate('hoi4-agent://schema/{name}', {
-        list: () => ({
-            resources: [...schemas.keys()].map((name) => ({
-                uri: `hoi4-agent://schema/${name}`,
-                name: `${name} JSON Schema`,
-                mimeType: 'application/schema+json',
-            })),
-        }),
-    }), {
-        title: 'Public JSON Schema',
-        description: 'Versioned strict schemas shipped with the package',
-        mimeType: 'application/schema+json',
-    }, async (uri, { name }, extra) => {
-        extra.signal.throwIfAborted();
-        assertResourceSelectors(uri, []);
-        const relative = schemas.get(String(name));
-        if (relative === undefined)
-            throw new ServiceError('RESOURCE_NOT_FOUND', 'Unknown schema');
-        const contents = await readFile(path.join(packageRoot, relative), 'utf8');
-        extra.signal.throwIfAborted();
-        return {
-            contents: [
-                {
-                    uri: uri.href,
-                    mimeType: 'application/schema+json',
-                    text: contents,
-                },
-            ],
-        };
-    });
 }
-//# sourceMappingURL=register.js.map

package/dist/hoi4_agent_tools/mcp/security/auth.js

@@ -136,10 +136,7 @@ export async function authenticate(authorization, configuration, requiredScopes
                 principal: configured.principal,
                 clientId: configured.principal,
                 credentialId: presentedCredentialId,
-                scopes: [
-                    'hoi4:read',
-                    ...(configuration.writePolicy === 'transactions' ? ['hoi4:write'] : []),
-                ],
+                scopes: ['hoi4:read', 'hoi4:write'],
             };
             requireScopes(principal.scopes, normalizedRequiredScopes);
             return principal;
@@ -231,4 +228,3 @@ export function protectedResourceMetadata(configuration) {
         resource_name: 'HOI4 Agent Tools',
     };
 }
-//# sourceMappingURL=auth.js.map