@luckypiggy/zhihu-ai-cli 0.1.0-test.1

package/dist/codex-skill.js

@@ -0,0 +1,573 @@
+import { chmodSync, lstatSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, readlinkSync, renameSync, rmdirSync, rmSync, symlinkSync, unlinkSync, writeFileSync, } from "node:fs";
+import { createHash, randomBytes } from "node:crypto";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, parse, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { CLI_VERSION, } from "./contracts.js";
+import { ConfigError, readConfigSnapshot, validateProfile, } from "./config.js";
+export const CODEX_SKILL_NAME = "zhihu-aiops";
+export const CODEX_SKILL_VERSION = CLI_VERSION;
+export const CODEX_SKILL_SCHEMA = "1";
+export const CODEX_SKILL_MARKER = ".zhihu-aiops-install.json";
+/** The package asset allowlist. Keep this list explicit: no directory copy is allowed. */
+export const CODEX_SKILL_FILES = [
+    "SKILL.md",
+    "agents/openai.yaml",
+    "references/commands.md",
+    "references/errors.md",
+    "references/safety.md",
+];
+export class CodexSkillError extends Error {
+    code;
+    exitCode = 2;
+    constructor(code, message) {
+        super(message);
+        this.name = "CodexSkillError";
+        this.code = code;
+    }
+}
+const SOURCE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..", "assets", "codex-skills", CODEX_SKILL_NAME);
+const CONTROL_PATTERN = /[\u0000-\u001f\u007f]/;
+const SHA256_PATTERN = /^[a-f0-9]{64}$/;
+function localError(code, message) {
+    throw new CodexSkillError(code, message);
+}
+function isNotFound(error) {
+    return Boolean(error && typeof error === "object" && "code" in error && error.code === "ENOENT");
+}
+function isDirectoryEntry(path) {
+    try {
+        return lstatSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function sourcePath(file) {
+    return join(SOURCE_ROOT, ...file.split("/"));
+}
+function sha256(data) {
+    return createHash("sha256").update(data).digest("hex");
+}
+function sourceFiles() {
+    const expected = new Set(CODEX_SKILL_FILES);
+    const expectedDirectories = new Set(["agents", "references"]);
+    let rootStat;
+    try {
+        rootStat = lstatSync(SOURCE_ROOT);
+    }
+    catch {
+        localError("CODEX_SKILL_IO_ERROR", "Codex Skill assets are unavailable");
+    }
+    if (rootStat.isSymbolicLink() || !rootStat.isDirectory()) {
+        localError("CODEX_SKILL_SYMLINK", "Codex Skill assets are not a regular directory");
+    }
+    const walk = (directory, prefix) => {
+        let entries;
+        try {
+            entries = readdirSync(directory, { withFileTypes: true });
+        }
+        catch {
+            localError("CODEX_SKILL_IO_ERROR", "Codex Skill assets cannot be read");
+        }
+        for (const entry of entries) {
+            const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+            const full = join(directory, entry.name);
+            if (entry.isSymbolicLink()) {
+                localError("CODEX_SKILL_SYMLINK", "Codex Skill assets contain a symbolic link");
+            }
+            if (entry.isDirectory()) {
+                if (!expectedDirectories.has(rel)) {
+                    localError("CODEX_SKILL_IO_ERROR", "Codex Skill assets contain an unsupported entry");
+                }
+                walk(full, rel);
+                continue;
+            }
+            if (!entry.isFile() || !expected.has(rel)) {
+                localError("CODEX_SKILL_IO_ERROR", "Codex Skill assets contain an unsupported entry");
+            }
+        }
+    };
+    walk(SOURCE_ROOT, "");
+    const output = new Map();
+    for (const file of CODEX_SKILL_FILES) {
+        const path = sourcePath(file);
+        let stat;
+        try {
+            stat = lstatSync(path);
+        }
+        catch {
+            localError("CODEX_SKILL_IO_ERROR", "Codex Skill assets are incomplete");
+        }
+        if (stat.isSymbolicLink())
+            localError("CODEX_SKILL_SYMLINK", "Codex Skill assets contain a symbolic link");
+        if (!stat.isFile())
+            localError("CODEX_SKILL_IO_ERROR", "Codex Skill assets are incomplete");
+        try {
+            output.set(file, readFileSync(path));
+        }
+        catch {
+            localError("CODEX_SKILL_IO_ERROR", "Codex Skill assets cannot be read");
+        }
+    }
+    return output;
+}
+function markerFor(files) {
+    const hashes = {};
+    for (const file of CODEX_SKILL_FILES)
+        hashes[file] = sha256(files.get(file));
+    return {
+        owner: "zhihu-ai-cli",
+        package: "@luckypiggy/zhihu-ai-cli",
+        skill: CODEX_SKILL_NAME,
+        schema: CODEX_SKILL_SCHEMA,
+        schema_version: CODEX_SKILL_SCHEMA,
+        version: CODEX_SKILL_VERSION,
+        files: hashes,
+    };
+}
+function homePath(environment) {
+    const value = environment.HOME?.trim();
+    return resolve(value || homedir());
+}
+function codexHomePath(environment, home) {
+    const value = environment.CODEX_HOME?.trim();
+    return resolve(value || join(home, ".codex"));
+}
+function rejectUnsafeTarget(pathValue, environment) {
+    if (typeof pathValue !== "string" || pathValue.length === 0 || pathValue.length > 4096 || CONTROL_PATTERN.test(pathValue)) {
+        localError("CODEX_SKILL_PATH_INVALID", "Codex Skill target path is invalid");
+    }
+    if (!isAbsolute(pathValue))
+        localError("CODEX_SKILL_PATH_INVALID", "Codex Skill target path must be absolute");
+    const target = resolve(pathValue);
+    if (basename(target) !== CODEX_SKILL_NAME)
+        localError("CODEX_SKILL_PATH_INVALID", "Codex Skill target must end with zhihu-aiops");
+    const home = homePath(environment);
+    const codexHome = codexHomePath(environment, home);
+    const forbidden = new Set([
+        "/",
+        home,
+        codexHome,
+        join(codexHome, "skills"),
+        join(home, ".codex", "skills"),
+    ].map((value) => resolve(value)));
+    if (forbidden.has(target))
+        localError("CODEX_SKILL_PATH_INVALID", "Codex Skill target is a protected directory");
+    return target;
+}
+function basename(pathValue) {
+    const parsed = parse(pathValue);
+    return parsed.base;
+}
+function assertNoSymlinkTarget(pathValue) {
+    try {
+        if (lstatSync(pathValue).isSymbolicLink()) {
+            localError("CODEX_SKILL_SYMLINK", "Codex Skill target is a symbolic link");
+        }
+    }
+    catch (error) {
+        if (error instanceof CodexSkillError)
+            throw error;
+        if (!isNotFound(error))
+            localError("CODEX_SKILL_IO_ERROR", "Codex Skill target cannot be inspected");
+    }
+}
+function profileSkillDirectory(options, environment) {
+    if (options.codexSkillDir !== undefined)
+        return options.codexSkillDir;
+    let snapshot;
+    try {
+        snapshot = readConfigSnapshot(environment, options.profile);
+    }
+    catch (error) {
+        if (error instanceof ConfigError)
+            throw error;
+        localError("CODEX_SKILL_IO_ERROR", "Profile configuration cannot be read");
+    }
+    let profile;
+    try {
+        profile = validateProfile(snapshot.profile);
+    }
+    catch (error) {
+        if (error instanceof ConfigError)
+            throw error;
+        localError("CODEX_SKILL_IO_ERROR", "Profile configuration cannot be read");
+    }
+    return profile.codex_skill_dir;
+}
+export function resolveCodexSkillTarget(options = {}) {
+    const environment = options.environment ?? process.env;
+    const home = homePath(environment);
+    const codexHome = codexHomePath(environment, home);
+    const profileDir = profileSkillDirectory(options, environment);
+    const candidate = options.codexSkillDir
+        ?? profileDir
+        ?? join(codexHome, "skills", CODEX_SKILL_NAME);
+    const target = rejectUnsafeTarget(candidate, environment);
+    assertNoSymlinkTarget(target);
+    return target;
+}
+function markerPath(target) {
+    return join(target, CODEX_SKILL_MARKER);
+}
+function validMarker(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const object = value;
+    const allowedKeys = new Set(["owner", "package", "skill", "schema", "schema_version", "version", "files"]);
+    if (Object.keys(object).some((key) => !allowedKeys.has(key)))
+        return false;
+    if (object.owner !== "zhihu-ai-cli"
+        || object.package !== "@luckypiggy/zhihu-ai-cli"
+        || object.skill !== CODEX_SKILL_NAME
+        || object.schema !== CODEX_SKILL_SCHEMA
+        || object.schema_version !== CODEX_SKILL_SCHEMA
+        || typeof object.version !== "string"
+        || object.version.length < 1
+        || !object.files
+        || typeof object.files !== "object"
+        || Array.isArray(object.files))
+        return false;
+    const files = object.files;
+    const keys = Object.keys(files).sort();
+    const expected = [...CODEX_SKILL_FILES].sort();
+    if (keys.length !== expected.length || keys.some((key, index) => key !== expected[index]))
+        return false;
+    if (keys.some((key) => typeof files[key] !== "string" || !SHA256_PATTERN.test(files[key])))
+        return false;
+    return true;
+}
+function readMarker(target) {
+    const path = markerPath(target);
+    let stat;
+    try {
+        stat = lstatSync(path);
+    }
+    catch (error) {
+        if (isNotFound(error))
+            return null;
+        localError("CODEX_SKILL_IO_ERROR", "Codex Skill marker cannot be inspected");
+    }
+    if (stat.isSymbolicLink())
+        localError("CODEX_SKILL_SYMLINK", "Codex Skill marker is a symbolic link");
+    if (!stat.isFile())
+        localError("CODEX_SKILL_FOREIGN", "Codex Skill target is not managed by this CLI");
+    let value;
+    try {
+        value = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        localError("CODEX_SKILL_FOREIGN", "Codex Skill target is not managed by this CLI");
+    }
+    if (!validMarker(value))
+        localError("CODEX_SKILL_FOREIGN", "Codex Skill target is not managed by this CLI");
+    return value;
+}
+function regularManagedState(target, marker) {
+    let state = "complete";
+    for (const file of CODEX_SKILL_FILES) {
+        const path = join(target, ...file.split("/"));
+        let stat;
+        try {
+            stat = lstatSync(path);
+        }
+        catch (error) {
+            if (!isNotFound(error))
+                localError("CODEX_SKILL_IO_ERROR", "Codex Skill file cannot be inspected");
+            state = "modified";
+            continue;
+        }
+        if (stat.isSymbolicLink())
+            localError("CODEX_SKILL_SYMLINK", "Codex Skill managed file is a symbolic link");
+        if (!stat.isFile()) {
+            state = "modified";
+            continue;
+        }
+        try {
+            if (sha256(readFileSync(path)) !== marker.files[file])
+                state = "modified";
+        }
+        catch {
+            localError("CODEX_SKILL_IO_ERROR", "Codex Skill file cannot be read");
+        }
+    }
+    return state;
+}
+function ensureParent(target) {
+    const parent = dirname(target);
+    try {
+        mkdirSync(parent, { recursive: true, mode: 0o700 });
+    }
+    catch {
+        localError("CODEX_SKILL_IO_ERROR", "Codex Skill target directory cannot be created");
+    }
+    if (!isDirectoryEntry(parent))
+        localError("CODEX_SKILL_IO_ERROR", "Codex Skill target parent is not a directory");
+}
+function temporaryDirectory(parent, label) {
+    try {
+        return mkdtempSync(join(parent, `.${label}.`));
+    }
+    catch {
+        localError("CODEX_SKILL_IO_ERROR", "Codex Skill temporary directory cannot be created");
+    }
+}
+function writeSkillDirectory(destination, files, marker) {
+    try {
+        for (const file of CODEX_SKILL_FILES) {
+            const path = join(destination, ...file.split("/"));
+            mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+            writeFileSync(path, files.get(file), { mode: 0o644 });
+            chmodSync(path, 0o644);
+        }
+        const path = markerPath(destination);
+        writeFileSync(path, `${JSON.stringify(marker, null, 2)}\n`, { mode: 0o600 });
+        chmodSync(path, 0o600);
+    }
+    catch {
+        localError("CODEX_SKILL_IO_ERROR", "Codex Skill files cannot be written");
+    }
+}
+function copyUnknownEntries(source, destination, prefix = "") {
+    let entries;
+    try {
+        entries = readdirSync(source, { withFileTypes: true });
+    }
+    catch {
+        localError("CODEX_SKILL_IO_ERROR", "Existing Codex Skill files cannot be read");
+    }
+    const managed = new Set([...CODEX_SKILL_FILES, CODEX_SKILL_MARKER]);
+    for (const entry of entries) {
+        const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+        if (managed.has(rel))
+            continue;
+        const sourcePathValue = join(source, entry.name);
+        const destinationPath = join(destination, entry.name);
+        let stat;
+        try {
+            stat = lstatSync(sourcePathValue);
+        }
+        catch {
+            localError("CODEX_SKILL_IO_ERROR", "Existing Codex Skill files cannot be inspected");
+        }
+        if (stat.isSymbolicLink()) {
+            try {
+                symlinkSync(readlinkSync(sourcePathValue), destinationPath);
+            }
+            catch {
+                localError("CODEX_SKILL_IO_ERROR", "Existing Codex Skill files cannot be preserved");
+            }
+            continue;
+        }
+        if (stat.isDirectory()) {
+            try {
+                mkdirSync(destinationPath, { recursive: false, mode: 0o700 });
+            }
+            catch {
+                localError("CODEX_SKILL_IO_ERROR", "Existing Codex Skill files cannot be preserved");
+            }
+            copyUnknownEntries(sourcePathValue, destinationPath, rel);
+            continue;
+        }
+        if (!stat.isFile())
+            localError("CODEX_SKILL_IO_ERROR", "Existing Codex Skill files cannot be preserved");
+        try {
+            writeFileSync(destinationPath, readFileSync(sourcePathValue), { mode: 0o644 });
+        }
+        catch {
+            localError("CODEX_SKILL_IO_ERROR", "Existing Codex Skill files cannot be preserved");
+        }
+    }
+}
+function removePathIfPresent(path) {
+    try {
+        rmSync(path, { recursive: true, force: true });
+    }
+    catch {
+        // Cleanup is best effort; the caller reports the primary installation error.
+    }
+}
+function atomicReplace(target, temporary) {
+    const parent = dirname(target);
+    const backup = join(parent, `.${CODEX_SKILL_NAME}.backup-${process.pid}-${randomBytes(6).toString("hex")}`);
+    let oldMoved = false;
+    let newMoved = false;
+    try {
+        renameSync(target, backup);
+        oldMoved = true;
+        renameSync(temporary, target);
+        newMoved = true;
+        removePathIfPresent(backup);
+    }
+    catch {
+        if (newMoved)
+            removePathIfPresent(target);
+        if (oldMoved) {
+            try {
+                renameSync(backup, target);
+            }
+            catch {
+                // The original location is retained if the filesystem refuses recovery.
+            }
+        }
+        removePathIfPresent(temporary);
+        localError("CODEX_SKILL_IO_ERROR", "Codex Skill installation could not be completed");
+    }
+}
+function inspectTarget(target) {
+    let stat;
+    try {
+        stat = lstatSync(target);
+    }
+    catch (error) {
+        if (isNotFound(error))
+            return "missing";
+        localError("CODEX_SKILL_IO_ERROR", "Codex Skill target cannot be inspected");
+    }
+    if (stat.isSymbolicLink())
+        localError("CODEX_SKILL_SYMLINK", "Codex Skill target is a symbolic link");
+    if (!stat.isDirectory())
+        localError("CODEX_SKILL_FOREIGN", "Codex Skill target is not a directory");
+    return "directory";
+}
+export function installCodexSkill(options = {}) {
+    const target = resolveCodexSkillTarget(options);
+    const files = sourceFiles();
+    const marker = markerFor(files);
+    ensureParent(target);
+    const state = inspectTarget(target);
+    if (state === "missing") {
+        const temporary = temporaryDirectory(dirname(target), CODEX_SKILL_NAME);
+        try {
+            writeSkillDirectory(temporary, files, marker);
+            renameSync(temporary, target);
+        }
+        catch {
+            removePathIfPresent(temporary);
+            localError("CODEX_SKILL_IO_ERROR", "Codex Skill installation could not be completed");
+        }
+        return { action: "install", status: "installed", skill: CODEX_SKILL_NAME, version: CODEX_SKILL_VERSION, target };
+    }
+    const existingMarker = readMarker(target);
+    if (!existingMarker)
+        localError("CODEX_SKILL_FOREIGN", "Codex Skill target is not managed by this CLI");
+    const managedState = regularManagedState(target, existingMarker);
+    if (managedState === "modified" && !options.force) {
+        localError("CODEX_SKILL_MODIFIED", "Codex Skill files were modified; use --force to replace them");
+    }
+    const sourceMatches = existingMarker.version === CODEX_SKILL_VERSION
+        && CODEX_SKILL_FILES.every((file) => existingMarker.files[file] === marker.files[file]);
+    if (managedState === "complete" && sourceMatches) {
+        return { action: "install", status: "unchanged", skill: CODEX_SKILL_NAME, version: CODEX_SKILL_VERSION, target };
+    }
+    const temporary = temporaryDirectory(dirname(target), CODEX_SKILL_NAME);
+    try {
+        copyUnknownEntries(target, temporary);
+        writeSkillDirectory(temporary, files, marker);
+    }
+    catch (error) {
+        removePathIfPresent(temporary);
+        throw error;
+    }
+    atomicReplace(target, temporary);
+    return { action: "install", status: "updated", skill: CODEX_SKILL_NAME, version: CODEX_SKILL_VERSION, target };
+}
+function removeManagedFile(path) {
+    let stat;
+    try {
+        stat = lstatSync(path);
+    }
+    catch (error) {
+        if (error instanceof CodexSkillError)
+            throw error;
+        if (isNotFound(error))
+            return false;
+        localError("CODEX_SKILL_IO_ERROR", "Codex Skill file cannot be inspected");
+    }
+    if (stat.isSymbolicLink())
+        localError("CODEX_SKILL_SYMLINK", "Codex Skill managed file is a symbolic link");
+    if (!stat.isFile())
+        return false;
+    try {
+        unlinkSync(path);
+    }
+    catch {
+        localError("CODEX_SKILL_IO_ERROR", "Codex Skill file cannot be removed");
+    }
+    return true;
+}
+function removeEmptyManagedDirectories(target) {
+    for (const directory of ["agents", "references"]) {
+        const path = join(target, directory);
+        try {
+            if (lstatSync(path).isDirectory())
+                rmdirSync(path);
+        }
+        catch (error) {
+            if (error instanceof CodexSkillError)
+                throw error;
+            if (!isNotFound(error) && !(error && typeof error === "object" && "code" in error && error.code === "ENOTEMPTY")) {
+                localError("CODEX_SKILL_IO_ERROR", "Codex Skill directory cannot be removed");
+            }
+        }
+    }
+}
+export function uninstallCodexSkill(options = {}) {
+    const target = resolveCodexSkillTarget(options);
+    const state = inspectTarget(target);
+    if (state === "missing") {
+        return { action: "uninstall", status: "not_found", skill: CODEX_SKILL_NAME, version: CODEX_SKILL_VERSION, target };
+    }
+    const marker = readMarker(target);
+    if (!marker)
+        localError("CODEX_SKILL_FOREIGN", "Codex Skill target is not managed by this CLI");
+    const managedState = regularManagedState(target, marker);
+    if (managedState === "modified" && !options.force) {
+        localError("CODEX_SKILL_MODIFIED", "Codex Skill files were modified; use --force to remove them");
+    }
+    for (const file of CODEX_SKILL_FILES)
+        removeManagedFile(join(target, ...file.split("/")));
+    removeManagedFile(markerPath(target));
+    removeEmptyManagedDirectories(target);
+    let preserved = false;
+    try {
+        rmdirSync(target);
+    }
+    catch (error) {
+        if (error && typeof error === "object" && "code" in error && error.code === "ENOTEMPTY")
+            preserved = true;
+        else if (!isNotFound(error))
+            localError("CODEX_SKILL_IO_ERROR", "Codex Skill directory cannot be removed");
+    }
+    return {
+        action: "uninstall",
+        status: preserved ? "preserved" : "removed",
+        skill: CODEX_SKILL_NAME,
+        version: marker.version,
+        target,
+    };
+}
+/** Read-only status used by `zhihu doctor`; it never changes the target. */
+export function inspectCodexSkill(options = {}) {
+    try {
+        const target = resolveCodexSkillTarget(options);
+        if (inspectTarget(target) === "missing")
+            return { state: "not_found", target };
+        const marker = readMarker(target);
+        if (!marker)
+            return { state: "foreign", target };
+        return { state: regularManagedState(target, marker) === "complete" ? "managed" : "modified", target };
+    }
+    catch (error) {
+        if (error instanceof CodexSkillError) {
+            if (error.code === "CODEX_SKILL_SYMLINK")
+                return { state: "symlink" };
+            if (error.code === "CODEX_SKILL_FOREIGN")
+                return { state: "foreign" };
+            if (error.code === "CODEX_SKILL_MODIFIED")
+                return { state: "modified" };
+        }
+        return { state: "unavailable" };
+    }
+}