@nowcrew/daemon 0.6.15 → 0.6.17

package/dist/project-skills/projection-state-domain.js

@@ -0,0 +1,153 @@
+import { createHash } from "node:crypto";
+import { posix, win32 } from "node:path";
+import { z } from "zod";
+import { compareProjectSkillRefs, isProjectId, isProjectSkillName, MAX_AGENT_PROJECT_SKILL_BINDINGS, MAX_PROJECT_ID_LENGTH, MAX_PROJECT_SKILL_NAME_LENGTH, } from "./types.js";
+const MANAGED_BY = "nowcrew-project-skills-v2";
+const MAX_SOURCE_PATH_BYTES = 16 * 1024;
+const MAX_GENERATION = 2_147_483_647;
+const DIGEST = /^sha256:[a-f0-9]{64}$/u;
+export class ProjectSkillProjectionStateError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+        this.name = "ProjectSkillProjectionStateError";
+    }
+}
+const corrupt = () => {
+    throw new ProjectSkillProjectionStateError("skill_projection_state_corrupt");
+};
+const unmanaged = () => {
+    throw new ProjectSkillProjectionStateError("skill_projection_state_unmanaged");
+};
+const immutableBinding = (binding) => Object.freeze({
+    projectId: binding.projectId,
+    skillName: binding.skillName,
+});
+const canonicalBindings = (bindings) => {
+    if (bindings.length > MAX_AGENT_PROJECT_SKILL_BINDINGS)
+        return corrupt();
+    const seen = new Set();
+    const canonical = bindings.map((binding) => {
+        if (!isProjectId(binding.projectId) || !isProjectSkillName(binding.skillName))
+            return corrupt();
+        const key = `${binding.projectId}\0${binding.skillName}`;
+        if (seen.has(key))
+            return corrupt();
+        seen.add(key);
+        return immutableBinding(binding);
+    }).sort(compareProjectSkillRefs);
+    return Object.freeze(canonical);
+};
+const digest = (value) => `sha256:${createHash("sha256").update(JSON.stringify(value), "utf8").digest("hex")}`;
+export function computeProjectSkillBindingDigest(bindings) {
+    return digest(canonicalBindings(bindings));
+}
+const normalizeWindowsPath = (sourcePath) => {
+    let value = sourcePath.replaceAll("/", "\\");
+    if (/^\\\\\?\\UNC\\/iu.test(value))
+        value = `\\\\${value.slice(8)}`;
+    else if (/^\\\\\?\\[A-Za-z]:\\/u.test(value))
+        value = value.slice(4);
+    if (!win32.isAbsolute(value))
+        return corrupt();
+    return win32.normalize(value).toLowerCase();
+};
+const normalizeSourcePath = (sourcePath, platform) => {
+    if (sourcePath.includes("\0") || Buffer.byteLength(sourcePath, "utf8") > MAX_SOURCE_PATH_BYTES) {
+        return corrupt();
+    }
+    if (platform === "win32")
+        return normalizeWindowsPath(sourcePath);
+    if (!posix.isAbsolute(sourcePath))
+        return corrupt();
+    return posix.normalize(sourcePath);
+};
+export function normalizeProjectSkillResolutionRecords(records, platform = process.platform) {
+    if (records.length > MAX_AGENT_PROJECT_SKILL_BINDINGS)
+        return corrupt();
+    const seen = new Set();
+    const normalized = records.map((record) => {
+        if (!isProjectId(record.projectId) || !isProjectSkillName(record.skillName))
+            return corrupt();
+        const key = `${record.projectId}\0${record.skillName}`;
+        if (seen.has(key))
+            return corrupt();
+        seen.add(key);
+        if (record.mode === "missing") {
+            if (record.sourcePath !== null)
+                return corrupt();
+            return Object.freeze({
+                projectId: record.projectId,
+                skillName: record.skillName,
+                sourcePath: null,
+                mode: "missing",
+            });
+        }
+        if (record.mode !== "resolved" || record.sourcePath === null)
+            return corrupt();
+        return Object.freeze({
+            projectId: record.projectId,
+            skillName: record.skillName,
+            sourcePath: normalizeSourcePath(record.sourcePath, platform),
+            mode: "resolved",
+        });
+    }).sort(compareProjectSkillRefs);
+    return Object.freeze(normalized);
+}
+export function computeProjectSkillResolutionDigest(records, platform = process.platform) {
+    return digest(normalizeProjectSkillResolutionRecords(records, platform));
+}
+const sameBinding = (left, right) => left.projectId === right.projectId && left.skillName === right.skillName;
+export function createAppliedProjectSkillManifest(input) {
+    if (!Number.isInteger(input.generation) || input.generation < 0 || input.generation > MAX_GENERATION) {
+        return corrupt();
+    }
+    const bindings = canonicalBindings(input.bindings);
+    const resolutions = normalizeProjectSkillResolutionRecords(input.resolutions, input.platform);
+    if (bindings.length !== resolutions.length
+        || bindings.some((binding, index) => !sameBinding(binding, resolutions[index]))) {
+        return corrupt();
+    }
+    return Object.freeze({
+        managedBy: MANAGED_BY,
+        generation: input.generation,
+        bindings,
+        bindingDigest: digest(bindings),
+        resolutionDigest: digest(resolutions),
+    });
+}
+const ProjectSkillRefSchema = z.object({
+    projectId: z.string().min(1).max(MAX_PROJECT_ID_LENGTH),
+    skillName: z.string().min(1).max(MAX_PROJECT_SKILL_NAME_LENGTH),
+}).strict();
+const AppliedManifestSchema = z.object({
+    managedBy: z.literal(MANAGED_BY),
+    generation: z.number().int().min(0).max(MAX_GENERATION),
+    bindings: z.array(ProjectSkillRefSchema).max(MAX_AGENT_PROJECT_SKILL_BINDINGS),
+    bindingDigest: z.string().regex(DIGEST),
+    resolutionDigest: z.string().regex(DIGEST),
+}).strict();
+/** Strict local-store boundary parser; not re-exported from the public projection-state facade. */
+export const parseAppliedProjectSkillManifest = (candidate) => {
+    if (candidate && typeof candidate === "object" && "managedBy" in candidate
+        && candidate.managedBy !== MANAGED_BY) {
+        return unmanaged();
+    }
+    const parsed = AppliedManifestSchema.safeParse(candidate);
+    if (!parsed.success)
+        return corrupt();
+    const bindings = canonicalBindings(parsed.data.bindings);
+    if (bindings.some((binding, index) => !sameBinding(binding, parsed.data.bindings[index]))) {
+        return corrupt();
+    }
+    if (parsed.data.bindingDigest !== digest(bindings))
+        return corrupt();
+    return Object.freeze({
+        managedBy: MANAGED_BY,
+        generation: parsed.data.generation,
+        bindings,
+        bindingDigest: parsed.data.bindingDigest,
+        resolutionDigest: parsed.data.resolutionDigest,
+    });
+};