@nowcrew/daemon 0.5.34 → 0.5.36

package/dist/project-skills/reconciler.js

@@ -0,0 +1,116 @@
+import { lstat, mkdir, rename, rm, stat, symlink, writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { dirname, join } from "node:path";
+export class ProjectProjectionError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+        this.name = "ProjectProjectionError";
+    }
+}
+const exists = async (path) => lstat(path).then(() => true, () => false);
+async function switchProjectionSet(targets) {
+    const moved = [];
+    try {
+        for (const target of targets) {
+            const hadPrevious = await exists(target.target);
+            if (hadPrevious)
+                await rename(target.target, target.backup);
+            const state = { target, hadPrevious, activated: false };
+            moved.push(state);
+            await rename(target.staging, target.target);
+            state.activated = true;
+        }
+    }
+    catch (error) {
+        for (const state of [...moved].reverse()) {
+            if (state.activated)
+                await rm(state.target.target, { recursive: true, force: true }).catch(() => { });
+            if (state.hadPrevious)
+                await rename(state.target.backup, state.target.target).catch(() => { });
+        }
+        throw error;
+    }
+    await Promise.all(targets.map((target) => rm(target.backup, { recursive: true, force: true })));
+}
+export function createProjectSkillsReconciler(deps) {
+    const platform = deps.platform ?? process.platform;
+    const reconcileUnlocked = async (handle, bindings) => {
+        if (platform !== "darwin" && platform !== "linux") {
+            throw new ProjectProjectionError("skill_projection_failed");
+        }
+        const projects = deps.scannedProjects();
+        const uniqueBindings = [...new Map(bindings.map((binding) => [
+                `${binding.projectId}\0${binding.skillName}`,
+                binding,
+            ])).values()].sort((left, right) => left.projectId.localeCompare(right.projectId) || left.skillName.localeCompare(right.skillName));
+        const names = new Map();
+        for (const binding of uniqueBindings) {
+            const owner = names.get(binding.skillName);
+            if (owner !== undefined && owner !== binding.projectId) {
+                throw new ProjectProjectionError("skill_name_conflict");
+            }
+            names.set(binding.skillName, binding.projectId);
+        }
+        const linked = [];
+        const resolutions = [];
+        for (const binding of uniqueBindings) {
+            const project = projects.find((candidate) => candidate.inventory.projectId === binding.projectId
+                && candidate.inventory.status === "available");
+            const skill = project?.resolved.find((candidate) => candidate.name === binding.skillName);
+            const available = skill !== undefined && (await stat(skill.sourcePath).catch(() => null))?.isDirectory() === true;
+            resolutions.push(Object.freeze({ ...binding, status: available ? "linked" : "unavailable" }));
+            if (available && skill !== undefined)
+                linked.push({ binding, skill });
+        }
+        const agentRoot = join(deps.agentsRoot, handle);
+        const id = randomUUID();
+        const targets = [
+            {
+                runtime: "codex",
+                target: join(agentRoot, ".agents", "skills"),
+                staging: join(agentRoot, ".agents", `.skills-next-${id}`),
+                backup: join(agentRoot, ".agents", `.skills-previous-${id}`),
+            },
+            {
+                runtime: "claude",
+                target: join(agentRoot, ".crew", "claude-skills", ".claude", "skills"),
+                staging: join(agentRoot, ".crew", "claude-skills", ".claude", `.skills-next-${id}`),
+                backup: join(agentRoot, ".crew", "claude-skills", ".claude", `.skills-previous-${id}`),
+            },
+        ];
+        try {
+            for (const target of targets) {
+                await mkdir(dirname(target.target), { recursive: true });
+                await mkdir(target.staging, { mode: 0o700 });
+                for (const item of linked) {
+                    await symlink(item.skill.sourcePath, join(target.staging, item.binding.skillName), "dir");
+                }
+            }
+            for (const target of targets)
+                await deps.beforeSwitch?.(target.runtime);
+            await switchProjectionSet(targets);
+            await writeFile(join(agentRoot, ".nowwork-root"), "", { encoding: "utf8", mode: 0o600 });
+            return Object.freeze(resolutions);
+        }
+        catch {
+            await Promise.all(targets.map((target) => rm(target.staging, { recursive: true, force: true })));
+            throw new ProjectProjectionError("skill_projection_failed");
+        }
+    };
+    return {
+        reconcile(handle, bindings) {
+            return deps.coordinator.runExclusive(deps.agentsRoot, handle, () => reconcileUnlocked(handle, bindings));
+        },
+        prepareAndLaunch(agentsRoot, handle, bindings, launch) {
+            if (agentsRoot !== deps.agentsRoot) {
+                return Promise.reject(new ProjectProjectionError("skill_projection_failed"));
+            }
+            return deps.coordinator.runExclusive(deps.agentsRoot, handle, async () => {
+                await reconcileUnlocked(handle, bindings);
+                return launch();
+            });
+        },
+    };
+}

package/dist/project-skills/registry.js

@@ -0,0 +1,113 @@
+import { readFile, stat } from "node:fs/promises";
+import { isAbsolute, join, resolve } from "node:path";
+import { z } from "zod";
+import { isProjectId, MAX_MACHINE_PROJECTS } from "./types.js";
+import { createPromiseTail } from "../promise-tail.js";
+import { atomicPrivateWrite } from "../atomic-private-write.js";
+const RegistryFileSchema = z.object({
+    version: z.literal(1),
+    projects: z.record(z.object({ root: z.string().min(1).max(4_096) }).strict()),
+}).strict();
+export class ProjectRegistryError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+        this.name = "ProjectRegistryError";
+    }
+}
+const immutableList = (projects) => {
+    const sorted = Object.entries(projects)
+        .map(([projectId, project]) => Object.freeze({ projectId, root: project.root }))
+        .sort((left, right) => left.projectId.localeCompare(right.projectId));
+    if (sorted.length <= MAX_MACHINE_PROJECTS)
+        return Object.freeze(sorted);
+    const visible = sorted.slice(0, MAX_MACHINE_PROJECTS);
+    const boundary = visible.at(-1);
+    if (boundary !== undefined) {
+        visible[visible.length - 1] = Object.freeze({
+            ...boundary,
+            errorCode: "project_registry_limit_exceeded",
+        });
+    }
+    return Object.freeze(visible);
+};
+export function createProjectRegistry(agentsRoot) {
+    const path = join(agentsRoot, ".crew", "projects.json");
+    const writeTail = createPromiseTail();
+    const load = async () => {
+        let raw;
+        try {
+            raw = await readFile(path, "utf8");
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return Object.freeze({});
+            throw new ProjectRegistryError("project_registry_corrupt");
+        }
+        try {
+            const parsed = RegistryFileSchema.parse(JSON.parse(raw));
+            for (const [projectId, project] of Object.entries(parsed.projects)) {
+                if (!isProjectId(projectId) || !isAbsolute(project.root)) {
+                    throw new ProjectRegistryError("project_registry_corrupt");
+                }
+            }
+            return Object.freeze(Object.fromEntries(Object.entries(parsed.projects).map(([projectId, project]) => [
+                projectId,
+                Object.freeze({ root: resolve(project.root) }),
+            ])));
+        }
+        catch (error) {
+            if (error instanceof ProjectRegistryError)
+                throw error;
+            throw new ProjectRegistryError("project_registry_corrupt");
+        }
+    };
+    const save = async (projects) => {
+        await atomicPrivateWrite(path, `${JSON.stringify({ version: 1, projects }, null, 2)}\n`);
+    };
+    const enqueue = (operation) => writeTail.enqueue(operation);
+    return {
+        path,
+        async list() {
+            await writeTail.wait();
+            return immutableList(await load());
+        },
+        add(projectId, root) {
+            return enqueue(async () => {
+                if (!isProjectId(projectId))
+                    throw new ProjectRegistryError("project_id_invalid");
+                if (!isAbsolute(root))
+                    throw new ProjectRegistryError("project_path_invalid");
+                const normalizedRoot = resolve(root);
+                const rootStat = await stat(normalizedRoot).catch(() => null);
+                if (!rootStat?.isDirectory())
+                    throw new ProjectRegistryError("project_path_invalid");
+                const projects = await load();
+                const existing = projects[projectId];
+                if (existing?.root === normalizedRoot)
+                    return Object.freeze({ projectId, root: normalizedRoot });
+                if (existing !== undefined)
+                    throw new ProjectRegistryError("project_id_conflict");
+                if (Object.keys(projects).length >= MAX_MACHINE_PROJECTS) {
+                    throw new ProjectRegistryError("project_limit_exceeded");
+                }
+                const next = Object.freeze({ ...projects, [projectId]: Object.freeze({ root: normalizedRoot }) });
+                await save(next);
+                return Object.freeze({ projectId, root: normalizedRoot });
+            });
+        },
+        remove(projectId) {
+            return enqueue(async () => {
+                if (!isProjectId(projectId))
+                    throw new ProjectRegistryError("project_id_invalid");
+                const projects = await load();
+                if (projects[projectId] === undefined)
+                    return false;
+                const next = Object.fromEntries(Object.entries(projects).filter(([candidate]) => candidate !== projectId));
+                await save(Object.freeze(next));
+                return true;
+            });
+        },
+    };
+}

package/dist/project-skills/scanner.js

@@ -0,0 +1,126 @@
+import { readdir, readFile, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { isProjectSkillName, MAX_MACHINE_PROJECT_SKILLS, MAX_PROJECT_SKILL_DESCRIPTION_LENGTH, MAX_PROJECT_SKILLS_PER_PROJECT, } from "./types.js";
+import { parseSkillFrontmatter } from "../skill-frontmatter.js";
+const unavailable = (projectId, scannedAt, errorCode) => Object.freeze({
+    inventory: Object.freeze({
+        projectId,
+        status: "unavailable",
+        skills: Object.freeze([]),
+        invalidSkillCount: 0,
+        errorCode,
+        scannedAt,
+    }),
+    resolved: Object.freeze([]),
+});
+export async function scanProject(project, now = () => new Date()) {
+    const scannedAt = now().toISOString();
+    if (project.errorCode !== undefined)
+        return unavailable(project.projectId, scannedAt, project.errorCode);
+    const projectStat = await stat(project.root).catch(() => null);
+    if (!projectStat?.isDirectory())
+        return unavailable(project.projectId, scannedAt, "project_path_unavailable");
+    const skillsRoot = join(project.root, ".agents", "skills");
+    let entries;
+    try {
+        entries = await readdir(skillsRoot, { withFileTypes: true });
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return Object.freeze({
+                inventory: Object.freeze({
+                    projectId: project.projectId,
+                    status: "available",
+                    skills: Object.freeze([]),
+                    invalidSkillCount: 0,
+                    errorCode: null,
+                    scannedAt,
+                }),
+                resolved: Object.freeze([]),
+            });
+        }
+        return unavailable(project.projectId, scannedAt, "project_skills_unreadable");
+    }
+    let invalidSkillCount = 0;
+    const candidates = [];
+    for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+        if (entry.name.startsWith(".") || !entry.isDirectory())
+            continue;
+        const sourcePath = join(skillsRoot, entry.name);
+        const markdown = await readFile(join(sourcePath, "SKILL.md"), "utf8").catch(() => null);
+        if (markdown === null) {
+            invalidSkillCount += 1;
+            continue;
+        }
+        const frontmatter = parseSkillFrontmatter(markdown);
+        const name = frontmatter.name;
+        const description = frontmatter.description;
+        if (name === undefined || description === undefined) {
+            invalidSkillCount += 1;
+            continue;
+        }
+        if (!isProjectSkillName(name) || description.length > MAX_PROJECT_SKILL_DESCRIPTION_LENGTH) {
+            invalidSkillCount += 1;
+            continue;
+        }
+        candidates.push(Object.freeze({ name, description, sourcePath }));
+    }
+    const counts = new Map();
+    for (const candidate of candidates)
+        counts.set(candidate.name, (counts.get(candidate.name) ?? 0) + 1);
+    const resolved = candidates.filter((candidate) => {
+        if (counts.get(candidate.name) === 1)
+            return true;
+        invalidSkillCount += 1;
+        return false;
+    }).sort((left, right) => left.name.localeCompare(right.name));
+    const skills = resolved.map(({ name, description }) => Object.freeze({ name, description }));
+    if (skills.length > MAX_PROJECT_SKILLS_PER_PROJECT) {
+        return unavailable(project.projectId, scannedAt, "project_skill_limit_exceeded");
+    }
+    return Object.freeze({
+        inventory: Object.freeze({
+            projectId: project.projectId,
+            status: "available",
+            skills: Object.freeze(skills),
+            invalidSkillCount,
+            errorCode: null,
+            scannedAt,
+        }),
+        resolved: Object.freeze(resolved),
+    });
+}
+export function boundScannedProjects(projects, retainedProjectIds = []) {
+    const retainedOrder = new Map(retainedProjectIds.map((projectId, index) => [projectId, index]));
+    const allocationOrder = [...projects].sort((left, right) => {
+        const leftOrder = retainedOrder.get(left.inventory.projectId);
+        const rightOrder = retainedOrder.get(right.inventory.projectId);
+        if (leftOrder !== undefined && rightOrder !== undefined)
+            return leftOrder - rightOrder;
+        if (leftOrder !== undefined)
+            return -1;
+        if (rightOrder !== undefined)
+            return 1;
+        return left.inventory.projectId.localeCompare(right.inventory.projectId);
+    });
+    let skillCount = 0;
+    const bounded = new Map();
+    for (const project of allocationOrder) {
+        if (project.inventory.status !== "available") {
+            bounded.set(project.inventory.projectId, project);
+            continue;
+        }
+        const nextCount = skillCount + project.inventory.skills.length;
+        if (nextCount <= MAX_MACHINE_PROJECT_SKILLS) {
+            skillCount = nextCount;
+            bounded.set(project.inventory.projectId, project);
+            continue;
+        }
+        bounded.set(project.inventory.projectId, unavailable(project.inventory.projectId, project.inventory.scannedAt, "machine_project_skill_limit_exceeded"));
+    }
+    return Object.freeze(projects.map((project) => bounded.get(project.inventory.projectId) ?? project));
+}
+export async function scanProjects(projects, now = () => new Date(), retainedProjectIds = []) {
+    const sorted = [...projects].sort((left, right) => left.projectId.localeCompare(right.projectId));
+    return boundScannedProjects(await Promise.all(sorted.map((project) => scanProject(project, now))), retainedProjectIds);
+}

package/dist/project-skills/types.js

@@ -0,0 +1,12 @@
+export const PROJECT_SKILLS_CAPABILITY = "project_skills_v1";
+export const MAX_PROJECT_ID_LENGTH = 64;
+export const MAX_PROJECT_SKILL_NAME_LENGTH = 128;
+export const MAX_PROJECT_SKILL_DESCRIPTION_LENGTH = 1_000;
+export const MAX_PROJECT_SKILLS_PER_PROJECT = 1_000;
+export const MAX_MACHINE_PROJECTS = 100;
+export const MAX_MACHINE_PROJECT_SKILLS = 1_000;
+export const MAX_AGENT_PROJECT_SKILL_BINDINGS = 500;
+const PROJECT_ID = /^[a-z0-9][a-z0-9._-]*$/u;
+const SKILL_NAME = /^[a-z0-9][a-z0-9._:-]*$/u;
+export const isProjectId = (value) => value.length > 0 && value.length <= MAX_PROJECT_ID_LENGTH && PROJECT_ID.test(value);
+export const isProjectSkillName = (value) => value.length > 0 && value.length <= MAX_PROJECT_SKILL_NAME_LENGTH && SKILL_NAME.test(value);

package/dist/promise-tail.js

@@ -0,0 +1,25 @@
+export function createKeyedPromiseTail() {
+    const tails = new Map();
+    return {
+        enqueue(key, operation) {
+            const previous = tails.get(key) ?? Promise.resolve();
+            const current = previous.catch(() => { }).then(operation);
+            const tail = current.then(() => undefined);
+            tails.set(key, tail);
+            void tail.finally(() => {
+                if (tails.get(key) === tail)
+                    tails.delete(key);
+            }).catch(() => { });
+            return current;
+        },
+        pending: (key) => tails.get(key),
+    };
+}
+export function createPromiseTail() {
+    const queue = createKeyedPromiseTail();
+    const key = "singleton";
+    return {
+        enqueue: (operation) => queue.enqueue(key, operation),
+        wait: () => queue.pending(key)?.catch(() => { }) ?? Promise.resolve(),
+    };
+}

package/dist/runner.js

@@ -154,6 +154,9 @@ export async function runAgent(config, input, onActivity = defaultPrint, onConso
             exitCode: local.exitCode,
             finalText: local.finalText,
             errorMessage: local.errorMessage,
+            ...(input.scheduled.serverOwnsFailureNotice?.() === true
+                ? { suppressFailureNotice: true }
+                : {}),
             send: (content) => sendAgentMessage(config.serverUrl, credential.token, input.channelId, {
                 content,
                 force: true,
@@ -194,6 +197,7 @@ export async function reportScheduledStartFailure(config, input) {
         exitCode: -1,
         finalText: null,
         errorMessage: input.errorMessage,
+        ...(input.serverOwnsFailureNotice?.() === true ? { suppressFailureNotice: true } : {}),
         send: (content) => sendAgentMessage(config.serverUrl, credential.token, input.channelId, {
             content,
             force: true,

package/dist/runtimes/claude.js

@@ -28,6 +28,8 @@ export function buildClaudeArgs(input) {
     if (input.sessionId) {
         args.push(input.resume ? "--resume" : "--session-id", input.sessionId);
     }
+    if (input.projectSkillsDirectory)
+        args.push("--add-dir", input.projectSkillsDirectory);
     if (input.effectivePermission === undefined) {
         if (input.dangerous)
             args.push("--dangerously-skip-permissions");

package/dist/runtimes/codex-app-server-runner.js

@@ -14,6 +14,7 @@ const RunnerInputSchema = z.object({
     reasoning: z.string().min(1).optional(),
     sessionId: z.string().min(1).optional(),
     imagePaths: z.array(z.string().min(1)).optional(),
+    projectRootMarkers: z.array(z.string().min(1).max(64).regex(/^[A-Za-z0-9._-]+$/u)).max(16).optional(),
     resume: z.boolean(),
 }).strict();
 const RPC_TIMEOUT_MS = 30_000;
@@ -31,6 +32,14 @@ const MAX_TRANSIENT_TURN_RETRIES = 2;
 const TRANSIENT_TURN_RETRY_DELAY_MS = 15_000;
 const TRANSIENT_TURN_RETRY_BACKOFF_FACTOR = 3;
 const PROCESS_TREE_STOP_TIMEOUT_MS = 1_000;
+export function codexAppServerArgs(projectRootMarkers) {
+    return [
+        ...(projectRootMarkers === undefined
+            ? []
+            : ["-c", `project_root_markers=${JSON.stringify(projectRootMarkers)}`]),
+        "app-server", "--listen", "stdio://",
+    ];
+}
 const TRANSIENT_TURN_ERROR_PATTERNS = [
     /at capacity/i,
     /overloaded/i,
@@ -345,7 +354,7 @@ async function stopChildTree(child) {
 }
 async function runCodexAppServerAttempt(bin, input, attempt, initializeTimeoutMs) {
     const attemptStartedAt = Date.now();
-    const child = spawn(bin, ["app-server", "--listen", "stdio://"], {
+    const child = spawn(bin, codexAppServerArgs(input.projectRootMarkers), {
         cwd: process.cwd(),
         env: process.env,
         stdio: ["pipe", "pipe", "pipe"],

package/dist/scheduled-report.js

@@ -18,6 +18,9 @@ export async function deliverScheduledReport(input) {
     let source = "none";
     let content = null;
     if (input.exitCode !== 0) {
+        if (input.suppressFailureNotice === true) {
+            return { required: false, attempted: false, delivered: false, source: "none" };
+        }
         source = "failure_notice";
         const detail = input.errorMessage?.trim().slice(0, 500);
         content = `Scheduled job "${title}" failed${detail ? `: ${detail}` : ` (exit ${input.exitCode})`}.`;