@oxygen-agent/cli 1.50.37 → 1.64.5

package/dist/skills.d.ts

@@ -0,0 +1,41 @@
+import { execFileSync } from "node:child_process";
+export type ExecFileSyncLike = typeof execFileSync;
+export type SkillsInstallOptions = {
+    json?: boolean;
+    apiUrl?: string;
+    agents?: string | string[];
+    skill?: string;
+    project?: boolean;
+    copy?: boolean;
+};
+export type SkillsListOptions = {
+    json?: boolean;
+    apiUrl?: string;
+};
+export type SkillsDoctorOptions = {
+    json?: boolean;
+    apiUrl?: string;
+};
+export type AutomaticSkillsInstallResult = {
+    attempted: boolean;
+    ok: boolean;
+    command: string;
+    reason?: string;
+    error?: {
+        code: string;
+        message: string;
+        details?: unknown;
+    };
+};
+export declare function listAgentSkills(options: SkillsListOptions): Promise<Record<string, unknown>>;
+export declare function doctorAgentSkills(options: SkillsDoctorOptions): Promise<Record<string, unknown>>;
+export declare function installAgentSkills(options: SkillsInstallOptions, runtime?: {
+    env?: NodeJS.ProcessEnv;
+    execFileSync?: ExecFileSyncLike;
+}): Record<string, unknown>;
+export declare function runAutomaticSkillsInstall(options?: {
+    apiUrl?: string;
+    env?: NodeJS.ProcessEnv;
+    execFileSync?: ExecFileSyncLike;
+}): AutomaticSkillsInstallResult;
+export declare function skippedAutomaticSkillsInstall(reason: string, apiUrl?: string): AutomaticSkillsInstallResult;

package/dist/skills.js

@@ -0,0 +1,325 @@
+import { execFileSync, spawnSync } from "node:child_process";
+import { existsSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { OxygenError, toFailure } from "@oxygen/shared";
+import { defaultApiUrl, normalizeApiUrl } from "./credentials.js";
+const DEFAULT_SKILL_AGENTS = ["codex", "claude-code", "cursor"];
+const SKILL_INDEX_PATH = "/.well-known/skills/index.json";
+export async function listAgentSkills(options) {
+    const apiUrl = normalizeApiUrl(readOption(options.apiUrl) ?? defaultApiUrl());
+    const indexUrl = skillIndexUrl(apiUrl);
+    const index = await inspectSkillIndex(indexUrl);
+    const installed = detectInstalledAgentSkills();
+    return {
+        index_url: indexUrl,
+        available: {
+            detected: index.reachable,
+            names: index.skill_names,
+            skills: index.skills,
+            ...(index.error ? { error: index.error } : {}),
+        },
+        installed,
+        recommended_install_command: recommendedSkillsInstallCommand(apiUrl),
+        install_command_args: recommendedSkillsInstallArgs(apiUrl),
+    };
+}
+export async function doctorAgentSkills(options) {
+    const apiUrl = normalizeApiUrl(readOption(options.apiUrl) ?? defaultApiUrl());
+    const indexUrl = skillIndexUrl(apiUrl);
+    const index = await inspectSkillIndex(indexUrl);
+    const installer = inspectSkillsInstaller();
+    const installed = detectInstalledAgentSkills();
+    const data = {
+        index_url: indexUrl,
+        index,
+        installer,
+        installed,
+        recommended_install_command: recommendedSkillsInstallCommand(apiUrl),
+        install_command_args: recommendedSkillsInstallArgs(apiUrl),
+    };
+    if (!index.reachable) {
+        throw new OxygenError("skills_index_unreachable", "Oxygen skill index is not reachable.", {
+            details: data,
+            exitCode: 1,
+        });
+    }
+    if (!installer.available) {
+        throw new OxygenError("skills_installer_unavailable", "The local npx installer command is not available.", {
+            details: data,
+            exitCode: 1,
+        });
+    }
+    return data;
+}
+export function installAgentSkills(options, runtime = {}) {
+    const apiUrl = normalizeApiUrl(readOption(options.apiUrl) ?? defaultApiUrl());
+    const indexUrl = skillIndexUrl(apiUrl);
+    const agents = readWords(options.agents ?? DEFAULT_SKILL_AGENTS);
+    const skill = readOption(options.skill) ?? "*";
+    const args = installerAddArgs(indexUrl, agents, skill);
+    if (!options.project)
+        args.push("--global");
+    if (options.copy)
+        args.push("--copy");
+    let output = "";
+    try {
+        const exec = runtime.execFileSync ?? execFileSync;
+        output = String(exec("npx", args, {
+            encoding: "utf8",
+            env: runtime.env ?? process.env,
+            stdio: ["ignore", "pipe", "pipe"],
+        }));
+    }
+    catch (error) {
+        const failure = error;
+        throw new OxygenError("skills_install_failed", "Unable to install Oxygen agent skills.", {
+            details: {
+                index_url: indexUrl,
+                stdout: failure.stdout?.slice(0, 2000) ?? "",
+                stderr: failure.stderr?.slice(0, 2000) ?? failure.message ?? "unknown",
+            },
+            exitCode: 1,
+        });
+    }
+    return {
+        indexUrl,
+        index_url: indexUrl,
+        agents,
+        skill,
+        scope: options.project ? "project" : "global",
+        output,
+    };
+}
+export function runAutomaticSkillsInstall(options = {}) {
+    const apiUrl = normalizeApiUrl(readOption(options.apiUrl) ?? defaultApiUrl());
+    const env = options.env ?? process.env;
+    if (env.OXYGEN_SKIP_SKILLS === "1") {
+        return skippedAutomaticSkillsInstall("OXYGEN_SKIP_SKILLS=1", apiUrl);
+    }
+    const command = recommendedSkillsInstallCommand(apiUrl);
+    try {
+        installAgentSkills({
+            apiUrl,
+            agents: DEFAULT_SKILL_AGENTS,
+            skill: "*",
+            json: true,
+        }, {
+            env,
+            ...(options.execFileSync ? { execFileSync: options.execFileSync } : {}),
+        });
+        return {
+            attempted: true,
+            ok: true,
+            command,
+        };
+    }
+    catch (error) {
+        const failure = toFailure("skills install", error);
+        return {
+            attempted: true,
+            ok: false,
+            command,
+            error: failure.error,
+        };
+    }
+}
+export function skippedAutomaticSkillsInstall(reason, apiUrl = normalizeApiUrl(defaultApiUrl())) {
+    return {
+        attempted: false,
+        ok: true,
+        command: recommendedSkillsInstallCommand(apiUrl),
+        reason,
+    };
+}
+async function inspectSkillIndex(indexUrl) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 10_000);
+    timeout.unref?.();
+    try {
+        const response = await fetch(indexUrl, {
+            headers: { Accept: "application/json" },
+            signal: controller.signal,
+        });
+        const text = await response.text();
+        if (!response.ok) {
+            return emptySkillIndexInspection({
+                status: response.status,
+                error: { code: "http_error", message: `HTTP ${response.status}` },
+            });
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch (error) {
+            return emptySkillIndexInspection({
+                status: response.status,
+                error: {
+                    code: "invalid_json",
+                    message: error instanceof Error ? error.message : "Invalid JSON.",
+                },
+            });
+        }
+        let index;
+        try {
+            index = parseSkillIndex(parsed);
+        }
+        catch (error) {
+            return emptySkillIndexInspection({
+                status: response.status,
+                error: {
+                    code: error instanceof OxygenError ? error.code : "invalid_skill_index",
+                    message: error instanceof Error ? error.message : "Skill index shape is invalid.",
+                },
+            });
+        }
+        return {
+            reachable: true,
+            status: response.status,
+            version: index.version,
+            base_url: index.base_url,
+            skill_names: index.skills.map((skill) => skill.name),
+            skills: index.skills,
+        };
+    }
+    catch (error) {
+        const aborted = error instanceof Error && error.name === "AbortError";
+        return emptySkillIndexInspection({
+            status: null,
+            error: {
+                code: aborted ? "network_timeout" : "network_error",
+                message: error instanceof Error ? error.message : "Unable to reach skill index.",
+            },
+        });
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function emptySkillIndexInspection(input) {
+    return {
+        reachable: false,
+        status: input.status,
+        version: null,
+        base_url: null,
+        skill_names: [],
+        skills: [],
+        error: input.error,
+    };
+}
+function parseSkillIndex(value) {
+    if (!isRecord(value) || !Array.isArray(value.skills)) {
+        throw new OxygenError("invalid_skill_index", "Skill index must include a skills array.", {
+            exitCode: 1,
+        });
+    }
+    const skills = value.skills
+        .map((entry) => {
+        if (!isRecord(entry) || typeof entry.name !== "string" || !entry.name.trim())
+            return null;
+        return {
+            name: entry.name.trim(),
+            title: typeof entry.title === "string" ? entry.title : null,
+            description: typeof entry.description === "string" ? entry.description : null,
+            entrypoint: typeof entry.entrypoint === "string" ? entry.entrypoint : null,
+        };
+    })
+        .filter((entry) => entry !== null);
+    return {
+        version: typeof value.version === "string" ? value.version : null,
+        base_url: typeof value.base_url === "string" ? value.base_url : null,
+        skills,
+    };
+}
+function inspectSkillsInstaller() {
+    const result = spawnSync("npx", ["--version"], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+        timeout: 5000,
+    });
+    const error = result.error instanceof Error ? result.error.message : null;
+    const stdout = typeof result.stdout === "string" ? result.stdout.trim() : "";
+    const stderr = typeof result.stderr === "string" ? result.stderr.trim() : "";
+    return {
+        command_path: "npx",
+        check_args: ["--version"],
+        available: result.status === 0 && !error,
+        version: stdout || null,
+        ...(error ? { error } : {}),
+        ...(stderr ? { stderr: stderr.slice(0, 1000) } : {}),
+    };
+}
+function detectInstalledAgentSkills() {
+    const roots = [
+        { agent: "codex", path: join(process.env.CODEX_HOME ?? join(homedir(), ".codex"), "skills") },
+        { agent: "claude-code", path: join(process.env.CLAUDE_HOME ?? join(homedir(), ".claude"), "skills") },
+        { agent: "cursor", path: join(process.env.CURSOR_HOME ?? join(homedir(), ".cursor"), "skills") },
+        { agent: "project", path: resolve(".agents", "skills") },
+    ];
+    const names = new Set();
+    const locations = [];
+    for (const root of roots) {
+        if (!existsSync(root.path))
+            continue;
+        try {
+            const rootNames = readdirSync(root.path, { withFileTypes: true })
+                .filter((entry) => entry.isDirectory() && entry.name.startsWith("oxygen-"))
+                .map((entry) => entry.name)
+                .sort();
+            for (const name of rootNames)
+                names.add(name);
+            locations.push({ ...root, names: rootNames });
+        }
+        catch {
+            locations.push({ ...root, names: [] });
+        }
+    }
+    return {
+        detected: locations.length > 0,
+        names: [...names].sort(),
+        locations,
+    };
+}
+function skillIndexUrl(apiUrl) {
+    return `${apiUrl}${SKILL_INDEX_PATH}`;
+}
+function recommendedSkillsInstallCommand(apiUrl) {
+    return recommendedSkillsInstallArgs(apiUrl)
+        .map((entry) => entry === "*" ? "'*'" : entry)
+        .join(" ");
+}
+function recommendedSkillsInstallArgs(apiUrl) {
+    const args = ["oxygen", "skills", "install"];
+    if (apiUrl !== normalizeApiUrl(defaultApiUrl())) {
+        args.push("--api-url", apiUrl);
+    }
+    args.push("--agents", ...DEFAULT_SKILL_AGENTS, "--skill", "*", "--json");
+    return args;
+}
+function installerAddArgs(indexUrl, agents, skill) {
+    return [
+        "skills",
+        "add",
+        indexUrl,
+        "--agents",
+        ...agents,
+        "--yes",
+        "--skill",
+        skill,
+        "--full-depth",
+    ];
+}
+function readWords(value) {
+    const text = Array.isArray(value) ? value.join(" ") : value;
+    return text
+        .split(/[,\s]+/)
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+}
+function readOption(value) {
+    return value?.trim() ? value.trim() : null;
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/dist/update.d.ts

@@ -1,4 +1,5 @@
 import { spawnSync } from "node:child_process";
+import { type AutomaticSkillsInstallResult, type ExecFileSyncLike } from "./skills.js";
 type SpawnResult = ReturnType<typeof spawnSync>;
 type SpawnSyncLike = (command: string, args: string[], options: {
     encoding: BufferEncoding;
@@ -18,12 +19,14 @@ export type UpdateResult = {
     command: string;
     dry_run: boolean;
     updated: boolean;
+    skills_install: AutomaticSkillsInstallResult;
 };
 export declare function updateCli(options: UpdateOptions, runtime?: {
     env?: NodeJS.ProcessEnv;
     platform?: NodeJS.Platform;
     modulePath?: string;
     spawnSync?: SpawnSyncLike;
+    execFileSync?: ExecFileSyncLike;
 }): UpdateResult;
 export declare function detectCliInstallPrefix(modulePath?: string): string | null;
 export declare function detectCliInstallPrefixFromPath(modulePath: string): string | null;

package/dist/update.js

@@ -1,7 +1,9 @@
 import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { OXYGEN_VERSION, OxygenError } from "@oxygen/shared";
+import { runAutomaticSkillsInstall, skippedAutomaticSkillsInstall, } from "./skills.js";
 const DEFAULT_CLI_PACKAGE_SPEC = "@oxygen-agent/cli@latest";
+// skipcq: JS-R1005 — handles platform/install-mode/dry-run combinations end-to-end
 export function updateCli(options, runtime = {}) {
     const env = runtime.env ?? process.env;
     const platform = runtime.platform ?? process.platform;
@@ -22,6 +24,7 @@ export function updateCli(options, runtime = {}) {
             command,
             dry_run: true,
             updated: false,
+            skills_install: skippedAutomaticSkillsInstall("dry_run"),
         };
     }
     const attemptedExecutables = [];
@@ -48,6 +51,10 @@ export function updateCli(options, runtime = {}) {
                 command,
                 dry_run: false,
                 updated: true,
+                skills_install: runAutomaticSkillsInstall({
+                    env,
+                    ...(runtime.execFileSync ? { execFileSync: runtime.execFileSync } : {}),
+                }),
             };
         }
         break;

package/node_modules/@oxygen/shared/dist/cell-format.js

@@ -52,6 +52,7 @@ const IDENTIFIER_COLUMN_RE = /(?:^|[^a-z0-9])(phone|mobile|tel(?:ephone)?|fax|zi
  * a value as the absence of a string. Surface-specific concerns (HTML
  * escaping, ellipsis budgets) belong outside this function.
  */
+// skipcq: JS-R1005 — dispatches across cell types + surfaces; branches are intrinsic
 export function formatCellForDisplay(value, column, options) {
     if (value === null || value === undefined || value === "")
         return "";
@@ -198,9 +199,7 @@ function shouldRescueColumn(column) {
     const dataType = readDataType(column);
     if (dataType !== "text" && dataType !== "numeric")
         return false;
-    if (columnLooksLikeIdentifier(column))
-        return false;
-    return true;
+    return !columnLooksLikeIdentifier(column);
 }
 /**
  * Decide whether the same value-level + column-level guards used inside

package/node_modules/@oxygen/shared/dist/index.d.ts

@@ -4,6 +4,7 @@ export * from "./cell-format.js";
 export * from "./column-types.js";
 export * from "./credit-guidance.js";
 export * from "./log.js";
+export * from "./provider-request-outcomes.js";
 export * from "./telemetry.js";
 export type JsonValue = string | number | boolean | null | JsonValue[] | {
     [key: string]: JsonValue;

package/node_modules/@oxygen/shared/dist/index.js

@@ -5,6 +5,7 @@ export * from "./cell-format.js";
 export * from "./column-types.js";
 export * from "./credit-guidance.js";
 export * from "./log.js";
+export * from "./provider-request-outcomes.js";
 export * from "./telemetry.js";
 export class OxygenError extends Error {
     code;

package/node_modules/@oxygen/shared/dist/provider-request-outcomes.d.ts

@@ -0,0 +1,3 @@
+export declare const PROVIDER_REQUEST_OUTCOMES: readonly ["success", "error", "blocked"];
+export type ProviderRequestOutcome = (typeof PROVIDER_REQUEST_OUTCOMES)[number];
+export declare function isProviderRequestOutcome(value: unknown): value is ProviderRequestOutcome;

package/node_modules/@oxygen/shared/dist/provider-request-outcomes.js

@@ -0,0 +1,5 @@
+export const PROVIDER_REQUEST_OUTCOMES = ["success", "error", "blocked"];
+const PROVIDER_REQUEST_OUTCOME_SET = new Set(PROVIDER_REQUEST_OUTCOMES);
+export function isProviderRequestOutcome(value) {
+    return typeof value === "string" && PROVIDER_REQUEST_OUTCOME_SET.has(value);
+}

package/node_modules/@oxygen/shared/dist/version.d.ts

@@ -1 +1 @@
-export declare const OXYGEN_VERSION = "1.50.37";
+export declare const OXYGEN_VERSION = "1.64.5";

package/node_modules/@oxygen/shared/dist/version.js

@@ -1 +1 @@
-export const OXYGEN_VERSION = "1.50.37";
+export const OXYGEN_VERSION = "1.64.5";

package/node_modules/@oxygen/workflows/dist/index.js

@@ -411,11 +411,44 @@ export async function runPureWorkflowFunction(input) {
         const first = issues[0];
         throw new Error(first ? `${first.code}: ${first.message}` : "Invalid workflow function source.");
     }
+    // Cross the host/sandbox boundary as a JSON string, then parse INSIDE the
+    // vm context. If we passed the host object directly its prototype chain
+    // would point at the host's Object/Function, and the regex token blacklist
+    // is trivially bypassed (e.g. "con"+"structor") to reach
+    // __oxygen_context.constructor.constructor === host Function — which is
+    // not affected by the new context's codeGeneration setting and yields
+    // worker-process RCE. Parsing inside the context rebinds the prototype to
+    // the sandboxed Object, so the same walk reaches the sandboxed Function,
+    // which then trips contextCodeGeneration.strings=false below.
     const context = toJsonValue(input.context, "context");
+    const contextJson = JSON.stringify(context);
     const sandbox = Object.create(null);
-    sandbox.__oxygen_context = context;
-    const script = new vm.Script(`"use strict";\nconst __oxygen_fn = (${input.source});\n__oxygen_fn(__oxygen_context);`);
-    const result = script.runInNewContext(sandbox, { timeout: timeoutMs });
+    sandbox.__oxygen_context_json = contextJson;
+    // Shadow dangerous globals on the sandbox surface. Defense-in-depth: the
+    // load-bearing block is contextCodeGeneration; this just removes the
+    // obvious top-level handles.
+    sandbox.Function = undefined;
+    sandbox.eval = undefined;
+    sandbox.setTimeout = undefined;
+    sandbox.setInterval = undefined;
+    sandbox.setImmediate = undefined;
+    sandbox.queueMicrotask = undefined;
+    sandbox.WebAssembly = undefined;
+    const script = new vm.Script(`"use strict";\n`
+        + `const __oxygen_context = JSON.parse(__oxygen_context_json);\n`
+        + `const __oxygen_fn = (${input.source});\n`
+        + `__oxygen_fn(__oxygen_context);`);
+    // Disable dynamic code generation in the sandboxed context. Combined with
+    // the JSON re-parse above, this means every prototype-walk path to
+    // Function — direct, via context.constructor.constructor, or any other
+    // reachable Function instance — throws EvalError when called with source.
+    const result = script.runInNewContext(sandbox, {
+        timeout: timeoutMs,
+        contextCodeGeneration: {
+            strings: false,
+            wasm: false,
+        },
+    });
     const resolved = isPromiseLike(result)
         ? await withTimeout(result, timeoutMs)
         : result;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxygen-agent/cli",
-  "version": "1.50.37",
+  "version": "1.64.5",
   "private": false,
   "license": "UNLICENSED",
   "type": "module",