@amoree-code/ocean 0.0.0-stage → 1.2.0

package/dist/application/integrations/engine-entry-repair.js

@@ -0,0 +1,105 @@
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { atomicWrite } from "@ocean/core/shared/fs-utils.js";
+import { liveEngineEntry, oceanPath, repoRoot, SYSTEM_DIR, } from "@ocean/core/shared/paths.js";
+// Client configs that may launch Ocean by an absolute path into the kernel (an MCP server entry).
+// When the engine's entry moved (packages/core → packages/harness), an entry written earlier kept
+// the old path and the client's Ocean server failed to start without a word (T-293). Only the
+// engine entry's former locations are rewritten, and only while they no longer exist — another
+// kernel package's server that is merely not built yet is never touched; the files are otherwise
+// left byte for byte. The release build's entry (T-294, removed in T-306) is repointed to the
+// checkout even while it still exists, so no client keeps running a release.
+// Where the engine's `dist/main.js` lived before it moved to packages/harness.
+const FORMER_ENGINE_PACKAGES = ["core"];
+const CLIENT_CONFIGS = [
+    ".gemini/settings.json",
+    ".hermes/config.yaml",
+    ".codex/config.toml",
+    ".claude.json",
+    ".cursor/mcp.json",
+    ".gemini/antigravity/mcp_config.json",
+    // Claude Desktop: macOS, then Windows.
+    "Library/Application Support/Claude/claude_desktop_config.json",
+    "AppData/Roaming/Claude/claude_desktop_config.json",
+];
+// The always-on service's start files as `ocean setup` writes them (macOS, Linux, Windows). An
+// updated one needs the service restarted to take effect (T-305).
+const SERVICE_FILES = [
+    "Library/LaunchAgents/com.ocean.runtime.plist",
+    ".config/systemd/user/ocean.service",
+    "AppData/Roaming/Microsoft/Windows/Start Menu/Programs/Startup/ocean.cmd",
+];
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+// A JSON config stores a Windows path with every backslash escaped, so a path is searched in
+// both spellings and replaced in the spelling it was found in. On POSIX the two are the same.
+function asJson(value) {
+    return JSON.stringify(value).slice(1, -1);
+}
+export async function repairEngineEntries(home = os.homedir()) {
+    const entry = liveEngineEntry();
+    const results = [];
+    // Without a built entry there is nothing correct to point at.
+    if (!existsSync(entry))
+        return results;
+    const releaseEntry = oceanPath(SYSTEM_DIR, "runtime", "release", "current", "packages", "harness", "dist", "main.js");
+    const targets = [
+        ...FORMER_ENGINE_PACKAGES.map((name) => path.join(repoRoot(), "packages", name, "dist", "main.js")),
+        releaseEntry,
+    ];
+    const stale = new RegExp([...new Set(targets.flatMap((target) => [target, asJson(target)]))]
+        .map(escapeRegExp)
+        .join("|"), "g");
+    const pathOf = (found) => targets.find((target) => target === found || asJson(target) === found) ??
+        found;
+    const files = [
+        ...CLIENT_CONFIGS.map((relative) => ({
+            relative,
+            kind: "client",
+        })),
+        ...SERVICE_FILES.map((relative) => ({
+            relative,
+            kind: "service",
+        })),
+    ];
+    for (const { relative, kind } of files) {
+        const file = path.join(home, relative);
+        const display = `~/${relative}`;
+        let text;
+        try {
+            text = await readFile(file, "utf8");
+        }
+        catch (error) {
+            // A config that exists but cannot be read is said so, never passed off as absent.
+            const missing = error.code === "ENOENT";
+            results.push({
+                file: display,
+                kind,
+                status: missing ? "missing" : "unreadable",
+                replaced: [],
+            });
+            continue;
+        }
+        const hits = [
+            ...new Set([...text.matchAll(stale)].map((match) => match[0])),
+        ].filter((found) => {
+            const target = pathOf(found);
+            return (target !== entry && (target === releaseEntry || !existsSync(target)));
+        });
+        const replaced = [...new Set(hits.map(pathOf))];
+        if (!replaced.length) {
+            results.push({ file: display, kind, status: "current", replaced });
+            continue;
+        }
+        let next = text;
+        for (const found of hits)
+            next = next.replaceAll(found, found === pathOf(found) ? entry : asJson(entry));
+        await atomicWrite(file, next);
+        results.push({ file: display, kind, status: "updated", replaced });
+    }
+    return results;
+}
+//# sourceMappingURL=engine-entry-repair.js.map

package/dist/application/integrations/skill-filter.js

@@ -0,0 +1,254 @@
+import { mkdir, readdir, readFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { claudeHiddenSkills, readHermesDisabled, } from "@ocean/context/context/context-cost.js";
+import { atomicWrite } from "@ocean/core/shared/fs-utils.js";
+import { oceanPath, SYSTEM_DIR } from "@ocean/core/shared/paths.js";
+// The owner hides skills from Claude's model with `skillOverrides` (`off`,
+// `user-invocable-only`). Codex, Gemini and Hermes have no such setting and load every installed
+// skill's description on every request, so `ocean client sync` disables the same skills there:
+// a generated block of `[[skills.config]] enabled = false` entries in ~/.codex/config.toml, and
+// names in `skills.disabled` of ~/.gemini/settings.json and ~/.hermes/config.yaml. None of them
+// can then use the skill at all, even explicitly; un-hiding it in Claude re-enables it on the
+// next sync.
+const BEGIN = "# ocean:skill-filter:begin — generated by `ocean client sync` from Claude's skillOverrides; edit those, not this";
+const END = "# ocean:skill-filter:end";
+// SKILL.md files directly under `root/<dir>/`, plus one category level deeper when `nested`.
+async function installedSkills(root, nested) {
+    const found = [];
+    let entries;
+    try {
+        entries = (await readdir(root)).sort();
+    }
+    catch {
+        return found;
+    }
+    for (const entry of entries) {
+        if (entry.startsWith(".") && !nested)
+            continue;
+        const file = path.join(root, entry, "SKILL.md");
+        let text;
+        try {
+            text = await readFile(file, "utf8");
+        }
+        catch {
+            if (nested)
+                found.push(...(await installedSkills(path.join(root, entry), false)));
+            continue;
+        }
+        const name = /^name:[ \t]*["']?([^"'\r\n]+?)["']?[ \t]*$/m.exec(text.split(/\r?\n---/)[0] ?? "")?.[1] ?? entry;
+        found.push({ name, file });
+    }
+    return found;
+}
+function codexBlock(files) {
+    const entries = files.map((file) => `[[skills.config]]\npath = ${JSON.stringify(file)}\nenabled = false\n`);
+    return `${BEGIN}\n${entries.join("\n")}${END}\n`;
+}
+async function syncCodex(home, hidden) {
+    const file = path.join(home, ".codex", "config.toml");
+    const display = "~/.codex/config.toml";
+    let text;
+    try {
+        text = await readFile(file, "utf8");
+    }
+    catch {
+        return { client: "codex", file: display, status: "missing", disabled: 0 };
+    }
+    const skills = [
+        ...(await installedSkills(path.join(home, ".codex", "skills"), true)),
+        ...(await installedSkills(path.join(home, ".agents", "skills"), false)),
+    ];
+    const files = skills
+        .filter((skill) => hidden.has(skill.name))
+        .map((skill) => skill.file);
+    const start = text.indexOf(BEGIN);
+    const end = start === -1 ? -1 : text.indexOf(END, start);
+    const hasBlock = start !== -1 && end > start;
+    const block = files.length ? codexBlock(files) : "";
+    let next;
+    if (hasBlock) {
+        const after = text.slice(end + END.length).replace(/^\r?\n/, "");
+        next = `${text.slice(0, start)}${block}${after}`;
+    }
+    else if (block) {
+        next = `${text}${text.endsWith("\n") || !text ? "" : "\n"}\n${block}`;
+    }
+    else
+        next = text;
+    if (next === text)
+        return {
+            client: "codex",
+            file: display,
+            status: "current",
+            disabled: files.length,
+        };
+    await atomicWrite(file, next);
+    return {
+        client: "codex",
+        file: display,
+        status: "updated",
+        disabled: files.length,
+    };
+}
+function statePath() {
+    return oceanPath(SYSTEM_DIR, "state", "skill-filter.json");
+}
+async function readState() {
+    try {
+        const parsed = JSON.parse(await readFile(statePath(), "utf8"));
+        return parsed && typeof parsed === "object" ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+// Names Ocean put into a client's list, so un-hiding a skill in Claude takes it back out without
+// touching the ones the owner disabled himself.
+async function readAdded(client) {
+    const list = (await readState())[client];
+    return new Set(Array.isArray(list)
+        ? list.filter((name) => typeof name === "string")
+        : []);
+}
+// Records one client's added names, keeping the other clients' entries.
+async function recordAdded(client, added, previous) {
+    if (JSON.stringify(added) === JSON.stringify([...previous].sort()))
+        return;
+    await mkdir(path.dirname(statePath()), { recursive: true });
+    await atomicWrite(statePath(), `${JSON.stringify({ ...(await readState()), [client]: added }, null, 2)}\n`);
+}
+// The owner's own entries first, then the hidden skills Ocean adds (never twice).
+function mergeDisabled(current, previous, wanted) {
+    const owners = current.filter((name) => !previous.has(name));
+    const added = wanted.filter((name) => !owners.includes(name));
+    return { next: [...owners, ...added], added };
+}
+async function syncGemini(home, hidden) {
+    const file = path.join(home, ".gemini", "settings.json");
+    const display = "~/.gemini/settings.json";
+    let text;
+    try {
+        text = await readFile(file, "utf8");
+    }
+    catch {
+        return { client: "gemini", file: display, status: "missing", disabled: 0 };
+    }
+    let settings;
+    try {
+        const parsed = JSON.parse(text);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            throw new Error("not an object");
+        settings = parsed;
+    }
+    catch {
+        return {
+            client: "gemini",
+            file: display,
+            status: "unparseable",
+            disabled: 0,
+        };
+    }
+    const installed = new Set([
+        ...(await installedSkills(path.join(home, ".gemini", "skills"), false)),
+        ...(await installedSkills(path.join(home, ".agents", "skills"), false)),
+    ].map((skill) => skill.name));
+    const wanted = [...hidden].filter((name) => installed.has(name)).sort();
+    const skills = settings.skills && typeof settings.skills === "object"
+        ? settings.skills
+        : {};
+    const current = Array.isArray(skills.disabled)
+        ? skills.disabled.filter((name) => typeof name === "string")
+        : [];
+    const previous = await readAdded("gemini");
+    const { next, added } = mergeDisabled(current, previous, wanted);
+    const record = () => recordAdded("gemini", added, previous);
+    if (JSON.stringify(next) === JSON.stringify(current)) {
+        await record();
+        return {
+            client: "gemini",
+            file: display,
+            status: "current",
+            disabled: wanted.length,
+        };
+    }
+    const updated = { ...settings, skills: { ...skills, disabled: next } };
+    await atomicWrite(file, `${JSON.stringify(updated, null, 2)}\n`);
+    await record();
+    return {
+        client: "gemini",
+        file: display,
+        status: "updated",
+        disabled: wanted.length,
+    };
+}
+export async function syncSkillFilter(home = os.homedir()) {
+    const hidden = await claudeHiddenSkills(home);
+    return [
+        await syncCodex(home, hidden),
+        await syncGemini(home, hidden),
+        await syncHermes(home, hidden),
+    ];
+}
+// Hermes reads `skills.disabled` from ~/.hermes/config.yaml. Only that key is rewritten, line by
+// line; a shape the reader does not understand is reported, never rewritten.
+async function syncHermes(home, hidden) {
+    const file = path.join(home, ".hermes", "config.yaml");
+    const display = "~/.hermes/config.yaml";
+    let text;
+    try {
+        text = await readFile(file, "utf8");
+    }
+    catch {
+        return { client: "hermes", file: display, status: "missing", disabled: 0 };
+    }
+    const parsed = readHermesDisabled(text);
+    if (!parsed)
+        return {
+            client: "hermes",
+            file: display,
+            status: "unparseable",
+            disabled: 0,
+        };
+    const installed = new Set((await installedSkills(path.join(home, ".hermes", "skills"), true)).map((skill) => skill.name));
+    const wanted = [...hidden].filter((name) => installed.has(name)).sort();
+    const previous = await readAdded("hermes");
+    const { next, added } = mergeDisabled(parsed.names, previous, wanted);
+    const record = () => recordAdded("hermes", added, previous);
+    const result = (status) => ({
+        client: "hermes",
+        file: display,
+        status,
+        disabled: wanted.length,
+    });
+    // Same names in another order is not a change: the owner's file is left as written.
+    if (next.length === parsed.names.length &&
+        next.every((name) => parsed.names.includes(name))) {
+        await record();
+        return result("current");
+    }
+    const { indent, lines } = parsed;
+    const quote = (name) => /^[\w.-]+$/.test(name) ? name : JSON.stringify(name);
+    const block = next.length
+        ? [`${indent}disabled:`, ...next.map((name) => `${indent}- ${quote(name)}`)]
+        : [`${indent}disabled: []`];
+    let updated;
+    if (parsed.disabled) {
+        const [from, to] = parsed.disabled;
+        updated = [...lines.slice(0, from), ...block, ...lines.slice(to)];
+    }
+    else if (parsed.skills >= 0)
+        updated = [
+            ...lines.slice(0, parsed.skills + 1),
+            ...block,
+            ...lines.slice(parsed.skills + 1),
+        ];
+    else {
+        const body = lines.at(-1) === "" ? lines.slice(0, -1) : lines;
+        updated = [...body, "skills:", ...block, ""];
+    }
+    await atomicWrite(file, updated.join("\n"));
+    await record();
+    return result("updated");
+}
+//# sourceMappingURL=skill-filter.js.map