@deksden-com/dd-flow-cli 0.9.0-beta.137 → 0.9.0-beta.138

package/dist/services/installed-flow-source.js

@@ -0,0 +1,183 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { AppError } from "../shared/errors.js";
+import { readSetupStatus } from "./setup.js";
+import { readBoundedReleaseFile } from "./release-source.js";
+import { hybridDigest, validateHybridShape } from "./hybrid-contracts.js";
+import { admitBundledFlow } from "./stage-handlers.js";
+const limit = 1024 * 1024;
+const hash = (bytes) => createHash("sha256").update(bytes).digest("hex");
+function refuse(reason) {
+    throw new AppError("installed_flow_source_invalid", "Installed flow source is not the selected verified canon", 1, { reason, phase: "prepare", effect: "no_effect" });
+}
+function directory(target) {
+    if (!fs.lstatSync(target).isDirectory())
+        refuse("unsafe_source_directory");
+}
+function containedFile(root, logical) {
+    if (!/^[A-Za-z0-9_-][A-Za-z0-9_.-]*(\/[A-Za-z0-9_-][A-Za-z0-9_.-]*)*$/.test(logical)
+        || logical.split("/").some(part => part === "." || part === ".."))
+        refuse("unsafe_source_path");
+    let current = root;
+    for (const part of logical.split("/").slice(0, -1)) {
+        current = path.join(current, part);
+        directory(current);
+    }
+    return path.join(root, logical);
+}
+/** Initial RUN materialization input, not handler/engine/storage admission.
+ * Built-in memory flows live in the global canon, not the curated project pack.
+ * Existing RUNs must restore their retained bundle rather than call this reader.
+ */
+export class PreparedInstalledFlowSource {
+    sha256;
+    #home;
+    #installationSha256;
+    #flowId;
+    #descriptor;
+    #canon;
+    #blobs;
+    constructor(home, installationSha256, flowId, descriptor, canon, blobs) {
+        this.#home = home;
+        this.#installationSha256 = installationSha256;
+        this.#flowId = flowId;
+        this.#descriptor = descriptor;
+        this.#canon = canon;
+        this.#blobs = blobs;
+        this.sha256 = hybridDigest({ installation_sha256: installationSha256, canon, inventory: this.inventory() });
+        Object.freeze(this);
+    }
+    static fromInstalledRelease(home, expectedInstallationSha256, flowId) {
+        try {
+            if (!path.isAbsolute(home) || !/^[a-f0-9]{64}$/.test(expectedInstallationSha256) || flowId !== "mb-init")
+                refuse("invalid_selection");
+            const selected = readSetupStatus(home);
+            if (!selected.installation || selected.installation_readiness !== "installed")
+                refuse("installed_release_unavailable");
+            const installation = selected.installation;
+            if (installation.manifest_sha256 !== expectedInstallationSha256)
+                refuse("installation_selection_changed");
+            directory(installation.canon_root);
+            const roots = fs.readdirSync(installation.canon_root);
+            if (roots.length !== 1)
+                refuse("ambiguous_archive_root");
+            const canonRoot = path.join(installation.canon_root, roots[0]);
+            directory(canonRoot);
+            const dotRoot = path.join(canonRoot, ".memory-bank"), memoryRoot = fs.existsSync(dotRoot) ? dotRoot : canonRoot;
+            directory(memoryRoot);
+            const flowRoot = path.join(memoryRoot, "dd-flow");
+            directory(flowRoot);
+            const descriptorPath = `${flowId}/flow-descriptor.json`;
+            const bytes = readBoundedReleaseFile(containedFile(flowRoot, descriptorPath), limit);
+            const value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+            if (validateHybridShape("flow-descriptor", value).length || value.id !== flowId || value.origin !== "canon"
+                || value.stages.length > 64)
+                refuse("invalid_descriptor");
+            const blobs = new Map([[descriptorPath, Buffer.from(bytes)]]), folded = new Map([[descriptorPath.toLowerCase(), descriptorPath]]);
+            let total = bytes.length;
+            for (const stage of value.stages)
+                for (const kind of ["instruction", "result_schema"]) {
+                    const reference = stage[kind], existing = blobs.get(reference.path);
+                    if (existing) {
+                        if (hash(existing) !== reference.sha256)
+                            refuse("conflicting_source_reference");
+                        continue;
+                    }
+                    if (folded.has(reference.path.toLowerCase()))
+                        refuse("conflicting_source_path");
+                    const content = readBoundedReleaseFile(containedFile(flowRoot, reference.path), limit);
+                    if (!content.length || (total += content.length) > 32 * limit || hash(content) !== reference.sha256)
+                        refuse("source_bytes_changed");
+                    new TextDecoder("utf-8", { fatal: true }).decode(content);
+                    if (kind === "result_schema")
+                        JSON.parse(content.toString("utf8"));
+                    folded.set(reference.path.toLowerCase(), reference.path);
+                    blobs.set(reference.path, Buffer.from(content));
+                }
+            // Verify compressed/expanded archive identity again after collecting bytes.
+            // A coherent descriptor+prompt edit cannot become a new trusted selection.
+            const final = readSetupStatus(home);
+            if (final.installation_readiness !== "installed" || hybridDigest(final.installation) !== hybridDigest(installation))
+                refuse("source_changed_during_preparation");
+            return new PreparedInstalledFlowSource(home, expectedInstallationSha256, flowId, { path: descriptorPath, sha256: hash(bytes) }, { version: installation.manifest.canon.version, commit: installation.manifest.canon.commit, archive_sha256: installation.manifest.canon.archive.sha256 }, blobs);
+        }
+        catch (error) {
+            if (error instanceof AppError && error.code === "installed_flow_source_invalid")
+                throw error;
+            return refuse("source_unavailable_or_changed");
+        }
+    }
+    descriptorReference() { return { ...this.#descriptor }; }
+    installationSha256() { return this.#installationSha256; }
+    snapshot() {
+        return { schema_id: "dd-flow/installed-flow-source@1", installation_sha256: this.#installationSha256,
+            descriptor: this.descriptorReference(), canon: this.canonProvenance(),
+            blobs: [...this.#blobs].map(([logical, bytes]) => ({ path: logical, base64: bytes.toString("base64") })) };
+    }
+    /** Copied source restoration only. expectedSha256 must come from independent
+     * request custody, not from the same input. This does not verify a new release
+     * or admit its engine/storage; those remain the bootstrap owner's duties.
+     */
+    static restoreRetained(input, expectedSha256) {
+        try {
+            if (!input || typeof input !== "object" || Array.isArray(input) || typeof expectedSha256 !== "string"
+                || !/^[a-f0-9]{64}$/.test(expectedSha256))
+                refuse("invalid_retained_source");
+            const value = input;
+            if (Object.keys(value).sort().join() !== "blobs,canon,descriptor,installation_sha256,schema_id"
+                || value.schema_id !== "dd-flow/installed-flow-source@1" || typeof value.installation_sha256 !== "string" || !/^[a-f0-9]{64}$/.test(value.installation_sha256)
+                || !value.canon || Object.keys(value.canon).sort().join() !== "archive_sha256,commit,version"
+                || typeof value.canon.commit !== "string" || !/^[a-f0-9]{40}$/.test(value.canon.commit)
+                || typeof value.canon.archive_sha256 !== "string" || !/^[a-f0-9]{64}$/.test(value.canon.archive_sha256)
+                || typeof value.canon.version !== "string" || !/^\d+\.\d+\.\d+(?:-[A-Za-z0-9.-]+)?$/.test(value.canon.version)
+                || !value.descriptor || Object.keys(value.descriptor).sort().join() !== "path,sha256"
+                || value.descriptor.path !== "mb-init/flow-descriptor.json" || typeof value.descriptor.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(value.descriptor.sha256)
+                || !Array.isArray(value.blobs) || value.blobs.length < 1 || value.blobs.length > 129)
+                refuse("invalid_retained_source");
+            const blobs = new Map(), folded = new Set();
+            let total = 0;
+            for (const entry of value.blobs) {
+                if (!entry || Object.keys(entry).sort().join() !== "base64,path" || typeof entry.path !== "string"
+                    || !/^[A-Za-z0-9_-][A-Za-z0-9_.-]*(\/[A-Za-z0-9_-][A-Za-z0-9_.-]*)*$/.test(entry.path)
+                    || entry.path.split("/").some(part => part === "." || part === "..")
+                    || folded.has(entry.path.toLowerCase()) || typeof entry.base64 !== "string" || entry.base64.length > 2 * limit)
+                    refuse("invalid_retained_source");
+                const content = Buffer.from(entry.base64, "base64");
+                if (!content.length || content.length > limit || content.toString("base64") !== entry.base64
+                    || (total += content.length) > 32 * limit)
+                    refuse("invalid_retained_source");
+                new TextDecoder("utf-8", { fatal: true }).decode(content);
+                folded.add(entry.path.toLowerCase());
+                blobs.set(entry.path, content);
+            }
+            const descriptor = blobs.get(value.descriptor.path);
+            if (!descriptor || hash(descriptor) !== value.descriptor.sha256)
+                refuse("retained_source_changed");
+            const result = new PreparedInstalledFlowSource(null, value.installation_sha256, "mb-init", { ...value.descriptor }, { ...value.canon }, blobs);
+            if (result.sha256 !== expectedSha256)
+                refuse("retained_source_changed");
+            result.resolveRegisteredFlow();
+            return result;
+        }
+        catch (error) {
+            if (error instanceof AppError && error.code === "installed_flow_source_invalid")
+                throw error;
+            return refuse("invalid_retained_source");
+        }
+    }
+    canonProvenance() { return { ...this.#canon }; }
+    blobs() { return new Map([...this.#blobs].map(([logical, bytes]) => [logical, Buffer.from(bytes)])); }
+    inventory() { return [...this.#blobs].map(([logical, bytes]) => ({ path: logical, sha256: hash(bytes) })).sort((a, b) => a.path.localeCompare(b.path, "en")); }
+    /** Production handler registry only: source declarations cannot register code. */
+    resolveRegisteredFlow() { return admitBundledFlow(this.#blobs.get(this.#descriptor.path), this.#descriptor.sha256, this.#blobs); }
+    /** Initial materialization only, outside SQL writers. */
+    revalidate() {
+        if (this.#home === null) {
+            PreparedInstalledFlowSource.restoreRetained(this.snapshot(), this.sha256);
+            return;
+        }
+        if (PreparedInstalledFlowSource.fromInstalledRelease(this.#home, this.#installationSha256, this.#flowId).sha256 !== this.sha256)
+            refuse("source_changed_after_preparation");
+    }
+}