@amoree-code/ocean 0.0.0-stage → 1.2.0

package/node_modules/@ocean/market/dist/skills/signal-detection.js

@@ -0,0 +1,84 @@
+import { redactRuntimeText } from "@ocean/core/domain/redaction/redaction.js";
+const CORRECTION_PATTERN = /\bno,|\bactually,|\bnot that\b|\binstead of\b|\bshould use\b|\bthat'?s wrong\b/i;
+// biome-ignore lint/suspicious/noControlCharactersInRegex: matching terminal escape sequences
+const ANSI_PATTERN = /\u001b\[[0-?]*[ -/]*[@-~]/g;
+// Runtime chatter (hook_response JSON, terminal redraws) repeats by construction, not by lesson.
+function isRuntimeNoise(text) {
+    if (text.length <= 12)
+        return true;
+    if (!text.startsWith("{"))
+        return false;
+    try {
+        return JSON.parse(text)?.type === "system";
+    }
+    catch {
+        return false;
+    }
+}
+function userInputTexts(events) {
+    return events
+        .filter((event) => event.type === "user_input")
+        .map((event) => ({
+        id: event.eventId,
+        text: redactRuntimeText(event.data).replace(/\s+/g, " ").trim(),
+    }))
+        .filter((event) => event.text.length > 12)
+        .slice(0, 80);
+}
+// True when the user pushed back in this session ("no, use X", "that's wrong").
+export function hasUserCorrection(events) {
+    return userInputTexts(events).some((event) => CORRECTION_PATTERN.test(event.text));
+}
+// What a completed, proven session is worth remembering. Pure: reads events, writes nothing.
+export function detectSessionSignals(events) {
+    const proven = events.filter((event) => event.type === "evidence" && /"result"\s*:\s*"proven"/.test(event.data));
+    if (!proven.length)
+        return [];
+    const outputs = events
+        .filter((event) => ["provider_output", "text", "json"].includes(event.type))
+        .map((event) => ({
+        id: event.eventId,
+        text: redactRuntimeText(event.data)
+            .replace(ANSI_PATTERN, "")
+            .replace(/\s+/g, " ")
+            .trim(),
+    }))
+        .filter((event) => !isRuntimeNoise(event.text))
+        .slice(0, 80);
+    const userInputs = userInputTexts(events);
+    const candidates = [];
+    const decisions = outputs.filter((event) => /\bdecision\s*:/i.test(event.text));
+    if (decisions.length)
+        candidates.push({
+            signalType: "explicit-decision",
+            summary: decisions[0].text.slice(0, 500),
+            refs: decisions.slice(0, 4).map((event) => `event:${event.id}`),
+            confidence: 0.9,
+        });
+    const counts = new Map();
+    for (const event of outputs) {
+        const normalized = event.text.toLocaleLowerCase();
+        const current = counts.get(normalized) ?? { count: 0, refs: [] };
+        current.count += 1;
+        current.refs.push(`event:${event.id}`);
+        counts.set(normalized, current);
+    }
+    const repeated = [...counts.entries()].find(([, value]) => value.count >= 2);
+    if (repeated)
+        candidates.push({
+            signalType: "repeated-procedure",
+            summary: repeated[0].slice(0, 500),
+            refs: repeated[1].refs.slice(0, 4),
+            confidence: 0.8,
+        });
+    const corrections = userInputs.filter((event) => CORRECTION_PATTERN.test(event.text));
+    if (corrections.length)
+        candidates.push({
+            signalType: "repeated-correction",
+            summary: corrections[0].text.slice(0, 500),
+            refs: corrections.slice(0, 4).map((event) => `event:${event.id}`),
+            confidence: 0.7,
+        });
+    return candidates;
+}
+//# sourceMappingURL=signal-detection.js.map

package/node_modules/@ocean/market/dist/skills/skill-hub.js

@@ -0,0 +1,220 @@
+import { createHash } from "node:crypto";
+import { cp, lstat, mkdir, readdir, readFile, readlink, rename, rm, stat, symlink, } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { enginePath, oceanPath, SYSTEM_DIR } from "@ocean/core/shared/paths.js";
+import { clientSkillRoots } from "./core-skill-sync.js";
+// The hub is the one place skills live inside Ocean. Clients hold symlinks into it, so
+// there is a single copy to edit and nothing drifts per client.
+export function skillHubRoot() {
+    return oceanPath(SYSTEM_DIR, "skills");
+}
+async function skillDirectories(root) {
+    const names = [];
+    for (const entry of await readdir(root, { withFileTypes: true })) {
+        // Follow symlinks: a client may expose another store's skills as links.
+        const full = path.join(root, entry.name);
+        const isDirectory = entry.isDirectory() || (await stat(full)).isDirectory();
+        if (!isDirectory)
+            continue;
+        try {
+            await stat(path.join(full, "SKILL.md"));
+            names.push(entry.name);
+        }
+        catch {
+            /* not a skill directory */
+        }
+    }
+    return names.sort();
+}
+// Additive: copies the engine's core skills and any extra source folders into the hub.
+// An existing hub skill is never overwritten.
+export async function populateSkillHub(extraSources = []) {
+    const hub = skillHubRoot();
+    await mkdir(hub, { recursive: true });
+    const added = [];
+    const kept = [];
+    for (const source of [enginePath("skills", "core"), ...extraSources]) {
+        for (const name of await skillDirectories(source)) {
+            const target = path.join(hub, name);
+            try {
+                await lstat(target);
+                kept.push(name);
+            }
+            catch {
+                await cp(path.join(source, name), target, {
+                    recursive: true,
+                    dereference: true,
+                });
+                added.push(name);
+            }
+        }
+    }
+    return { added, kept };
+}
+// Dry run unless `apply`. Skills a client does not already have are only added with `all`:
+// every extra skill costs that client always-on context. A real directory (or a link elsewhere) already at the target is
+// moved into a timestamped backup under the bridge archive before the link is made.
+export async function linkClientSkills(options) {
+    const home = options.home ?? os.homedir();
+    const hub = options.hub ?? skillHubRoot();
+    const backup = path.join(oceanPath(SYSTEM_DIR, "archive"), `skills-backup-${new Date().toISOString().replace(/[:.]/g, "-")}`);
+    const actions = [];
+    let backedUp = false;
+    const names = await skillDirectories(hub);
+    for (const client of Object.keys(clientSkillRoots)) {
+        const root = clientSkillRoots[client](home);
+        try {
+            await stat(root);
+        }
+        catch {
+            continue; // client not installed
+        }
+        for (const skill of names) {
+            const target = path.join(root, skill);
+            const wanted = path.join(hub, skill);
+            let action = "create";
+            try {
+                const info = await lstat(target);
+                if (info.isSymbolicLink() &&
+                    path.resolve(root, await readlink(target)) === wanted) {
+                    action = "linked";
+                }
+                else {
+                    action = "replace";
+                }
+            }
+            catch {
+                /* absent */
+            }
+            if (action === "create" && !options.all)
+                action = "skip";
+            actions.push({ client, skill, action });
+            if (!options.apply || action === "linked" || action === "skip")
+                continue;
+            if (action === "replace") {
+                const saved = path.join(backup, client);
+                await mkdir(saved, { recursive: true });
+                await rename(target, path.join(saved, skill));
+                backedUp = true;
+            }
+            await symlink(wanted, target, "dir");
+        }
+    }
+    return { actions, backup: backedUp ? backup : null };
+}
+// Clients that get the hub's skills as copies. Hermes manages its own bundle and curator,
+// so it is left alone unless asked for by name.
+export const COPY_CLIENTS = [
+    "claude",
+    "codex",
+    "gemini",
+    "hermes",
+];
+// Content hash of a whole skill directory: paths and bytes, so a changed script or reference
+// counts as drift, not only SKILL.md.
+// A symlink inside a skill is refused: copying it would either dereference into data outside
+// the hub or leave a dangling link in the client, and a loop would never finish.
+async function directoryHash(directory) {
+    const hash = createHash("sha256");
+    async function walk(current, prefix) {
+        const entries = (await readdir(current, { withFileTypes: true })).sort((left, right) => left.name.localeCompare(right.name));
+        for (const entry of entries) {
+            const full = path.join(current, entry.name);
+            const relative = path.posix.join(prefix, entry.name);
+            const info = await lstat(full);
+            if (info.isSymbolicLink())
+                throw new Error(`${relative} is a symlink inside a skill`);
+            if (info.isDirectory())
+                await walk(full, relative);
+            else
+                hash.update(relative).update(await readFile(full));
+        }
+    }
+    await walk(directory, "");
+    return hash.digest("hex");
+}
+// Gives every client a real copy of every hub skill, replacing the symlink farm. Dry run
+// unless `apply`. A symlink is only unlinked (its target is untouched); a real directory
+// that differs from the hub is moved into a timestamped backup, never deleted. Anything in a
+// client that the hub does not name is left alone.
+export async function copyClientSkills(options) {
+    const home = options.home ?? os.homedir();
+    const hub = options.hub ?? skillHubRoot();
+    const backup = path.join(options.archive ?? oceanPath(SYSTEM_DIR, "archive"), `skills-backup-${new Date().toISOString().replace(/[:.]/g, "-")}`);
+    const actions = [];
+    let backedUp = false;
+    const names = await skillDirectories(hub);
+    for (const client of options.clients ?? COPY_CLIENTS) {
+        const root = clientSkillRoots[client](home);
+        try {
+            await stat(root);
+        }
+        catch {
+            continue; // client not installed
+        }
+        for (const skill of names) {
+            const target = path.join(root, skill);
+            const source = path.join(hub, skill);
+            try {
+                let action = "create";
+                let info = null;
+                try {
+                    info = await lstat(target);
+                }
+                catch {
+                    /* absent */
+                }
+                const wanted = await directoryHash(source);
+                let ours = false;
+                if (info?.isSymbolicLink()) {
+                    action = "unlink";
+                    // A link into the hub holds nothing of its own. Any other link is moved into the
+                    // backup (the link itself, intact) so what it pointed at stays reachable.
+                    ours = path
+                        .resolve(root, await readlink(target))
+                        .startsWith(hub + path.sep);
+                }
+                else if (info) {
+                    action =
+                        info.isDirectory() && (await directoryHash(target)) === wanted
+                            ? "synchronized"
+                            : "replace";
+                }
+                actions.push({ client, skill, action });
+                if (!options.apply || action === "synchronized")
+                    continue;
+                if (action === "replace" || (action === "unlink" && !ours)) {
+                    const saved = path.join(backup, client);
+                    await mkdir(saved, { recursive: true });
+                    await rename(target, path.join(saved, skill));
+                    backedUp = true;
+                }
+                else if (action === "unlink")
+                    await rm(target);
+                // Copy beside the target and rename, so a failed copy never leaves a half skill.
+                const staging = path.join(root, `.${skill}.copying`);
+                await rm(staging, { recursive: true, force: true });
+                try {
+                    await cp(source, staging, { recursive: true });
+                    await rename(staging, target);
+                }
+                catch (error) {
+                    await rm(staging, { recursive: true, force: true });
+                    throw error;
+                }
+            }
+            catch (error) {
+                // One bad skill must not abort the run halfway through every client.
+                actions.push({
+                    client,
+                    skill,
+                    action: "failed",
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+    }
+    return { actions, backup: backedUp ? backup : null };
+}
+//# sourceMappingURL=skill-hub.js.map

package/node_modules/@ocean/market/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@ocean/market",
+  "version": "1.2.0",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    "./*.js": {
+      "import": "./dist/*.js"
+    }
+  }
+}

package/node_modules/@ocean/services/dist/browser/browser-service.js

@@ -0,0 +1,124 @@
+// Enforces the browser capability's authority/approval policy and drives live
+// verification. This is where operation gating lives — providers only execute what
+// they are asked and report what happened; they never decide whether an action was
+// approved or verified.
+import { browserContracts, } from "@ocean/core/domain/capabilities/browser-contract.js";
+export class BrowserApprovalRequiredError extends Error {
+    constructor(operation, reason) {
+        super(`Browser operation '${operation}' requires owner approval: ${reason}`);
+    }
+}
+function isExternalOrigin(currentUrl, targetUrl) {
+    if (currentUrl === "about:blank")
+        return false;
+    try {
+        return new URL(currentUrl).origin !== new URL(targetUrl).origin;
+    }
+    catch {
+        return true;
+    }
+}
+export class BrowserService {
+    provider;
+    constructor(provider) {
+        this.provider = provider;
+    }
+    detect() {
+        return this.provider.detect();
+    }
+    launch(profileDir, port) {
+        return this.provider.launch(profileDir, port);
+    }
+    connect(launch) {
+        return this.provider.connect(launch);
+    }
+    close(launch) {
+        return this.provider.close(launch);
+    }
+    requireApproval(operation, approved, reason) {
+        const contract = browserContracts[operation];
+        if (contract.approval === "required" && !approved)
+            throw new BrowserApprovalRequiredError(operation, reason);
+    }
+    async navigate(handle, url, options = {}) {
+        const before = await handle.state();
+        const crossOrigin = isExternalOrigin(before.url, url);
+        if (crossOrigin && !options.approved)
+            throw new BrowserApprovalRequiredError("navigate", `destination origin differs from current origin (${before.url} -> ${url})`);
+        const result = await handle.navigate(url, options.timeoutMs);
+        const verified = result.url === url || result.url.startsWith(url);
+        return {
+            operation: "navigate",
+            approved: crossOrigin ? Boolean(options.approved) : true,
+            verified,
+            result,
+        };
+    }
+    async upload(handle, selector, paths, options = {}) {
+        this.requireApproval("upload", Boolean(options.approved), "attaching local files to a page is irreversible from Ocean's point of view");
+        const result = await handle.upload(selector, paths);
+        return {
+            operation: "upload",
+            approved: true,
+            verified: result.attached.length === paths.length,
+            result,
+        };
+    }
+    async download(handle, selector, destinationDir, options = {}) {
+        this.requireApproval("download", Boolean(options.approved), "saving a file to disk is irreversible from Ocean's point of view");
+        const result = await handle.download(selector, destinationDir, options.timeoutMs);
+        return {
+            operation: "download",
+            approved: true,
+            verified: result.size > 0,
+            result,
+        };
+    }
+    async submit(handle, selector, options = {}) {
+        this.requireApproval("submit", Boolean(options.approved), "submitting a form is irreversible from Ocean's point of view");
+        const result = await handle.submit(selector, options.timeoutMs);
+        const verified = result.url !== result.urlBefore || result.bodyAfter !== result.bodyBefore;
+        return { operation: "submit", approved: true, verified, result };
+    }
+    async click(handle, selector, expectation, timeoutMs) {
+        const result = await handle.click(selector, timeoutMs);
+        let verified;
+        if (expectation.kind === "navigates")
+            verified = result.url !== result.urlBefore;
+        else if (expectation.kind === "stays")
+            verified = result.url === result.urlBefore;
+        else
+            verified =
+                (await handle.extract(expectation.selector, null)).count ===
+                    expectation.expected;
+        return { operation: "click", approved: true, verified, result };
+    }
+    async type(handle, selector, text, clear) {
+        const result = await handle.type(selector, text, clear);
+        return {
+            operation: "type",
+            approved: true,
+            verified: result.value.includes(text) || !clear,
+            result,
+        };
+    }
+    async select(handle, selector, value) {
+        const result = await handle.select(selector, value);
+        return {
+            operation: "select",
+            approved: true,
+            verified: result.value === value,
+            result,
+        };
+    }
+    async replaceText(handle, selector, oldText, newText, occurrence = 1) {
+        const result = await handle.replaceText(selector, oldText, newText, occurrence);
+        return {
+            operation: "replace-text",
+            approved: true,
+            verified: result.value.includes(newText),
+            result,
+        };
+    }
+}
+//# sourceMappingURL=browser-service.js.map