@ccoalm/ccl-skills 0.15.1 → 0.15.2

package/dist/codex-host.js

@@ -1,10 +1,10 @@
 import { spawnSync } from "node:child_process";
-import { existsSync } from "node:fs";
+import { existsSync, mkdtempSync, rmSync, statSync } from "node:fs";
+import { tmpdir } from "node:os";
 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";
-import { probeHostVersion } from "./host-probe.js";
+import { assertSafeRoot, canonicalAlias } from "./fs-safe.js";
+import { probeHostCommand } from "./host-probe.js";
 function call(args, codexHome) {
     const env = {
         ...process.env,
@@ -17,17 +17,41 @@ function call(args, codexHome) {
     });
 }
 export function checkHost(codexHome) {
-    const p = probeHostVersion("codex", { ...process.env, ...(codexHome ? { CODEX_HOME: codexHome } : {}) });
-    if (!p.ok)
-        return p;
-    const version = parseVersion(p.output);
-    if (!version || compare(version, "0.133.0") < 0)
-        return {
-            ok: false,
-            kind: "old",
-            message: "Codex >=0.133.0 is required",
-        };
-    return { ok: true, version };
+    const targetHome = codexHome || process.env.CODEX_HOME || join(process.env.HOME || "", ".codex");
+    try {
+        assertSafeRoot(targetHome, join(targetHome, "ccl-skills-npm"));
+        try {
+            if (!statSync(targetHome).isDirectory())
+                throw new Error(`Codex home is not a directory: ${targetHome}`);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+    }
+    catch (error) {
+        return { ok: false, kind: "safety-refusal", message: String(error) };
+    }
+    // Codex refuses a nonexistent CODEX_HOME. Probe the binary against a private
+    // empty home without creating the user's target just to discover capability.
+    const temporaryHome = existsSync(targetHome) ? null : mkdtempSync(join(tmpdir(), "ccl-codex-probe-"));
+    try {
+        const env = { ...process.env, CODEX_HOME: temporaryHome || targetHome };
+        const marketplace = probeHostCommand("codex", ["plugin", "marketplace", "list"], env);
+        if (!marketplace.ok)
+            return marketplace;
+        const plugins = probeHostCommand("codex", ["plugin", "list"], env);
+        if (!plugins.ok)
+            return plugins;
+        const parsed = parseMarketplace(marketplace.stdout);
+        if (!parsed.ok || !parsePluginList(plugins.stdout, parsed.source).ok)
+            return { ok: false, kind: "state-unknown", message: "Codex public state could not be verified" };
+        return { ok: true };
+    }
+    finally {
+        if (temporaryHome)
+            rmSync(temporaryHome, { recursive: true, force: true });
+    }
 }
 export function parsePluginList(text, marketplaceSource) {
     const lines = text.split(/\r?\n/).filter((line) => line.trim());

package/dist/host-probe.d.ts

@@ -1,11 +1,27 @@
+export declare function isHostCommandMissing(command: string, env?: NodeJS.ProcessEnv): boolean;
 export declare function probeHostVersion(command: string, env?: NodeJS.ProcessEnv): {
     ok: false;
     kind: string;
     message: string;
     output?: undefined;
+    stdout?: undefined;
 } | {
     ok: true;
     output: string;
+    stdout: string;
+    kind?: undefined;
+    message?: undefined;
+};
+export declare function probeHostCommand(command: string, args: string[], env?: NodeJS.ProcessEnv): {
+    ok: false;
+    kind: string;
+    message: string;
+    output?: undefined;
+    stdout?: undefined;
+} | {
+    ok: true;
+    output: string;
+    stdout: string;
     kind?: undefined;
     message?: undefined;
 };

package/dist/host-probe.js

@@ -1,8 +1,32 @@
 import { spawnSync } from "node:child_process";
-// Version discovery must not hold up other hosts or wait for interactive input.
+import { accessSync } from "node:fs";
+import { delimiter, resolve } from "node:path";
+// Host discovery must not hold up other hosts or wait for interactive input.
 const HOST_PROBE_TIMEOUT_MS = 10000;
+// Presence only: do not execute a candidate or inspect its configuration.
+export function isHostCommandMissing(command, env = process.env) {
+    const candidates = command.includes("/")
+        ? [command]
+        : (env.PATH ?? "/usr/bin:/bin").split(delimiter).map((dir) => resolve(dir, command));
+    let uncertain = false;
+    for (const candidate of candidates) {
+        try {
+            accessSync(candidate);
+            return false;
+        }
+        catch (error) {
+            const code = error.code;
+            if (code !== "ENOENT" && code !== "ENOTDIR")
+                uncertain = true;
+        }
+    }
+    return !uncertain;
+}
 export function probeHostVersion(command, env = process.env) {
-    const result = spawnSync(command, ["--version"], {
+    return probeHostCommand(command, ["--version"], env);
+}
+export function probeHostCommand(command, args, env = process.env) {
+    const result = spawnSync(command, args, {
         encoding: "utf8",
         env,
         stdio: ["ignore", "pipe", "pipe"],
@@ -17,11 +41,11 @@ export function probeHostVersion(command, env = process.env) {
             ok: false,
             kind,
             message: kind === "timeout"
-                ? `${command} --version timed out after ${HOST_PROBE_TIMEOUT_MS}ms`
+                ? `${command} ${args.join(" ")} timed out after ${HOST_PROBE_TIMEOUT_MS}ms`
                 : kind === "missing"
                     ? `${command} CLI is unavailable (ENOENT)`
-                    : `${command} --version failed (${errorCode || (result.signal ? `signal ${result.signal}` : result.error ? "spawn error" : `exit ${result.status}`)})`,
+                    : `${command} ${args.join(" ")} failed (${errorCode || (result.signal ? `signal ${result.signal}` : result.error ? "spawn error" : `exit ${result.status}`)})`,
         };
     }
-    return { ok: true, output: `${result.stdout}\n${result.stderr}` };
+    return { ok: true, output: `${result.stdout}\n${result.stderr}`, stdout: result.stdout };
 }

package/dist/operations.js

@@ -200,13 +200,24 @@ function cleanupCandidate(path, files, context) {
     removeEmptyTree(path, files);
     return [];
 }
-function resumeJournal(context) {
+function resumeJournal(context, host) {
     const p = paths(context), j = journal(p.journal, p.root);
+    const hostFailure = host.ok ? undefined : { kind: host.kind, message: host.message };
     if (!j)
         return {
             code: 5,
             status: "partial-journal",
             message: "operation journal is malformed",
+            ...(hostFailure ? { details: { hostFailure } } : {}),
+        };
+    if (!host.ok)
+        return {
+            code: 5,
+            status: "partial-journal",
+            message: host.kind === "missing"
+                ? "operation journal retained; restore or reinstall the Codex CLI, then rerun this command"
+                : "operation journal retained; restore readable Codex public plugin state, then rerun this command",
+            details: { hostFailure },
         };
     if (j.step === "committed" || j.step === "journal-unlink-failed") {
         if (j.operation !== "install" && j.operation !== "update")
@@ -274,6 +285,12 @@ function resumeJournal(context) {
         }
     }
     if (j.trashPath && j.snapshot) {
+        if (j.operation === "uninstall" && !exactState(p.codexHome, null, false))
+            return {
+                code: 5,
+                status: "partial",
+                message: "uninstall resume requires absent public state",
+            };
         const trash = contained(p.root, j.trashPath), deleted = j.deletedFiles || [], errors = remainingErrors(trash, j.snapshot, deleted);
         if (errors.length)
             return {
@@ -423,13 +440,16 @@ function doctor(context) {
         return { code: 3, status: "safety-refusal", message: String(error) };
     }
     const host = checkHost(p.codexHome);
-    if (!host.ok)
-        return { code: 4, status: `host-${host.kind}`, message: host.message };
+    if (!host.ok && host.kind === "safety-refusal")
+        return { code: 3, status: host.kind, message: host.message };
+    // Diagnose pending journals first; unreadable public state cannot authorize cleanup.
     if (existsSync(p.journal)) {
-        const repair = resumeJournal(context);
+        const repair = resumeJournal(context, host);
         if (repair)
             return repair;
     }
+    if (!host.ok)
+        return { code: host.kind === "state-unknown" ? 3 : 4, status: `host-${host.kind}`, message: host.message };
     const unknownTrash = existsSync(p.root)
         ? readdirSync(p.root).filter((name) => name.startsWith(".trash-"))
         : [];
@@ -478,13 +498,16 @@ function installOrUpdate(command, options, context) {
         return { code: 3, status: "safety-refusal", message: String(error) };
     }
     const host = checkHost(p.codexHome);
-    if (!host.ok)
-        return { code: 4, status: `host-${host.kind}`, message: host.message };
+    if (!host.ok && host.kind === "safety-refusal")
+        return { code: 3, status: host.kind, message: host.message };
+    // Diagnose pending journals first; unreadable public state cannot authorize cleanup.
     if (existsSync(p.journal)) {
-        const repair = resumeJournal(context);
+        const repair = resumeJournal(context, host);
         if (repair)
             return repair;
     }
+    if (!host.ok)
+        return { code: host.kind === "state-unknown" ? 3 : 4, status: `host-${host.kind}`, message: host.message };
     const problem = conflict(command, context);
     if (problem)
         return problem;
@@ -787,7 +810,10 @@ function uninstall(options, context) {
         return { code: 3, status: "safety-refusal", message: String(error) };
     }
     if (existsSync(p.journal)) {
-        const repair = resumeJournal(context);
+        const host = checkHost(p.codexHome);
+        if (!host.ok && host.kind === "safety-refusal")
+            return { code: 3, status: host.kind, message: host.message };
+        const repair = resumeJournal(context, host);
         if (repair)
             return repair;
     }

package/dist/unified.d.ts

@@ -1,4 +1,4 @@
-import type { PathContext } from "./paths.js";
+import { type PathContext } from "./paths.js";
 import type { Host, Options, Result } from "./types.js";
 export declare function runHostSequence(hosts: Host[], invoke: (host: Host) => Result): Result;
 export declare function runUnified(command: string, options?: Options, codexContext?: PathContext): Result;

package/dist/unified.js

@@ -1,9 +1,11 @@
-import { probeHostVersion } from "./host-probe.js";
+import { isHostCommandMissing, probeHostVersion } from "./host-probe.js";
+import { checkHost } from "./codex-host.js";
 import { existsSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { runClaude } from "./claude-adapter.js";
 import { run as runCodex } from "./operations.js";
 import { runOpenCode } from "./opencode-adapter.js";
+import { paths } from "./paths.js";
 function owned(host) {
     const home = process.env.HOME;
     if (!home)
@@ -53,14 +55,19 @@ export function runUnified(command, options = {}, codexContext = {}) {
         return dispatch(options.host, command, options, codexContext);
     const includeOwned = command === "doctor" || command === "uninstall";
     const candidates = ["claude", "codex", "opencode"].filter((host) => command !== "update" || owned(host));
-    const probes = candidates.map((host) => ({ host, probe: probeHostVersion(host) }));
+    const probes = candidates.map((host) => {
+        const probe = host !== "codex" ? probeHostVersion(host)
+            : isHostCommandMissing(host) ? { ok: false, kind: "missing", message: "codex CLI was not found on PATH" }
+                : checkHost(paths(codexContext).codexHome);
+        return { host, probe };
+    });
     const hosts = probes.filter(({ host, probe }) => probe.ok || probe.kind !== "missing" || (includeOwned && owned(host))).map(({ host }) => host);
     if (!hosts.length)
         return { code: 4, status: "host-missing", message: "no Claude Code, Codex, or OpenCode CLI is available" };
     return runHostSequence(hosts, (host) => {
         const probe = probes.find((entry) => entry.host === host).probe;
-        if (!probe.ok && probe.kind !== "missing")
-            return { code: 4, status: `host-${probe.kind}`, message: probe.message };
+        if (!probe.ok && probe.kind !== "missing" && !(host === "codex" && probe.kind !== "safety-refusal" && existsSync(paths(codexContext).journal)))
+            return { code: probe.kind === "state-unknown" || probe.kind === "safety-refusal" ? 3 : 4, status: probe.kind === "safety-refusal" ? probe.kind : `host-${probe.kind}`, message: probe.message };
         return dispatch(host, command, { ...options, host }, codexContext);
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ccoalm/ccl-skills",
-	"version": "0.15.1",
+	"version": "0.15.2",
   "description": "Reusable workflows that help coding agents plan, build, test, review, and release software — for Claude Code, Codex, and OpenCode",
 	"keywords": ["skills", "agent-skills", "claude", "claude-code", "codex", "opencode", "agent", "ai", "ai-agents", "cli", "anthropic", "developer-tools"],
   "type": "module",