@nowcrew/daemon 0.6.18 → 0.6.20

package/dist/project-skills/runtime-launch.js

@@ -0,0 +1,102 @@
+import { join } from "node:path";
+import { resolveOrderedUniqueClaudeDirectories } from "../runtimes/claude.js";
+import { ProjectProjectionError, } from "./reconciler.js";
+const runtimeRootSecrets = (root) => Object.freeze([...new Set([
+        root.rootDirectory,
+        root.codexSkillRoot,
+        root.claudeAdditionalDirectory,
+        root.rootId,
+    ].flatMap((value) => [
+        value,
+        value.replaceAll("\\", "/"),
+        value.replaceAll("/", "\\"),
+    ]))].sort((left, right) => right.length - left.length));
+export function redactProjectSkillRuntimeRootText(text, root) {
+    if (root === undefined)
+        return text;
+    return runtimeRootSecrets(root)
+        .reduce((redacted, secret) => redacted.replaceAll(secret, "[project-skill-root]"), text);
+}
+export function redactProjectSkillRuntimeRootError(error, root) {
+    if (!(error instanceof Error)) {
+        return typeof error === "string" ? redactProjectSkillRuntimeRootText(error, root) : error;
+    }
+    const message = redactProjectSkillRuntimeRootText(error.message, root);
+    if (message === error.message)
+        return error;
+    const redacted = new Error(message);
+    redacted.name = error.name;
+    return redacted;
+}
+/** Recursively redacts exact v2 root identities before Runtime output crosses daemon boundaries. */
+export function redactProjectSkillRuntimeRootValue(value, root) {
+    if (root === undefined)
+        return value;
+    if (typeof value === "string")
+        return redactProjectSkillRuntimeRootText(value, root);
+    if (Array.isArray(value)) {
+        return value.map((item) => redactProjectSkillRuntimeRootValue(item, root));
+    }
+    if (typeof value === "object" && value !== null) {
+        return Object.fromEntries(Object.entries(value)
+            .map(([key, item]) => [key, redactProjectSkillRuntimeRootValue(item, root)]));
+    }
+    return value;
+}
+/** Maps one captured daemon-local root to the exact native Runtime registration seam. */
+export function projectSkillRuntimeLaunchFacts(runtime, root) {
+    if (root === undefined)
+        return Object.freeze({});
+    if (runtime === "codex") {
+        return Object.freeze({ codexSkillRoot: root.codexSkillRoot });
+    }
+    if (runtime === "claude") {
+        return Object.freeze({ claudeAdditionalDirectory: root.claudeAdditionalDirectory });
+    }
+    throw new ProjectProjectionError("skill_projection_failed");
+}
+/** Builds Runtime-native arrays while keeping v1 shared roots separate from v2 exact roots. */
+export async function projectSkillRuntimeDirectories(input) {
+    const facts = projectSkillRuntimeLaunchFacts(input.runtime, input.runtimeRoot);
+    const codexSkillRoots = input.runtime === "codex"
+        && (input.runtimeRoot !== undefined || input.projectContext !== undefined)
+        ? Object.freeze([
+            ...(facts.codexSkillRoot === undefined
+                ? input.projectSkillsPresent ? [join(input.agentRoot, ".agents", "skills")] : []
+                : [facts.codexSkillRoot]),
+            ...(input.abilitySkillRoot === undefined ? [] : [input.abilitySkillRoot]),
+        ])
+        : Object.freeze([]);
+    if (input.runtime !== "claude") {
+        return Object.freeze({ codexSkillRoots, claudeAdditionalDirectories: Object.freeze([]) });
+    }
+    if (input.runtimeRoot !== undefined) {
+        if (facts.claudeAdditionalDirectory === undefined) {
+            throw new ProjectProjectionError("skill_projection_failed");
+        }
+        return Object.freeze({
+            codexSkillRoots,
+            claudeAdditionalDirectories: await resolveOrderedUniqueClaudeDirectories([
+                ...(input.projectContext?.secondary.map((project) => project.root) ?? []),
+                facts.claudeAdditionalDirectory,
+                ...(input.abilitySkillRoot === undefined ? [] : [input.abilitySkillRoot]),
+            ], input.projectContext?.primary === undefined ? [] : [input.projectContext.primary.root]),
+        });
+    }
+    const claudeAdditionalDirectories = input.projectContext === undefined
+        ? !input.projectSkillsPresent && input.abilitySkillRoot === undefined
+            ? Object.freeze([])
+            : await resolveOrderedUniqueClaudeDirectories([
+                join(input.agentRoot, ".crew", "claude-skills"),
+                input.agentRoot,
+                ...(input.abilitySkillRoot === undefined ? [] : [input.abilitySkillRoot]),
+            ])
+        : await resolveOrderedUniqueClaudeDirectories([
+            ...input.projectContext.secondary.map((project) => project.root),
+            ...(input.projectSkillsPresent
+                ? [join(input.agentRoot, ".crew", "claude-skills")]
+                : []),
+            ...(input.abilitySkillRoot === undefined ? [] : [input.abilitySkillRoot]),
+        ], input.projectContext.primary === undefined ? [] : [input.projectContext.primary.root]);
+    return Object.freeze({ codexSkillRoots, claudeAdditionalDirectories });
+}

package/dist/project-skills/runtime-root-bootstrap.js

@@ -0,0 +1,47 @@
+import { ProjectSkillRuntimeStoreError } from "./runtime-root-domain.js";
+/**
+ * Generic startup hard gate. The callback is the only place a journal owner may be constructed or
+ * initialized, and is unreachable until every durable lease inventory has populated the synchronous
+ * retention snapshot. Task 9 wires this gate into `serve`; Task 5 deliberately does not advertise v2.
+ */
+export async function initializeAfterProjectSkillLeaseProtection(input) {
+    const protectedExecutionIds = new Set();
+    for (const agentRoot of input.agentRoots) {
+        for (const executionId of await input.leases.protectedExecutionIds(agentRoot)) {
+            protectedExecutionIds.add(executionId);
+        }
+    }
+    return input.initialize(protectedExecutionIds);
+}
+/**
+ * Runs only after execution-journal restart reconciliation has settled. A lease without a terminal
+ * journal fact remains durable and prevents the caller from marking Project Skill v2 ready.
+ */
+export async function recoverProjectSkillRuntimeRoots(input) {
+    for (const agentRoot of input.agentRoots) {
+        await input.roots.recover(agentRoot);
+        let unresolvedLease = false;
+        await input.leases.recover(agentRoot, async (executionId) => {
+            const entry = await input.journal.get(executionId);
+            const releasable = entry?.state === "completed" || entry?.state === "interrupted";
+            if (!releasable)
+                unresolvedLease = true;
+            return releasable;
+        });
+        if (unresolvedLease) {
+            throw new ProjectSkillRuntimeStoreError("skill_projection_snapshot_corrupt");
+        }
+    }
+    await input.afterLeaseRecovery?.();
+    for (const agentRoot of input.agentRoots) {
+        if (input.gc !== undefined && input.leases.list !== undefined && input.currentRootId !== undefined) {
+            const leased = await input.leases.list(agentRoot);
+            const currentRootId = await input.currentRootId(agentRoot);
+            await input.gc.collect(agentRoot, {
+                currentRootId,
+                leasedRootIds: leased.map(({ rootId }) => rootId),
+                keepHistory: 2,
+            }).catch(() => undefined);
+        }
+    }
+}

package/dist/project-skills/runtime-root-domain.js

@@ -0,0 +1,268 @@
+import { createHash } from "node:crypto";
+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 RUNTIME_ROOT_MANAGED_BY = "nowcrew-project-skill-runtime-root";
+const RUNTIME_STORE_MANAGED_BY = "nowcrew-project-skill-runtime-store";
+const RUNTIME_LEASE_MANAGED_BY = "nowcrew-project-skill-runtime-lease";
+const DIGEST = /^sha256:[a-f0-9]{64}$/u;
+const DECIMAL_BIGINT = /^(?:0|[1-9][0-9]*)$/u;
+const PATH_FREE_IDENTITY = /^[A-Za-z0-9][A-Za-z0-9._:-]*$/u;
+const CANONICAL_ROOT_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u;
+const MAX_LOCAL_IDENTITY_LENGTH = 512;
+const MAX_PUBLISHED_SEQUENCE = Number.MAX_SAFE_INTEGER - 1;
+/** Deployment algorithm/layout revision. This is deliberately not a source-content hash. */
+export const PROJECT_SKILL_RUNTIME_MATERIALIZATION_REVISION = 1;
+export class ProjectSkillRuntimeStoreError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+        this.name = "ProjectSkillRuntimeStoreError";
+    }
+}
+const corrupt = () => {
+    throw new ProjectSkillRuntimeStoreError("skill_projection_snapshot_corrupt");
+};
+const unmanaged = () => {
+    throw new ProjectSkillRuntimeStoreError("skill_projection_runtime_root_unmanaged");
+};
+const SafeSequenceSchema = z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+const PublishedSequenceSchema = SafeSequenceSchema.max(MAX_PUBLISHED_SEQUENCE);
+const PositiveMaterializationRevisionSchema = z.number().int().positive().max(Number.MAX_SAFE_INTEGER);
+export const isCanonicalProjectSkillRuntimeRootId = (value) => CANONICAL_ROOT_ID.test(value);
+const RootIdSchema = z.string().refine(isCanonicalProjectSkillRuntimeRootId);
+const DigestSchema = z.string().regex(DIGEST);
+const DirectoryIdentitySchema = z.object({
+    dev: z.string().regex(DECIMAL_BIGINT),
+    ino: z.string().regex(DECIMAL_BIGINT),
+    birthtimeNs: z.string().regex(DECIMAL_BIGINT),
+}).strict();
+const ProjectionModeSchema = z.object({
+    projectId: z.string().min(1).max(MAX_PROJECT_ID_LENGTH),
+    skillName: z.string().min(1).max(MAX_PROJECT_SKILL_NAME_LENGTH),
+    mode: z.enum(["symlink", "junction", "copy", "missing"]),
+}).strict();
+const RuntimeRootManifestSchema = z.object({
+    managedBy: z.literal(RUNTIME_ROOT_MANAGED_BY),
+    version: z.literal(1),
+    rootId: RootIdSchema,
+    publishedSequence: PublishedSequenceSchema,
+    materializationRevision: PositiveMaterializationRevisionSchema,
+    directoryIdentity: DirectoryIdentitySchema,
+    bindingDigest: DigestSchema,
+    resolutionDigest: DigestSchema,
+    projectionModes: z.array(ProjectionModeSchema).max(MAX_AGENT_PROJECT_SKILL_BINDINGS),
+}).strict();
+const RuntimeRootManifestInputSchema = RuntimeRootManifestSchema
+    .omit({ managedBy: true, version: true, materializationRevision: true })
+    .partial({ publishedSequence: true, directoryIdentity: true });
+const RuntimeRootRecordSchema = z.object({
+    rootId: RootIdSchema,
+    publishedSequence: PublishedSequenceSchema,
+    materializationRevision: PositiveMaterializationRevisionSchema,
+    directoryIdentity: DirectoryIdentitySchema,
+    bindingDigest: DigestSchema,
+    resolutionDigest: DigestSchema,
+}).strict();
+const RuntimeStoreStateSchema = z.object({
+    managedBy: z.literal(RUNTIME_STORE_MANAGED_BY),
+    version: z.literal(1),
+    nextSequence: SafeSequenceSchema,
+    roots: z.array(RuntimeRootRecordSchema),
+}).strict();
+const RuntimeStoreStateInputSchema = RuntimeStoreStateSchema.omit({ managedBy: true, version: true });
+const PathFreeIdentitySchema = z.string()
+    .min(1)
+    .max(MAX_LOCAL_IDENTITY_LENGTH)
+    .regex(PATH_FREE_IDENTITY);
+const RuntimeLeaseRecordSchema = z.object({
+    managedBy: z.literal(RUNTIME_LEASE_MANAGED_BY),
+    version: z.literal(1),
+    executionId: PathFreeIdentitySchema,
+    rootId: RootIdSchema,
+    nonce: PathFreeIdentitySchema,
+}).strict();
+const RuntimeLeaseRecordInputSchema = RuntimeLeaseRecordSchema.omit({ managedBy: true, version: true });
+const immutableDirectoryIdentity = (identity) => Object.freeze({
+    dev: identity.dev,
+    ino: identity.ino,
+    birthtimeNs: identity.birthtimeNs,
+});
+const sameProjectionRef = (left, right) => left.projectId === right.projectId && left.skillName === right.skillName;
+const immutableProjectionMode = (projection) => Object.freeze({
+    projectId: projection.projectId,
+    skillName: projection.skillName,
+    mode: projection.mode,
+});
+const canonicalProjectionModes = (modes) => {
+    const seen = new Set();
+    const canonical = modes.map((mode) => {
+        if (!isProjectId(mode.projectId) || !isProjectSkillName(mode.skillName))
+            return corrupt();
+        const key = `${mode.projectId}\0${mode.skillName}`;
+        if (seen.has(key))
+            return corrupt();
+        seen.add(key);
+        return immutableProjectionMode(mode);
+    }).sort(compareProjectSkillRefs);
+    return Object.freeze(canonical);
+};
+const requireCanonicalProjectionModes = (modes) => {
+    const canonical = canonicalProjectionModes(modes);
+    if (canonical.some((mode, index) => {
+        const input = modes[index];
+        return input === undefined || !sameProjectionRef(mode, input) || mode.mode !== input.mode;
+    }))
+        return corrupt();
+    return canonical;
+};
+const immutableRootRecord = (record) => Object.freeze({
+    rootId: record.rootId,
+    publishedSequence: record.publishedSequence,
+    materializationRevision: record.materializationRevision,
+    directoryIdentity: immutableDirectoryIdentity(record.directoryIdentity),
+    bindingDigest: record.bindingDigest,
+    resolutionDigest: record.resolutionDigest,
+});
+const compareRootRecords = (left, right) => left.publishedSequence - right.publishedSequence
+    || (left.rootId < right.rootId ? -1 : left.rootId > right.rootId ? 1 : 0);
+const canonicalRootRecords = (records) => {
+    const rootIds = new Set();
+    const sequences = new Set();
+    const canonical = records.map((record) => {
+        const parsed = RuntimeRootRecordSchema.safeParse(record);
+        if (!parsed.success)
+            return corrupt();
+        if (rootIds.has(parsed.data.rootId) || sequences.has(parsed.data.publishedSequence))
+            return corrupt();
+        rootIds.add(parsed.data.rootId);
+        sequences.add(parsed.data.publishedSequence);
+        return immutableRootRecord(parsed.data);
+    }).sort(compareRootRecords);
+    return Object.freeze(canonical);
+};
+const requireCanonicalRootRecords = (records) => {
+    const canonical = canonicalRootRecords(records);
+    if (canonical.some((record, index) => {
+        const input = records[index];
+        return input === undefined
+            || record.rootId !== input.rootId
+            || record.publishedSequence !== input.publishedSequence;
+    }))
+        return corrupt();
+    return canonical;
+};
+const requireNextSequence = (nextSequence, roots) => {
+    const latest = roots.at(-1);
+    if (latest !== undefined && latest.publishedSequence >= nextSequence)
+        corrupt();
+};
+const rejectUnknownOwner = (candidate, expected) => {
+    if (candidate && typeof candidate === "object" && "managedBy" in candidate
+        && candidate.managedBy !== expected)
+        unmanaged();
+};
+export function createProjectSkillRuntimeRootManifest(input) {
+    const parsedInput = RuntimeRootManifestInputSchema.safeParse(input);
+    if (!parsedInput.success)
+        return corrupt();
+    const candidate = RuntimeRootManifestSchema.safeParse({
+        managedBy: RUNTIME_ROOT_MANAGED_BY,
+        version: 1,
+        rootId: parsedInput.data.rootId,
+        publishedSequence: parsedInput.data.publishedSequence ?? 0,
+        materializationRevision: PROJECT_SKILL_RUNTIME_MATERIALIZATION_REVISION,
+        directoryIdentity: parsedInput.data.directoryIdentity ?? { dev: "0", ino: "0", birthtimeNs: "0" },
+        bindingDigest: parsedInput.data.bindingDigest,
+        resolutionDigest: parsedInput.data.resolutionDigest,
+        projectionModes: parsedInput.data.projectionModes,
+    });
+    if (!candidate.success)
+        return corrupt();
+    return Object.freeze({
+        ...candidate.data,
+        directoryIdentity: immutableDirectoryIdentity(candidate.data.directoryIdentity),
+        projectionModes: canonicalProjectionModes(candidate.data.projectionModes),
+    });
+}
+export function parseProjectSkillRuntimeRootManifest(candidate) {
+    rejectUnknownOwner(candidate, RUNTIME_ROOT_MANAGED_BY);
+    const parsed = RuntimeRootManifestSchema.safeParse(candidate);
+    if (!parsed.success)
+        return corrupt();
+    return Object.freeze({
+        ...parsed.data,
+        directoryIdentity: immutableDirectoryIdentity(parsed.data.directoryIdentity),
+        projectionModes: requireCanonicalProjectionModes(parsed.data.projectionModes),
+    });
+}
+export function createProjectSkillRuntimeRootRecord(input) {
+    const parsed = RuntimeRootRecordSchema.safeParse(input);
+    if (!parsed.success)
+        return corrupt();
+    return immutableRootRecord(parsed.data);
+}
+export function parseProjectSkillRuntimeRootRecord(candidate) {
+    const parsed = RuntimeRootRecordSchema.safeParse(candidate);
+    if (!parsed.success)
+        return corrupt();
+    return immutableRootRecord(parsed.data);
+}
+export function createProjectSkillRuntimeStoreState(input) {
+    const parsedInput = RuntimeStoreStateInputSchema.safeParse(input);
+    if (!parsedInput.success)
+        return corrupt();
+    const parsed = RuntimeStoreStateSchema.safeParse({
+        managedBy: RUNTIME_STORE_MANAGED_BY,
+        version: 1,
+        nextSequence: parsedInput.data.nextSequence,
+        roots: parsedInput.data.roots,
+    });
+    if (!parsed.success)
+        return corrupt();
+    const roots = canonicalRootRecords(parsed.data.roots);
+    requireNextSequence(parsed.data.nextSequence, roots);
+    return Object.freeze({
+        managedBy: RUNTIME_STORE_MANAGED_BY,
+        version: 1,
+        nextSequence: parsed.data.nextSequence,
+        roots,
+    });
+}
+export function parseProjectSkillRuntimeStoreState(candidate) {
+    rejectUnknownOwner(candidate, RUNTIME_STORE_MANAGED_BY);
+    const parsed = RuntimeStoreStateSchema.safeParse(candidate);
+    if (!parsed.success)
+        return corrupt();
+    const roots = requireCanonicalRootRecords(parsed.data.roots);
+    requireNextSequence(parsed.data.nextSequence, roots);
+    return Object.freeze({
+        managedBy: RUNTIME_STORE_MANAGED_BY,
+        version: 1,
+        nextSequence: parsed.data.nextSequence,
+        roots,
+    });
+}
+export function createProjectSkillRuntimeLeaseRecord(input) {
+    const parsedInput = RuntimeLeaseRecordInputSchema.safeParse(input);
+    if (!parsedInput.success)
+        return corrupt();
+    const parsed = RuntimeLeaseRecordSchema.safeParse({
+        managedBy: RUNTIME_LEASE_MANAGED_BY,
+        version: 1,
+        ...parsedInput.data,
+    });
+    if (!parsed.success)
+        return corrupt();
+    return Object.freeze(parsed.data);
+}
+export function parseProjectSkillRuntimeLeaseRecord(candidate) {
+    rejectUnknownOwner(candidate, RUNTIME_LEASE_MANAGED_BY);
+    const parsed = RuntimeLeaseRecordSchema.safeParse(candidate);
+    if (!parsed.success)
+        return corrupt();
+    return Object.freeze(parsed.data);
+}
+export function projectSkillRuntimeLeaseKey(executionId) {
+    return createHash("sha256").update(executionId, "utf8").digest("hex");
+}