@ccoalm/ccl-skills 0.1.0

package/dist/codex-host.js

@@ -0,0 +1,162 @@
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { isAbsolute, join, resolve } from "node:path";
+import { LEGACY_REF, MARKET, REF } from "./paths.js";
+import { canonicalAlias } from "./fs-safe.js";
+import { compare, parseVersion } from "./version.js";
+function call(args, codexHome) {
+    const env = {
+        ...process.env,
+        ...(codexHome ? { CODEX_HOME: codexHome } : {}),
+    };
+    return spawnSync("codex", args, {
+        encoding: "utf8",
+        env,
+        detached: process.platform !== "win32",
+    });
+}
+export function checkHost(codexHome) {
+    const p = call(["--version"], codexHome);
+    if (p.error || p.status !== 0)
+        return {
+            ok: false,
+            kind: "missing",
+            message: "Codex CLI is missing",
+        };
+    const version = parseVersion(`${p.stdout}\n${p.stderr}`);
+    if (!version || compare(version, "0.133.0") < 0)
+        return {
+            ok: false,
+            kind: "old",
+            message: "Codex >=0.133.0 is required",
+        };
+    return { ok: true, version };
+}
+export function parsePluginList(text, marketplaceSource) {
+    const lines = text.split(/\r?\n/).filter((line) => line.trim());
+    if (lines.length === 0 ||
+        (lines.length === 1 && lines[0] === "No marketplace plugins found."))
+        return { ok: true, plugin: false, legacy: false };
+    const header = /^PLUGIN\s+STATUS\s+VERSION\s+PATH\s*$/;
+    const provenance = /^Marketplace `([^`]+)`$/;
+    const sensitiveRefs = new Set();
+    let plugin = false;
+    let legacy = false;
+    const parseRow = (line, marketplace) => {
+        const row = line.match(/^(\S+)\s{2,}(\S(?:.*\S)?)\s{2,}(\S+)\s{2,}(\/\S.*)$/);
+        if (!row)
+            return false;
+        if (row[1] === REF || row[1] === LEGACY_REF) {
+            if (!["not installed", "installed, enabled", "installed, disabled"].includes(row[2]))
+                return false;
+            if (sensitiveRefs.has(row[1]))
+                return false;
+            sensitiveRefs.add(row[1]);
+            if (marketplace !== null &&
+                ((row[1] === REF && marketplace !== MARKET) ||
+                    (row[1] === LEGACY_REF && marketplace !== "ccl-skills")))
+                return false;
+        }
+        if (row[1] === REF && row[2] === "installed, enabled")
+            plugin = true;
+        if (row[1] === LEGACY_REF && row[2].startsWith("installed,"))
+            legacy = true;
+        return true;
+    };
+    if (header.test(lines[0])) {
+        for (const line of lines.slice(1))
+            if (!parseRow(line, null))
+                return { ok: false, plugin: false, legacy: false };
+        return { ok: true, plugin, legacy };
+    }
+    if (!provenance.test(lines[0]))
+        return { ok: false, plugin: false, legacy: false };
+    const seenMarketplaces = new Set();
+    let index = 0;
+    while (index < lines.length) {
+        const match = lines[index].match(provenance);
+        if (!match || index + 2 >= lines.length)
+            return { ok: false, plugin: false, legacy: false };
+        const marketplace = match[1];
+        if (seenMarketplaces.has(marketplace))
+            return { ok: false, plugin: false, legacy: false };
+        seenMarketplaces.add(marketplace);
+        const manifest = lines[index + 1];
+        if (!isAbsolute(manifest))
+            return { ok: false, plugin: false, legacy: false };
+        if (marketplace === MARKET &&
+            (!marketplaceSource ||
+                canonicalAlias(resolve(manifest)) !==
+                    canonicalAlias(resolve(join(marketplaceSource, ".agents/plugins/marketplace.json")))))
+            return { ok: false, plugin: false, legacy: false };
+        index += 2;
+        if (!header.test(lines[index]))
+            return { ok: false, plugin: false, legacy: false };
+        index++;
+        while (index < lines.length && !provenance.test(lines[index]))
+            if (!parseRow(lines[index++], marketplace))
+                return { ok: false, plugin: false, legacy: false };
+    }
+    return { ok: true, plugin, legacy };
+}
+function parseMarketplace(text) {
+    const lines = text.split(/\r?\n/).filter((line) => line.trim());
+    if (lines.length === 0)
+        return { ok: true, source: null };
+    if (lines.length === 1 && lines[0] === "No plugin marketplaces in scope.")
+        return { ok: true, source: null };
+    if (!/^MARKETPLACE\s+ROOT\s*$/.test(lines[0]))
+        return { ok: false, source: null };
+    let source = null;
+    const seen = new Set();
+    for (const line of lines.slice(1)) {
+        const match = line.match(/^(\S+)\s{2,}(\S.*)$/);
+        if (!match)
+            return { ok: false, source: null };
+        if (seen.has(match[1]))
+            return { ok: false, source: null };
+        seen.add(match[1]);
+        if (match[1] === MARKET) {
+            if (!isAbsolute(match[2]))
+                return { ok: false, source: null };
+            source = resolve(match[2]);
+        }
+    }
+    return { ok: true, source };
+}
+export function publicState(codexHome) {
+    const empty = {
+        marketplace: false,
+        marketplaceSource: null,
+        plugin: false,
+        legacy: false,
+        marketplaceOutput: "",
+        pluginOutput: "",
+    };
+    if (!existsSync(codexHome))
+        return { status: "known", ...empty };
+    const marketplace = call(["plugin", "marketplace", "list"], codexHome);
+    const plugins = call(["plugin", "list"], codexHome);
+    const marketplaceOutput = `${marketplace.stdout}${marketplace.stderr}`;
+    const pluginOutput = `${plugins.stdout}${plugins.stderr}`;
+    const parsed = parseMarketplace(`${marketplace.stdout}`);
+    const parsedPlugins = parsePluginList(`${plugins.stdout}`, parsed.source);
+    if (marketplace.status !== 0 ||
+        plugins.status !== 0 ||
+        !parsed.ok ||
+        !parsedPlugins.ok)
+        return { status: "unknown", ...empty, marketplaceOutput, pluginOutput };
+    return {
+        status: "known",
+        marketplace: parsed.source !== null,
+        marketplaceSource: parsed.source,
+        plugin: parsedPlugins.plugin,
+        legacy: parsedPlugins.legacy,
+        marketplaceOutput,
+        pluginOutput,
+    };
+}
+export const marketplaceAdd = (path, codexHome) => call(["plugin", "marketplace", "add", path], codexHome);
+export const marketplaceRemove = (codexHome) => call(["plugin", "marketplace", "remove", MARKET], codexHome);
+export const pluginAdd = (codexHome) => call(["plugin", "add", REF], codexHome);
+export const pluginRemove = (codexHome) => call(["plugin", "remove", REF], codexHome);

package/dist/fs-safe.d.ts

@@ -0,0 +1,21 @@
+import type { OwnedFile } from "./types.js";
+export declare const sha256: (path: string) => string;
+export interface FsDependencies {
+    fsync: (fd: number) => void;
+    rename: (from: string, to: string) => void;
+    unlink: (path: string) => void;
+    fault?: (operation: string) => void;
+}
+export declare function fsyncDirectory(path: string, deps?: Partial<FsDependencies>): void;
+export declare function atomicJson(path: string, value: unknown, deps?: Partial<FsDependencies>): void;
+export declare function durableUnlink(path: string, deps?: Partial<FsDependencies>, operation?: string): void;
+export declare function durableRename(from: string, to: string, deps?: Partial<FsDependencies>, operation?: string): void;
+export declare function canonicalAlias(path: string, platform?: NodeJS.Platform): string;
+export declare function assertSafeRoot(codexHome: string, managed: string, createHome?: boolean): void;
+export declare function contained(root: string, rel: string): string;
+export declare function copyRegularTree(src: string, dst: string): OwnedFile[];
+export declare function verifyFiles(root: string, files: OwnedFile[]): string[];
+export declare function verifyTree(root: string, files: OwnedFile[]): string[];
+export declare function deleteOwned(root: string, files: OwnedFile[]): string[];
+export declare function deleteVerifiedTree(root: string, files: OwnedFile[]): string[];
+export declare function acquireLock(path: string): () => void;

package/dist/fs-safe.js

@@ -0,0 +1,241 @@
+import { createHash } from "node:crypto";
+import { closeSync, copyFileSync, existsSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, unlinkSync, writeFileSync, } from "node:fs";
+import { dirname, join, normalize, relative, resolve, sep } from "node:path";
+export const sha256 = (path) => createHash("sha256").update(readFileSync(path)).digest("hex");
+const nativeFs = {
+    fsync: fsyncSync,
+    rename: renameSync,
+    unlink: unlinkSync,
+};
+export function fsyncDirectory(path, deps = {}) {
+    const fs = { ...nativeFs, ...deps };
+    const fd = openSync(path, "r");
+    try {
+        fs.fault?.("parent-dir-fsync");
+        fs.fsync(fd);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code !== "EINVAL" && code !== "ENOTSUP" && code !== "EISDIR")
+            throw error;
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+export function atomicJson(path, value, deps = {}) {
+    const fs = { ...nativeFs, ...deps };
+    mkdirSync(dirname(path), { recursive: true });
+    const tmp = join(dirname(path), `.${relative(dirname(path), path)}.tmp-${process.pid}-${Date.now()}`);
+    const fd = openSync(tmp, "wx", 0o600);
+    try {
+        writeFileSync(fd, `${JSON.stringify(value, null, 2)}\n`);
+        fs.fault?.("temp-file-fsync");
+        fs.fsync(fd);
+    }
+    finally {
+        closeSync(fd);
+    }
+    fs.fault?.("atomic-json-rename");
+    fs.rename(tmp, path);
+    fsyncDirectory(dirname(path), deps);
+}
+export function durableUnlink(path, deps = {}, operation = "durable-unlink") {
+    const fs = { ...nativeFs, ...deps };
+    fs.fault?.(operation);
+    fs.unlink(path);
+    fsyncDirectory(dirname(path), deps);
+}
+export function durableRename(from, to, deps = {}, operation = "durable-rename") {
+    const fs = { ...nativeFs, ...deps };
+    fs.fault?.(operation);
+    fs.rename(from, to);
+    fsyncDirectory(dirname(to), deps);
+}
+export function canonicalAlias(path, platform = process.platform) {
+    const p = resolve(path);
+    if (platform !== "darwin")
+        return p;
+    return p === "/var" || p.startsWith("/var/") || p === "/tmp" || p.startsWith("/tmp/") ? `/private${p}` : p;
+}
+function verifyExistingComponents(path) {
+    const target = resolve(path);
+    const parts = [];
+    let cursor = target;
+    while (!existsSync(cursor)) {
+        parts.push(cursor);
+        const parent = dirname(cursor);
+        if (parent === cursor)
+            break;
+        cursor = parent;
+    }
+    const chain = [];
+    for (let current = cursor;; current = dirname(current)) {
+        chain.push(current);
+        if (dirname(current) === current)
+            break;
+    }
+    for (const component of chain.reverse()) {
+        const expected = canonicalAlias(component), actual = canonicalAlias(realpathSync(component));
+        if (lstatSync(component).isSymbolicLink() && actual !== expected)
+            throw new Error(`symlinked managed component: ${component}`);
+        if (actual !== expected)
+            throw new Error(`non-canonical managed component: ${component}`);
+    }
+    for (const component of parts.reverse())
+        if (existsSync(component)) {
+            const expected = canonicalAlias(component), actual = canonicalAlias(realpathSync(component));
+            if (lstatSync(component).isSymbolicLink() && actual !== expected)
+                throw new Error(`symlinked managed component: ${component}`);
+            if (actual !== expected)
+                throw new Error(`non-canonical managed component: ${component}`);
+        }
+}
+export function assertSafeRoot(codexHome, managed, createHome = false) {
+    const home = resolve(codexHome), root = resolve(managed);
+    if (root !== join(home, "ccl-skills-npm"))
+        throw new Error("managed root is not canonical");
+    verifyExistingComponents(home);
+    if (createHome) {
+        mkdirSync(home, { recursive: true });
+        verifyExistingComponents(home);
+    }
+    verifyExistingComponents(root);
+}
+export function contained(root, rel) {
+    if (!rel || rel.startsWith("/") || normalize(rel).split(sep).includes(".."))
+        throw new Error(`unsafe manifest path: ${rel}`);
+    const p = resolve(root, rel);
+    if (p !== root && !p.startsWith(`${root}${sep}`))
+        throw new Error(`path escape: ${rel}`);
+    return p;
+}
+export function copyRegularTree(src, dst) {
+    const files = [];
+    function walk(s, d, base) {
+        for (const e of readdirSync(s, { withFileTypes: true })) {
+            const a = join(s, e.name), b = join(d, e.name), st = lstatSync(a);
+            if (st.isSymbolicLink() ||
+                (!st.isDirectory() && !st.isFile()) ||
+                (st.isFile() && st.nlink !== 1))
+                throw new Error(`unsafe asset: ${relative(base, a)}`);
+            if (st.isDirectory()) {
+                mkdirSync(b, { recursive: true });
+                walk(a, b, base);
+            }
+            else {
+                mkdirSync(dirname(b), { recursive: true });
+                copyFileSync(a, b);
+                files.push({
+                    path: relative(dst, b),
+                    sha256: sha256(b),
+                    mode: st.mode & 0o777,
+                });
+            }
+        }
+    }
+    mkdirSync(dst, { recursive: true });
+    walk(src, dst, src);
+    return files.sort((a, b) => a.path.localeCompare(b.path));
+}
+export function verifyFiles(root, files) {
+    const errors = [];
+    for (const f of files) {
+        try {
+            const p = contained(root, f.path);
+            if (!existsSync(p)) {
+                errors.push(`${f.path}: missing`);
+                continue;
+            }
+            const st = lstatSync(p);
+            if (!st.isFile() || st.isSymbolicLink() || st.nlink !== 1) {
+                errors.push(`${f.path}: unsafe type`);
+                continue;
+            }
+            if (sha256(p) !== f.sha256)
+                errors.push(`${f.path}: hash mismatch`);
+            if ((st.mode & 0o777) !== f.mode)
+                errors.push(`${f.path}: mode mismatch`);
+        }
+        catch (e) {
+            errors.push(`${f.path}: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    return errors;
+}
+export function verifyTree(root, files) {
+    const errors = verifyFiles(root, files), actual = [];
+    if (!existsSync(root))
+        return ["snapshot: missing"];
+    const walk = (dir) => {
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+            const path = join(dir, entry.name), stat = lstatSync(path), rel = relative(root, path);
+            if (entry.isSymbolicLink() ||
+                (!entry.isDirectory() && !entry.isFile()) ||
+                (entry.isFile() && stat.nlink !== 1))
+                errors.push(`${rel}: unsafe type`);
+            else if (entry.isDirectory())
+                walk(path);
+            else
+                actual.push(rel);
+        }
+    };
+    walk(root);
+    const expected = new Set(files.map((f) => f.path));
+    for (const path of actual)
+        if (!expected.has(path))
+            errors.push(`${path}: unowned`);
+    return errors;
+}
+export function deleteOwned(root, files) {
+    const errors = verifyFiles(root, files);
+    if (errors.length)
+        return errors;
+    for (const f of [...files].sort((a, b) => b.path.length - a.path.length))
+        unlinkSync(contained(root, f.path));
+    const dirs = new Set(files.map((f) => dirname(contained(root, f.path))));
+    for (const d of [...dirs].sort((a, b) => b.length - a.length)) {
+        try {
+            rmSync(d, { recursive: false });
+        }
+        catch { }
+    }
+    return [];
+}
+export function deleteVerifiedTree(root, files) {
+    const errors = verifyTree(root, files);
+    if (errors.length)
+        return errors;
+    const actual = [];
+    const walk = (dir) => {
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+            const path = join(dir, entry.name);
+            const stat = lstatSync(path);
+            if (entry.isSymbolicLink() ||
+                (!entry.isDirectory() && !entry.isFile()) ||
+                (entry.isFile() && stat.nlink !== 1)) {
+                errors.push(`${relative(root, path)}: unsafe type`);
+            }
+            else if (entry.isDirectory())
+                walk(path);
+            else
+                actual.push(relative(root, path));
+        }
+    };
+    walk(root);
+    const expected = new Set(files.map((file) => file.path));
+    for (const path of actual)
+        if (!expected.has(path))
+            errors.push(`${path}: unowned`);
+    if (errors.length)
+        return errors;
+    return deleteOwned(root, files);
+}
+export function acquireLock(path) {
+    mkdirSync(dirname(path), { recursive: true });
+    const fd = openSync(path, "wx", 0o600);
+    return () => {
+        closeSync(fd);
+        rmSync(path, { force: true });
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { runUnified as run } from "./unified.js";
+export type { Result, Options } from "./types.js";

package/dist/index.js

@@ -0,0 +1 @@
+export { runUnified as run } from "./unified.js";

package/dist/manifest.d.ts

@@ -0,0 +1,8 @@
+import type { Manifest, OwnedFile, Release, SnapshotMetadata } from "./types.js";
+export declare class MetadataError extends Error {
+}
+export declare function snapshotIdentity(version: string, ownedFiles: OwnedFile[]): string;
+export declare function readRelease(path: string): Release;
+export declare function readManifest(path: string): Manifest | null;
+export declare function snapshotFor(r: Release, path: string): SnapshotMetadata;
+export declare function manifestFor(r: Release, active: string, previous: SnapshotMetadata | null): Manifest;

package/dist/manifest.js

@@ -0,0 +1,135 @@
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { isAbsolute, normalize, sep } from "node:path";
+export class MetadataError extends Error {
+}
+const HEX40 = /^[0-9a-f]{40}$/, HEX64 = /^[0-9a-f]{64}$/, SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
+function object(value, label) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new MetadataError(`invalid ${label}`);
+    return value;
+}
+function safeRel(value, label) {
+    if (typeof value !== "string" ||
+        !value ||
+        isAbsolute(value) ||
+        normalize(value).split(sep).includes("..") ||
+        value.includes("\\"))
+        throw new MetadataError(`unsafe ${label}`);
+    return value;
+}
+function files(value) {
+    if (!Array.isArray(value) || !value.length)
+        throw new MetadataError("invalid owned files");
+    const seen = new Set();
+    return value
+        .map((raw) => {
+        const f = object(raw, "owned file"), path = safeRel(f.path, "owned path");
+        if (seen.has(path))
+            throw new MetadataError(`duplicate owned path: ${path}`);
+        seen.add(path);
+        if (typeof f.sha256 !== "string" || !HEX64.test(f.sha256))
+            throw new MetadataError(`invalid hash: ${path}`);
+        if (!Number.isInteger(f.mode) ||
+            ![0o600, 0o644, 0o700, 0o755].includes(f.mode))
+            throw new MetadataError(`invalid mode: ${path}`);
+        return { path, sha256: f.sha256, mode: f.mode };
+    })
+        .sort((a, b) => a.path.localeCompare(b.path));
+}
+function parse(path, label) {
+    try {
+        return object(JSON.parse(readFileSync(path, "utf8")), label);
+    }
+    catch (error) {
+        if (error instanceof MetadataError)
+            throw error;
+        throw new MetadataError(`invalid ${label} JSON`);
+    }
+}
+export function snapshotIdentity(version, ownedFiles) {
+    return createHash("sha256")
+        .update(JSON.stringify({ version, files: ownedFiles }))
+        .digest("hex");
+}
+export function readRelease(path) {
+    const r = parse(path, "release");
+    const owned = files(r.files), runtime = files(r.runtime);
+    if (r.schema !== 1 ||
+        r.npmPackage !== "@ccoalm/ccl-skills" ||
+        typeof r.version !== "string" ||
+        !SEMVER.test(r.version) ||
+        typeof r.sourceCommit !== "string" ||
+        !HEX40.test(r.sourceCommit) ||
+        !["clean", "development-dirty"].includes(r.sourceState) ||
+        typeof r.snapshotHash !== "string" ||
+        !HEX64.test(r.snapshotHash) ||
+        snapshotIdentity(r.version, owned) !== r.snapshotHash)
+        throw new MetadataError("invalid release identity");
+    return {
+        schema: 1,
+        npmPackage: r.npmPackage,
+        version: r.version,
+        sourceCommit: r.sourceCommit,
+        sourceState: r.sourceState,
+        files: owned,
+        runtime,
+        snapshotHash: r.snapshotHash,
+    };
+}
+function snapshotRel(value, label) {
+    if (value === null)
+        return null;
+    const rel = safeRel(value, label);
+    if (!/^snapshots\/[0-9a-f]{64}$/.test(rel))
+        throw new MetadataError(`invalid ${label}`);
+    return rel;
+}
+function snapshot(value, label) {
+    if (value === null)
+        return null;
+    const s = object(value, label), path = snapshotRel(s.path, `${label} path`), owned = files(s.ownedFiles);
+    if (!path ||
+        typeof s.version !== "string" ||
+        !SEMVER.test(s.version) ||
+        typeof s.sourceCommit !== "string" ||
+        !HEX40.test(s.sourceCommit) ||
+        !["clean", "development-dirty"].includes(s.sourceState) ||
+        typeof s.snapshotHash !== "string" ||
+        !HEX64.test(s.snapshotHash) ||
+        path.slice(10) !== s.snapshotHash ||
+        snapshotIdentity(s.version, owned) !== s.snapshotHash)
+        throw new MetadataError(`invalid ${label} identity`);
+    return {
+        path,
+        version: s.version,
+        sourceCommit: s.sourceCommit,
+        sourceState: s.sourceState,
+        snapshotHash: s.snapshotHash,
+        ownedFiles: owned,
+    };
+}
+export function readManifest(path) {
+    if (!existsSync(path))
+        return null;
+    const m = parse(path, "manifest");
+    if (m.schema !== 2)
+        throw new MetadataError("invalid manifest schema");
+    const active = snapshot(m.active, "active");
+    if (!active)
+        throw new MetadataError("invalid active snapshot");
+    return { schema: 2, active, previous: snapshot(m.previous, "previous") };
+}
+export function snapshotFor(r, path) {
+    return {
+        path,
+        version: r.version,
+        sourceCommit: r.sourceCommit,
+        sourceState: r.sourceState,
+        snapshotHash: r.snapshotHash,
+        ownedFiles: r.files,
+    };
+}
+export function manifestFor(r, active, previous) {
+    return { schema: 2, active: snapshotFor(r, active), previous };
+}

package/dist/opencode-adapter.d.ts

@@ -0,0 +1,10 @@
+import type { Options, Result } from "./types.js";
+export interface OpenCodeContext {
+    home?: string;
+    assets?: string;
+    env?: NodeJS.ProcessEnv;
+    isInterrupted?: () => boolean;
+    removeRoot?: (path: string) => void;
+    copyShared?: (from: string, to: string) => void;
+}
+export declare function runOpenCode(commandName: string, options?: Options, context?: OpenCodeContext): Result;