@camerontaylor/paseo-server 0.8.0-fork.1

package/dist/server/server/orchestration-skills/internal/operations.js

@@ -0,0 +1,178 @@
+import { createHash } from "node:crypto";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { listFilesRecursive, removeSkill, syncSkills } from "./sync.js";
+// Names the bundle used to ship. They are never selectable, but every scan still
+// covers them so an older install's copies get cleaned up.
+export const LEGACY_SKILL_NAMES = [
+    "paseo-chat",
+    "paseo-epic",
+    "paseo-orchestrate",
+    "paseo-orchestrator",
+];
+/**
+ * The bundle directory is the catalog. Reading it instead of a hardcoded list is
+ * what makes `all` pick up skills added in a later release with no code change.
+ */
+async function listBundledSkills(sourceDir) {
+    const entries = await fs.readdir(sourceDir, { withFileTypes: true }).catch(() => []);
+    return entries
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name)
+        .sort(compareStrings);
+}
+/** Every name Paseo owns on disk: what it ships now plus what it used to ship. */
+function managedSkillNames(available) {
+    return [...new Set([...available, ...LEGACY_SKILL_NAMES])].sort(compareStrings);
+}
+/** The names a convergence may create, replace, or delete. */
+export async function listManagedSkillNames(sourceDir) {
+    return managedSkillNames(await listBundledSkills(sourceDir));
+}
+function resolveDesiredSkills(selection, available) {
+    if (selection.mode === "all")
+        return new Set(available);
+    const chosen = new Set(selection.skills);
+    return new Set(available.filter((name) => chosen.has(name)));
+}
+async function hashSkillDir(skillDir) {
+    const stat = await fs.stat(skillDir).catch(() => null);
+    if (!stat?.isDirectory())
+        return null;
+    const rels = await listFilesRecursive(skillDir);
+    const files = new Map();
+    for (const rel of rels) {
+        const buf = await fs.readFile(path.join(skillDir, rel));
+        const sha = createHash("sha256").update(buf).digest("hex");
+        files.set(toPosix(rel), sha);
+    }
+    return files;
+}
+async function hashSkills(rootDir, names) {
+    const out = new Map();
+    for (const name of names) {
+        const files = await hashSkillDir(path.join(rootDir, name));
+        if (files !== null)
+            out.set(name, files);
+    }
+    return out;
+}
+function diff(bundle, disks, names, desired) {
+    const ops = [];
+    for (const name of names) {
+        const b = desired.has(name) ? bundle.get(name) : undefined;
+        const targetFiles = disks.map((disk) => disk.get(name));
+        const installedTargets = targetFiles.filter((files) => files !== undefined);
+        if (b) {
+            const missingTargets = installedTargets.length < disks.length;
+            const changedTargets = installedTargets.some((files) => !bundleFilesMatch(b, files));
+            if (missingTargets)
+                ops.push({ kind: "add", name });
+            else if (changedTargets)
+                ops.push({ kind: "update", name });
+        }
+        else if (installedTargets.length > 0) {
+            ops.push({ kind: "delete", name });
+        }
+    }
+    ops.sort((a, b) => compareStrings(a.name, b.name));
+    return ops;
+}
+function hasInstalledPaseoSkill(disks) {
+    return disks.some((disk) => disk.size > 0);
+}
+function installedSkillNames(disks, names) {
+    return names.filter((name) => disks.some((disk) => disk.has(name)));
+}
+function bundleFilesMatch(bundle, disk) {
+    for (const [rel, sha] of bundle) {
+        if (disk.get(rel) !== sha)
+            return false;
+    }
+    return true;
+}
+function toPosix(p) {
+    return p.split(path.sep).join("/");
+}
+function compareStrings(a, b) {
+    if (a < b)
+        return -1;
+    if (a > b)
+        return 1;
+    return 0;
+}
+export async function getSkillsStatus(targets, selection) {
+    const available = await listBundledSkills(targets.sourceDir);
+    const names = managedSkillNames(available);
+    const [bundle, agentsDisk, claudeDisk, codexDisk] = await Promise.all([
+        hashSkills(targets.sourceDir, available),
+        hashSkills(targets.agentsDir, names),
+        hashSkills(targets.claudeDir, names),
+        hashSkills(targets.codexDir, names),
+    ]);
+    const disks = [agentsDisk, claudeDisk, codexDisk];
+    const ops = diff(bundle, disks, names, resolveDesiredSkills(selection, available));
+    const installed = installedSkillNames(disks, names);
+    if (!hasInstalledPaseoSkill(disks))
+        return { state: "not-installed", ops, available, installed };
+    if (ops.length === 0)
+        return { state: "up-to-date", ops, available, installed };
+    return { state: "drift", ops, available, installed };
+}
+async function applySkills(targets, selection, initialStatus) {
+    const status = initialStatus ?? (await getSkillsStatus(targets, selection));
+    const writes = status.ops
+        .filter((op) => op.kind === "add" || op.kind === "update")
+        .map((op) => op.name);
+    if (writes.length > 0) {
+        await syncSkills({
+            sourceDir: targets.sourceDir,
+            agentsDir: targets.agentsDir,
+            claudeDir: targets.claudeDir,
+            codexDir: targets.codexDir,
+            skillNames: writes,
+        });
+    }
+    for (const op of status.ops) {
+        if (op.kind !== "delete")
+            continue;
+        await removeSkill(op.name, {
+            agentsDir: targets.agentsDir,
+            claudeDir: targets.claudeDir,
+            codexDir: targets.codexDir,
+        });
+    }
+    return getSkillsStatus(targets, selection);
+}
+export async function installSkills(targets, selection, 
+/** Apply exactly this plan instead of rescanning, so a confirmed plan is the applied plan. */
+plan) {
+    return applySkills(targets, selection, plan);
+}
+export async function updateSkills(targets, selection) {
+    const status = await getSkillsStatus(targets, selection);
+    return applySkills(targets, selection, nonDestructivePlan(status));
+}
+function nonDestructivePlan(status) {
+    return { ...status, ops: status.ops.filter((op) => op.kind !== "delete") };
+}
+export async function autoUpdateInstalledSkills(targets, selection) {
+    const status = await getSkillsStatus(targets, selection);
+    if (status.state !== "drift")
+        return status;
+    // Automatic maintenance may repair selected skills, but removal is an
+    // interactive operation because managed directories can contain user files.
+    return applySkills(targets, selection, nonDestructivePlan(status));
+}
+export async function uninstallSkills(targets, selection) {
+    const available = await listBundledSkills(targets.sourceDir);
+    for (const name of managedSkillNames(available)) {
+        await removeSkill(name, {
+            agentsDir: targets.agentsDir,
+            claudeDir: targets.claudeDir,
+            codexDir: targets.codexDir,
+        });
+    }
+    return getSkillsStatus(targets, selection);
+}
+//# sourceMappingURL=operations.js.map

package/dist/server/server/orchestration-skills/internal/paths.d.ts

@@ -0,0 +1,4 @@
+import type { SkillTargets } from "./operations.js";
+export declare function resolveBundledSkillsDir(moduleUrl?: string | URL): string;
+export declare function resolveSkillTargets(home?: string): SkillTargets;
+//# sourceMappingURL=paths.d.ts.map

package/dist/server/server/orchestration-skills/internal/paths.js

@@ -0,0 +1,21 @@
+import { existsSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+export function resolveBundledSkillsDir(moduleUrl = import.meta.url) {
+    const moduleDir = path.dirname(fileURLToPath(moduleUrl));
+    const candidates = [
+        path.resolve(moduleDir, "..", "..", "..", "skills"),
+        path.resolve(moduleDir, "..", "..", "..", "..", "..", "..", "skills"),
+    ];
+    return candidates.find((candidate) => existsSync(candidate)) ?? candidates[0];
+}
+export function resolveSkillTargets(home = os.homedir()) {
+    return {
+        sourceDir: resolveBundledSkillsDir(),
+        agentsDir: path.join(home, ".agents", "skills"),
+        claudeDir: path.join(home, ".claude", "skills"),
+        codexDir: path.join(home, ".codex", "skills"),
+    };
+}
+//# sourceMappingURL=paths.js.map

package/dist/server/server/orchestration-skills/internal/selection-store.d.ts

@@ -0,0 +1,12 @@
+import type { AgentSkillSelection } from "@camerontaylor/paseo-protocol/messages";
+import type { DaemonConfigStore } from "../../daemon-config-store.js";
+export type SkillSelection = AgentSkillSelection;
+export interface SkillSelectionStore {
+    get(): Promise<SkillSelection>;
+    set(selection: unknown): Promise<SkillSelection>;
+    isSet(): Promise<boolean>;
+}
+export declare function coerceSkillNames(value: unknown): string[];
+export declare function coerceSkillSelection(value: unknown): SkillSelection;
+export declare function createSkillSelectionStore(configStore: Pick<DaemonConfigStore, "get" | "setAgentSkillSelection">): SkillSelectionStore;
+//# sourceMappingURL=selection-store.d.ts.map

package/dist/server/server/orchestration-skills/internal/selection-store.js

@@ -0,0 +1,39 @@
+const DEFAULT_SKILL_SELECTION = { mode: "all" };
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function coerceSkillNames(value) {
+    if (!Array.isArray(value))
+        return [];
+    const names = value
+        .filter((entry) => typeof entry === "string")
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0);
+    return [...new Set(names)].sort();
+}
+export function coerceSkillSelection(value) {
+    if (!isRecord(value))
+        return DEFAULT_SKILL_SELECTION;
+    if (value.mode === "all")
+        return { mode: "all" };
+    if (value.mode === "custom") {
+        return { mode: "custom", skills: coerceSkillNames(value.skills) };
+    }
+    return DEFAULT_SKILL_SELECTION;
+}
+export function createSkillSelectionStore(configStore) {
+    return {
+        async get() {
+            return coerceSkillSelection(configStore.get().skills?.selection);
+        },
+        async set(selection) {
+            const parsed = coerceSkillSelection(selection);
+            configStore.setAgentSkillSelection(parsed);
+            return parsed;
+        },
+        async isSet() {
+            return configStore.get().skills?.selection !== undefined;
+        },
+    };
+}
+//# sourceMappingURL=selection-store.js.map

package/dist/server/server/orchestration-skills/internal/sync.d.ts

@@ -0,0 +1,21 @@
+export interface SkillSyncOptions {
+    sourceDir: string;
+    agentsDir: string;
+    claudeDir: string;
+    codexDir: string;
+    skillNames: readonly string[];
+    onSkillError?: (skillName: string, error: unknown) => void;
+}
+export interface SkillSyncResult {
+    changedFiles: number;
+    processedSkills: number;
+}
+export declare function listFilesRecursive(rootDir: string): Promise<string[]>;
+export interface RemoveSkillTargets {
+    agentsDir: string;
+    claudeDir: string;
+    codexDir: string;
+}
+export declare function removeSkill(skillName: string, targets: RemoveSkillTargets): Promise<void>;
+export declare function syncSkills(options: SkillSyncOptions): Promise<SkillSyncResult>;
+//# sourceMappingURL=sync.d.ts.map

package/dist/server/server/orchestration-skills/internal/sync.js

@@ -0,0 +1,177 @@
+import { createHash } from "node:crypto";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+const MANAGED_FILES_MANIFEST = ".paseo-managed-files.json";
+async function writeFileIfChanged(srcPath, dstPath) {
+    const src = await fs.readFile(srcPath);
+    const dst = await fs.readFile(dstPath).catch(() => null);
+    if (dst && src.equals(dst))
+        return false;
+    await fs.mkdir(path.dirname(dstPath), { recursive: true });
+    await fs.writeFile(dstPath, src);
+    return true;
+}
+export async function listFilesRecursive(rootDir) {
+    const out = [];
+    async function walk(dir) {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const full = path.join(dir, entry.name);
+            const rel = path.relative(rootDir, full);
+            if (rel === MANAGED_FILES_MANIFEST)
+                continue;
+            if (entry.isDirectory()) {
+                await walk(full);
+            }
+            else if (entry.isFile()) {
+                out.push(rel);
+            }
+        }
+    }
+    await walk(rootDir);
+    return out;
+}
+async function readManagedFilesManifest(dstDir) {
+    const raw = await fs
+        .readFile(path.join(dstDir, MANAGED_FILES_MANIFEST), "utf-8")
+        .catch(() => null);
+    if (!raw)
+        return null;
+    const parsed = safeParseJson(raw);
+    if (!parsed)
+        return null;
+    if (parsed.version !== 1 || typeof parsed.files !== "object" || parsed.files === null)
+        return null;
+    return { version: 1, files: parsed.files };
+}
+function safeParseJson(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+async function hashFile(filePath) {
+    const buf = await fs.readFile(filePath);
+    return createHash("sha256").update(buf).digest("hex");
+}
+async function writeManifestIfChanged(dstDir, files) {
+    const manifest = { version: 1, files };
+    const next = `${JSON.stringify(manifest, null, 2)}\n`;
+    const manifestPath = path.join(dstDir, MANAGED_FILES_MANIFEST);
+    const current = await fs.readFile(manifestPath, "utf-8").catch(() => null);
+    if (current === next)
+        return false;
+    await fs.mkdir(dstDir, { recursive: true });
+    await fs.writeFile(manifestPath, next);
+    return true;
+}
+async function pruneEmptyParentDirs(rootDir, rels) {
+    const dirs = new Set();
+    for (const rel of rels) {
+        let dir = path.dirname(rel);
+        while (dir !== ".") {
+            dirs.add(dir);
+            dir = path.dirname(dir);
+        }
+    }
+    const deepestFirst = [...dirs].sort((a, b) => b.split(path.sep).length - a.split(path.sep).length);
+    for (const rel of deepestFirst) {
+        await fs.rmdir(path.join(rootDir, rel)).catch(() => { });
+    }
+}
+async function assertManagedPathsStayInsideSkill(rootDir, rels) {
+    for (const rel of rels) {
+        const normalized = path.normalize(rel);
+        if (path.isAbsolute(normalized) ||
+            normalized === ".." ||
+            normalized.startsWith(`..${path.sep}`)) {
+            throw new Error(`Cannot sync managed path outside skill directory: ${rel}`);
+        }
+        let current = rootDir;
+        for (const segment of normalized.split(path.sep)) {
+            current = path.join(current, segment);
+            const info = await fs.lstat(current).catch((error) => {
+                if (error.code === "ENOENT")
+                    return null;
+                throw error;
+            });
+            if (info === null)
+                break;
+            if (info.isSymbolicLink()) {
+                throw new Error(`Cannot sync through symbolic link: ${current}`);
+            }
+        }
+    }
+}
+async function syncDirectoryFiles(srcDir, dstDir) {
+    const files = await listFilesRecursive(srcDir);
+    const srcFileSet = new Set(files);
+    const srcHashes = {};
+    for (const rel of files) {
+        srcHashes[rel] = await hashFile(path.join(srcDir, rel));
+    }
+    await assertManagedPathsStayInsideSkill(dstDir, [MANAGED_FILES_MANIFEST]);
+    const previousManifest = await readManagedFilesManifest(dstDir);
+    await assertManagedPathsStayInsideSkill(dstDir, [
+        MANAGED_FILES_MANIFEST,
+        ...files,
+        ...Object.keys(previousManifest?.files ?? {}),
+    ]);
+    let changed = 0;
+    for (const rel of files) {
+        if (await writeFileIfChanged(path.join(srcDir, rel), path.join(dstDir, rel))) {
+            changed++;
+        }
+    }
+    const deletedRels = [];
+    for (const [rel, previousHash] of Object.entries(previousManifest?.files ?? {})) {
+        if (srcFileSet.has(rel))
+            continue;
+        const dstPath = path.join(dstDir, rel);
+        const currentHash = await hashFile(dstPath).catch(() => null);
+        if (currentHash !== previousHash)
+            continue;
+        await fs.rm(dstPath, { force: true });
+        deletedRels.push(rel);
+        changed++;
+    }
+    await pruneEmptyParentDirs(dstDir, deletedRels);
+    if (await writeManifestIfChanged(dstDir, srcHashes))
+        changed++;
+    return changed;
+}
+export async function removeSkill(skillName, targets) {
+    const paths = [
+        path.join(targets.agentsDir, skillName),
+        path.join(targets.claudeDir, skillName),
+        path.join(targets.codexDir, skillName),
+    ];
+    for (const p of paths) {
+        await fs.rm(p, { recursive: true, force: true });
+    }
+}
+export async function syncSkills(options) {
+    let changedFiles = 0;
+    let processedSkills = 0;
+    for (const skillName of options.skillNames) {
+        const bundleSkillDir = path.join(options.sourceDir, skillName);
+        const bundleStat = await fs.stat(bundleSkillDir).catch(() => null);
+        if (!bundleStat?.isDirectory())
+            continue;
+        try {
+            changedFiles += await syncDirectoryFiles(bundleSkillDir, path.join(options.agentsDir, skillName));
+            changedFiles += await syncDirectoryFiles(bundleSkillDir, path.join(options.claudeDir, skillName));
+            changedFiles += await syncDirectoryFiles(bundleSkillDir, path.join(options.codexDir, skillName));
+            processedSkills++;
+        }
+        catch (error) {
+            if (!options.onSkillError)
+                throw error;
+            options.onSkillError(skillName, error);
+        }
+    }
+    return { changedFiles, processedSkills };
+}
+//# sourceMappingURL=sync.js.map

package/dist/server/server/orchestration-skills/internal/transaction.d.ts

@@ -0,0 +1,22 @@
+import { type SkillOp, type SkillSelection, type SkillTargets } from "./operations.js";
+export interface SkillsTransaction {
+    /** Convergence stuck. Drop the staged copies. */
+    commit(): Promise<void>;
+    /** Put every captured directory back exactly as it was, then drop the staging. */
+    rollback(): Promise<void>;
+}
+/**
+ * Finishes what an interrupted save started. A transaction directory only exists
+ * while a save is mid-flight, so finding one means the process died between
+ * mutating the directories and committing the selection — the staged copies are
+ * the only place the user's files still exist. Restore them, then drop the
+ * transaction. Anything without our manifest is left where it is.
+ */
+export declare function recoverInterruptedSkillTransactions(targets: SkillTargets, committedSelection: SkillSelection): Promise<void>;
+/**
+ * Captures the managed skill directories so a failed save can put the machine
+ * back exactly as it was — including files the user added inside them, which
+ * re-running an install cannot reconstruct.
+ */
+export declare function beginSkillsTransaction(targets: SkillTargets, previousSelection: SkillSelection, nextSelection: SkillSelection, ops: readonly SkillOp[]): Promise<SkillsTransaction>;
+//# sourceMappingURL=transaction.d.ts.map