mdkg 0.5.0 → 0.5.2

package/dist/commands/archive.js

@@ -83,6 +83,22 @@ function normalizeArchiveId(raw) {
     }
     return normalized;
 }
+function archiveTargetFromInput(value, ws) {
+    const uriId = (0, refs_1.archiveIdFromUri)(value);
+    if (uriId) {
+        return { id: normalizeArchiveId(uriId), workspace: normalizeWorkspace(ws) };
+    }
+    const separator = value.indexOf(":");
+    if (separator > 0) {
+        const workspace = normalizeWorkspace(value.slice(0, separator));
+        const id = normalizeArchiveId(value.slice(separator + 1));
+        if (ws && normalizeWorkspace(ws) !== workspace) {
+            throw new errors_1.UsageError(`archive qid ${value} conflicts with --ws ${normalizeWorkspace(ws)}`);
+        }
+        return { id, workspace };
+    }
+    return { id: normalizeArchiveId(value), workspace: normalizeWorkspace(ws) };
+}
 function archiveIdFromInput(value) {
     return normalizeArchiveId((0, refs_1.archiveIdFromUri)(value) ?? value);
 }
@@ -133,9 +149,8 @@ function maybeReindex(root) {
 function resolveArchiveNode(root, id, ws) {
     const config = (0, config_1.loadConfig)(root);
     const { index } = (0, index_cache_1.loadIndex)({ root, config });
-    const archiveId = archiveIdFromInput(id);
-    const wsHint = normalizeWorkspace(ws);
-    const qid = archiveId.includes(":") ? archiveId : `${wsHint}:${archiveId}`;
+    const target = archiveTargetFromInput(id, ws);
+    const qid = `${target.workspace}:${target.id}`;
     const node = index.nodes[qid];
     if (!node || node.type !== "archive") {
         throw new errors_1.NotFoundError(`archive not found: ${id}`);
@@ -143,6 +158,9 @@ function resolveArchiveNode(root, id, ws) {
     return node;
 }
 function archiveNodePaths(root, node) {
+    if (node.source?.imported || node.source?.read_only || node.path.includes("#")) {
+        throw new errors_1.ValidationError(`refusing to derive filesystem paths for read-only archive projection ${node.qid}`);
+    }
     const sidecarPath = path_1.default.resolve(root, node.path);
     const sidecarDir = path_1.default.dirname(sidecarPath);
     return {
@@ -175,9 +193,12 @@ function stringAttribute(value) {
     return typeof value === "string" && value.trim().length > 0 ? value : undefined;
 }
 function writeArchiveSidecar(root, sidecarPath, frontmatter, body) {
+    (0, filesystem_authority_1.atomicReplaceContainedFile)({ root, relativePath: toPosixPath(path_1.default.relative(root, sidecarPath)) }, formatArchiveSidecar(frontmatter, body));
+}
+function formatArchiveSidecar(frontmatter, body) {
     const lines = (0, frontmatter_1.formatFrontmatter)(frontmatter);
     const content = ["---", ...lines, "---", body.trimStart()].join("\n");
-    (0, filesystem_authority_1.atomicReplaceContainedFile)({ root, relativePath: toPosixPath(path_1.default.relative(root, sidecarPath)) }, content.endsWith("\n") ? content : `${content}\n`);
+    return content.endsWith("\n") ? content : `${content}\n`;
 }
 function verifyArchiveSidecar(root, ws, sidecarPath) {
     const relativePath = toPosixPath(path_1.default.relative(root, sidecarPath));
@@ -436,42 +457,137 @@ function runArchiveVerifyCommand(options) {
         throw new errors_1.ValidationError("archive verification failed");
     }
 }
-function runArchiveCompressCommandLocked(options) {
-    if (!options.all && !options.id) {
-        throw new errors_1.UsageError("archive compress requires <id-or-archive-uri> or --all");
+function isReadOnlyArchiveProjection(config, node) {
+    return Boolean(node.source?.imported ||
+        node.source?.read_only ||
+        config.subgraphs[node.source?.subgraph_alias ?? node.ws]);
+}
+function readOnlyArchiveError(node) {
+    const alias = node.source?.subgraph_alias ?? node.ws;
+    return new errors_1.ValidationError(`cannot compress read-only archive ${node.qid} from imported workspace ${alias}; ` +
+        "run compression in the source workspace and refresh the subgraph bundle");
+}
+function readOnlyWorkspaceError(alias) {
+    return new errors_1.ValidationError(`cannot compress archives in read-only imported workspace ${alias}; ` +
+        "run compression in the source workspace and refresh the subgraph bundle");
+}
+function assertWritableArchiveOwner(config, node) {
+    if (isReadOnlyArchiveProjection(config, node)) {
+        throw readOnlyArchiveError(node);
     }
-    const config = (0, config_1.loadConfig)(options.root);
-    const { index } = (0, index_cache_1.loadIndex)({ root: options.root, config });
-    const nodes = options.all
-        ? Object.values(index.nodes).filter((node) => node.type === "archive")
-        : [resolveArchiveNode(options.root, String(options.id), options.ws)];
-    const updated = [];
-    const today = (0, date_1.formatDate)(options.now ?? new Date());
-    for (const node of nodes) {
-        const { sidecarPath, rawPath, zipPath } = archiveNodePaths(options.root, node);
-        const rawRelativePath = toPosixPath(path_1.default.relative(options.root, rawPath));
-        const zipRelativePath = toPosixPath(path_1.default.relative(options.root, zipPath));
-        const sidecarRelativePath = toPosixPath(path_1.default.relative(options.root, sidecarPath));
-        for (const relativePath of [rawRelativePath, zipRelativePath, sidecarRelativePath]) {
-            (0, filesystem_authority_1.withContainedPathSink)({ root: options.root, relativePath, operation: relativePath === rawRelativePath ? "read" : "replace" }, () => undefined);
+    const workspace = config.workspaces[node.ws];
+    if (!workspace) {
+        throw new errors_1.ValidationError(`archive ${node.qid} has no configured local workspace owner`);
+    }
+    if (!workspace.enabled) {
+        throw new errors_1.ValidationError(`archive workspace ${node.ws} is disabled and not writable`);
+    }
+    const archiveRoot = (0, workspace_path_1.workspaceDocumentRelativePath)(workspace.path, workspace.mdkg_dir, "archive");
+    const nodePath = toPosixPath(node.path);
+    if (!nodePath.startsWith(`${archiveRoot}/`)) {
+        throw new errors_1.ValidationError(`archive ${node.qid} path is outside its configured local archive root: ${archiveRoot}`);
+    }
+}
+function resolveArchiveNodeFromIndex(index, id, ws) {
+    const target = archiveTargetFromInput(id, ws);
+    const qid = `${target.workspace}:${target.id}`;
+    const node = index.nodes[qid];
+    if (!node || node.type !== "archive") {
+        throw new errors_1.NotFoundError(`archive not found: ${id}`);
+    }
+    return node;
+}
+function selectArchiveCompressionNodes(options, config, index) {
+    if (options.all && options.id) {
+        throw new errors_1.UsageError("archive compress accepts either <id-or-archive-uri-or-qid> or --all, not both");
+    }
+    const requestedWorkspace = options.ws ? normalizeWorkspace(options.ws) : null;
+    const excluded = [];
+    let nodes;
+    if (options.all) {
+        if (requestedWorkspace && config.subgraphs[requestedWorkspace]) {
+            throw readOnlyWorkspaceError(requestedWorkspace);
         }
-        if (!(0, filesystem_authority_1.containedPathExists)({ root: options.root, relativePath: rawRelativePath })) {
-            throw new errors_1.NotFoundError(`raw archive file missing for ${node.qid}: ${path_1.default.relative(options.root, rawPath)}`);
+        if (requestedWorkspace) {
+            const workspace = config.workspaces[requestedWorkspace];
+            if (!workspace) {
+                throw new errors_1.NotFoundError(`workspace not found: ${requestedWorkspace}`);
+            }
+            if (!workspace.enabled) {
+                throw new errors_1.ValidationError(`archive workspace ${requestedWorkspace} is disabled and not writable`);
+            }
         }
-        const rawData = (0, filesystem_authority_1.readContainedFile)({ root: options.root, relativePath: rawRelativePath }, null);
-        const zipData = (0, zip_1.createDeterministicZip)(path_1.default.basename(rawPath), rawData);
-        (0, filesystem_authority_1.atomicReplaceContainedFile)({ root: options.root, relativePath: zipRelativePath }, zipData);
-        const parsed = (0, frontmatter_1.parseFrontmatter)((0, filesystem_authority_1.readContainedFile)({ root: options.root, relativePath: sidecarRelativePath }), sidecarPath);
-        const nextFrontmatter = {
-            ...parsed.frontmatter,
-            byte_size: String(rawData.length),
-            sha256: (0, archive_integrity_1.hashArchiveBuffer)(rawData),
-            compressed_sha256: (0, archive_integrity_1.hashArchiveBuffer)(zipData),
-            ingest_status: "compressed",
-            updated: today,
-        };
-        writeArchiveSidecar(options.root, sidecarPath, nextFrontmatter, parsed.body);
-        updated.push({
+        nodes = Object.values(index.nodes)
+            .filter((node) => node.type === "archive")
+            .sort((a, b) => a.qid.localeCompare(b.qid))
+            .filter((node) => {
+            if (requestedWorkspace && node.ws !== requestedWorkspace) {
+                return false;
+            }
+            if (isReadOnlyArchiveProjection(config, node)) {
+                if (!requestedWorkspace) {
+                    excluded.push({
+                        workspace: node.ws,
+                        qid: node.qid,
+                        reason: "read_only_imported_subgraph",
+                    });
+                }
+                return false;
+            }
+            assertWritableArchiveOwner(config, node);
+            return true;
+        });
+    }
+    else {
+        const node = resolveArchiveNodeFromIndex(index, String(options.id), options.ws);
+        assertWritableArchiveOwner(config, node);
+        nodes = [node];
+    }
+    return {
+        nodes,
+        selection: {
+            requested_workspace: requestedWorkspace,
+            selected_workspaces: Array.from(new Set(nodes.map((node) => node.ws))).sort(),
+            excluded_read_only: excluded.sort((a, b) => a.qid.localeCompare(b.qid)),
+        },
+    };
+}
+function preflightArchiveCompression(root, node, today) {
+    for (const attribute of ["stored_path", "compressed_path"]) {
+        if (typeof node.attributes[attribute] !== "string" || !String(node.attributes[attribute]).trim()) {
+            throw new errors_1.ValidationError(`${node.qid}: ${attribute} is required before archive compression`);
+        }
+    }
+    const { sidecarPath, rawPath, zipPath } = archiveNodePaths(root, node);
+    const rawRelativePath = toPosixPath(path_1.default.relative(root, rawPath));
+    const zipRelativePath = toPosixPath(path_1.default.relative(root, zipPath));
+    const sidecarRelativePath = toPosixPath(path_1.default.relative(root, sidecarPath));
+    for (const relativePath of [rawRelativePath, zipRelativePath, sidecarRelativePath]) {
+        (0, filesystem_authority_1.withContainedPathSink)({ root, relativePath, operation: relativePath === rawRelativePath ? "read" : "replace" }, () => undefined);
+    }
+    if (!(0, filesystem_authority_1.containedPathExists)({ root, relativePath: rawRelativePath })) {
+        throw new errors_1.NotFoundError(`raw archive file missing for ${node.qid}: ${path_1.default.relative(root, rawPath)}`);
+    }
+    const rawData = (0, filesystem_authority_1.readContainedFile)({ root, relativePath: rawRelativePath }, null);
+    const parsed = (0, frontmatter_1.parseFrontmatter)((0, filesystem_authority_1.readContainedFile)({ root, relativePath: sidecarRelativePath }), sidecarPath);
+    if (parsed.frontmatter.type !== "archive" || parsed.frontmatter.id !== node.id) {
+        throw new errors_1.ValidationError(`${node.qid}: archive sidecar identity changed before compression`);
+    }
+    const zipData = (0, zip_1.createDeterministicZip)(path_1.default.basename(rawPath), rawData);
+    const nextFrontmatter = {
+        ...parsed.frontmatter,
+        byte_size: String(rawData.length),
+        sha256: (0, archive_integrity_1.hashArchiveBuffer)(rawData),
+        compressed_sha256: (0, archive_integrity_1.hashArchiveBuffer)(zipData),
+        ingest_status: "compressed",
+        updated: today,
+    };
+    return {
+        zipRelativePath,
+        sidecarRelativePath,
+        zipData,
+        sidecarContent: formatArchiveSidecar(nextFrontmatter, parsed.body),
+        receipt: {
             workspace: node.ws,
             id: node.id,
             qid: node.qid,
@@ -482,14 +598,35 @@ function runArchiveCompressCommandLocked(options) {
             sha256: String(nextFrontmatter.sha256),
             compressed_sha256: String(nextFrontmatter.compressed_sha256),
             visibility: (0, visibility_1.normalizeVisibility)(typeof nextFrontmatter.visibility === "string" ? nextFrontmatter.visibility : undefined, "archive visibility"),
-        });
+        },
+    };
+}
+function runArchiveCompressCommandLocked(options) {
+    if (!options.all && !options.id) {
+        throw new errors_1.UsageError("archive compress requires <id-or-archive-uri-or-qid> or --all");
+    }
+    const config = (0, config_1.loadConfig)(options.root);
+    const { index } = (0, index_cache_1.loadIndex)({ root: options.root, config });
+    const { nodes, selection } = selectArchiveCompressionNodes(options, config, index);
+    const today = (0, date_1.formatDate)(options.now ?? new Date());
+    const plans = nodes.map((node) => preflightArchiveCompression(options.root, node, today));
+    const updated = [];
+    for (const plan of plans) {
+        (0, filesystem_authority_1.atomicReplaceContainedFile)({ root: options.root, relativePath: plan.zipRelativePath }, plan.zipData);
+        (0, filesystem_authority_1.atomicReplaceContainedFile)({ root: options.root, relativePath: plan.sidecarRelativePath }, plan.sidecarContent);
+        updated.push(plan.receipt);
     }
     maybeReindex(options.root);
     if (options.json) {
-        console.log(JSON.stringify({ action: "compressed", count: updated.length, archives: updated }, null, 2));
+        console.log(JSON.stringify({ action: "compressed", count: updated.length, archives: updated, selection }, null, 2));
         return;
     }
     console.log(`archive compressed: ${updated.length}`);
+    console.log(`selected workspaces: ${selection.selected_workspaces.join(", ") || "none"}`);
+    console.log(`excluded read-only projections: ${selection.excluded_read_only.length}`);
+    for (const excluded of selection.excluded_read_only) {
+        console.log(`  - ${excluded.qid} (${excluded.reason})`);
+    }
 }
 function withArchiveLock(root, fn) {
     const config = (0, config_1.loadConfig)(root);