@amoree-code/ocean 0.0.0-stage → 1.1.0

package/node_modules/@ocean/market/dist/skills/task-observer.js

@@ -0,0 +1,165 @@
+import { createHash } from "node:crypto";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { redactRuntimeText } from "@ocean/core/domain/redaction/redaction.js";
+import { oceanPath, SYSTEM_DIR } from "@ocean/core/shared/paths.js";
+import { addSkillCandidate } from "./skill-curation.js";
+const observationsFile = () => oceanPath(SYSTEM_DIR, "skills", "observations.json");
+async function load() {
+    try {
+        return JSON.parse(await readFile(observationsFile(), "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+}
+async function save(items) {
+    await mkdir(path.dirname(observationsFile()), { recursive: true });
+    await writeFile(observationsFile(), `${JSON.stringify(items.slice(-200), null, 2)}\n`, { mode: 0o600 });
+}
+function observationId(sessionId, signalType, summary) {
+    return `obs-${createHash("sha256").update(`${sessionId}:${signalType}:${summary}`).digest("hex").slice(0, 16)}`;
+}
+const CORRECTION_PATTERN = /\bno,|\bactually,|\bnot that\b|\binstead of\b|\bshould use\b|\bthat'?s wrong\b/i;
+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(/\s+/g, " ").trim(),
+    }))
+        .filter((event) => event.text.length > 12)
+        .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;
+}
+export async function observeSessionWithStore(store, sessionId) {
+    const session = store.get(sessionId);
+    if (!session)
+        throw new Error(`Session not found: ${sessionId}`);
+    if (session.status !== "completed")
+        return [];
+    const events = store.listEvents(sessionId);
+    const candidates = detectSessionSignals(events);
+    const items = await load();
+    const created = [];
+    for (const candidate of candidates.slice(0, 4)) {
+        const id = observationId(sessionId, candidate.signalType, candidate.summary);
+        if (items.some((item) => item.observationId === id))
+            continue;
+        created.push({
+            observationId: id,
+            sourceSessionId: sessionId,
+            taskId: session.taskId,
+            profileId: session.profile,
+            signalType: candidate.signalType,
+            summary: candidate.summary,
+            evidenceRefs: candidate.refs,
+            confidence: candidate.confidence,
+            status: "observed",
+            createdAt: new Date().toISOString(),
+            reviewedAt: null,
+            skillCandidateId: null,
+        });
+    }
+    if (created.length)
+        await save([...items, ...created]);
+    return created;
+}
+export async function observeSession(sessionId, openStore) {
+    const store = await openStore();
+    try {
+        return await observeSessionWithStore(store, sessionId);
+    }
+    finally {
+        store.close();
+    }
+}
+export async function listObservations() {
+    return load();
+}
+/**
+ * Approving an observation creates the skill candidate it was promising —
+ * reviewObservation used to only flip a status flag with nothing downstream.
+ * A duplicate or invalid candidate (see addSkillCandidate) leaves the
+ * approval standing but skillCandidateId null; the summary is short and
+ * redacted, so this should be rare.
+ */
+export async function reviewObservation(observationIdValue, status) {
+    const items = await load();
+    const item = items.find((candidate) => candidate.observationId === observationIdValue);
+    if (!item)
+        throw new Error(`Observation not found: ${observationIdValue}`);
+    item.status = status;
+    item.reviewedAt = new Date().toISOString();
+    if (status === "approved" && !item.skillCandidateId) {
+        try {
+            const candidate = await addSkillCandidate({
+                id: `learned-${item.observationId.slice(4, 16)}`,
+                name: `Learned: ${item.signalType} (${item.observationId.slice(4, 10)})`,
+                instructions: item.summary,
+                sourceSessionId: item.sourceSessionId,
+            });
+            item.skillCandidateId = candidate.id;
+        }
+        catch {
+            // Duplicate id/name or invalid content — approval stands, no candidate.
+        }
+    }
+    await save(items);
+    return item;
+}
+//# sourceMappingURL=task-observer.js.map

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

@@ -0,0 +1,11 @@
+{
+  "name": "@ocean/market",
+  "version": "1.1.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

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

@@ -0,0 +1,287 @@
+import { randomUUID } from "node:crypto";
+import { mkdir } from "node:fs/promises";
+import { validateSessionEntryContract } from "@ocean/core/domain/sessions/entry-contract.js";
+import { oceanPath, oceanRoot, SYSTEM_DIR } from "@ocean/core/shared/paths.js";
+import { sessionProjectId } from "@ocean/loop/sessions/session-projects.js";
+function safeProfileKey(value) {
+    const key = value.trim();
+    if (!key ||
+        key === "." ||
+        key === ".." ||
+        !/^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/.test(key)) {
+        throw new Error("Browser profile key must contain only letters, numbers, hyphens, and underscores.");
+    }
+    return key;
+}
+function normalizeBrowserUrl(value) {
+    const trimmed = value.trim();
+    const markdown = trimmed.match(/^\[([^\]]+)\]\([^)]*\)$/);
+    return (markdown?.[1] ?? trimmed).trim();
+}
+function parseResumeData(session) {
+    if (session.provider !== "browser" || !session.resumeData)
+        throw new Error(`Browser session is not reconnectable: ${session.sessionId}`);
+    try {
+        const value = JSON.parse(session.resumeData);
+        if (!value.profileDir ||
+            value.port === undefined ||
+            value.pid === undefined ||
+            value.provider !== "playwright")
+            throw new Error("incomplete browser metadata");
+        return value;
+    }
+    catch {
+        throw new Error(`Browser session metadata is invalid: ${session.sessionId}`);
+    }
+}
+export class BrowserSessionManager {
+    store;
+    service;
+    constructor(store, service) {
+        this.store = store;
+        this.service = service;
+    }
+    async detect() {
+        return this.service.detect();
+    }
+    async open(profileKey = "default", port) {
+        const key = safeProfileKey(profileKey);
+        const existing = this.store.list().find((session) => {
+            if (session.provider !== "browser" || session.status !== "running")
+                return false;
+            try {
+                return parseResumeData(session).profileKey === key;
+            }
+            catch {
+                return false;
+            }
+        });
+        if (existing) {
+            this.store.appendEvent(existing.sessionId, "browser_reused", JSON.stringify({
+                profileKey: key,
+                reason: "running-session-for-profile",
+            }));
+            return existing;
+        }
+        const recoverable = this.store.list().find((session) => {
+            if (session.provider !== "browser" || session.status !== "failed")
+                return false;
+            try {
+                return parseResumeData(session).profileKey === key;
+            }
+            catch {
+                return false;
+            }
+        });
+        if (recoverable) {
+            const resume = parseResumeData(recoverable);
+            try {
+                const handle = await this.service.connect(resume);
+                await handle.release();
+                this.store.updateStatus(recoverable.sessionId, "running");
+                this.store.appendEvent(recoverable.sessionId, "browser_recovered", JSON.stringify({ profileKey: key, reason: "endpoint-reachable" }));
+                return this.requireSession(recoverable.sessionId);
+            }
+            catch {
+                // Stale failed session; continue with a new launch below.
+            }
+        }
+        const sessionId = randomUUID();
+        const profileDir = oceanPath(SYSTEM_DIR, "browser", "profiles", key);
+        await mkdir(profileDir, { recursive: true });
+        this.store.create({
+            sessionId,
+            provider: "browser",
+            providerSessionId: `browser:${key}:${sessionId}`,
+            parentSessionId: null,
+            profile: "browser",
+            profileIdentity: "browser-v1",
+            workingDirectory: oceanRoot(),
+            projectId: await sessionProjectId(oceanRoot()),
+            resumeData: null,
+        });
+        this.store.appendEvent(sessionId, "session_entry_contract", JSON.stringify(validateSessionEntryContract({
+            entryPoint: "ocean-run",
+            controlLevel: "full-head",
+            inputCapture: "semantic",
+            contextTransport: "browser-capability-contract",
+            policyEnforcement: "browser-approval-and-post-condition-contract",
+            promotion: "explicit-review",
+            resume: "browser-profile-session",
+        })));
+        // Browser startup is a provider run. Mark it running before launching so a
+        // launch failure can transition legally to failed without weakening the
+        // global session state machine with created -> failed.
+        this.store.updateStatus(sessionId, "running");
+        try {
+            const launch = await this.service.launch(profileDir, port);
+            const resumeData = {
+                ...launch,
+                profileKey: key,
+                provider: "playwright",
+            };
+            this.store.updateStatus(sessionId, "running", JSON.stringify(resumeData));
+            this.store.appendEvent(sessionId, "browser_opened", JSON.stringify({ profileKey: key, port: launch.port, pid: launch.pid }));
+            return this.requireSession(sessionId);
+        }
+        catch (error) {
+            this.store.updateStatus(sessionId, "failed");
+            this.store.appendEvent(sessionId, "error", error instanceof Error ? error.message : String(error));
+            throw error;
+        }
+    }
+    show(sessionId) {
+        return this.requireSession(sessionId);
+    }
+    events(sessionId) {
+        this.requireSession(sessionId);
+        return this.store.listEvents(sessionId);
+    }
+    async close(sessionId) {
+        const session = this.requireSession(sessionId);
+        if (session.status === "completed")
+            return session;
+        const launch = parseResumeData(session);
+        try {
+            await this.service.close(launch);
+            this.store.updateStatus(sessionId, "completed");
+            this.store.appendEvent(sessionId, "browser_closed", JSON.stringify({ pid: launch.pid, port: launch.port }));
+            return this.requireSession(sessionId);
+        }
+        catch (error) {
+            this.store.updateStatus(sessionId, "failed");
+            this.store.appendEvent(sessionId, "error", error instanceof Error ? error.message : String(error));
+            throw error;
+        }
+    }
+    async approve(sessionId) {
+        const session = this.requireSession(sessionId, false);
+        const resume = parseResumeData(session);
+        this.store.updateStatus(sessionId, session.status, JSON.stringify({ ...resume, approved: true }));
+        this.store.appendEvent(sessionId, "browser_session_approved", JSON.stringify({ scope: "session", expires: "on-close" }));
+        return this.requireSession(sessionId);
+    }
+    async navigate(sessionId, url, approved, timeoutMs) {
+        const normalizedUrl = normalizeBrowserUrl(url);
+        return this.withHandle(sessionId, "navigate", (handle) => this.service.navigate(handle, normalizedUrl, {
+            approved: approved || this.isApproved(sessionId),
+            timeoutMs,
+        }));
+    }
+    async read(sessionId) {
+        return this.withHandle(sessionId, "read", (handle) => handle.readText());
+    }
+    async observe(sessionId) {
+        return this.withHandle(sessionId, "observe", (handle) => handle.observe());
+    }
+    async extract(sessionId, selector, attribute) {
+        return this.withHandle(sessionId, "extract", (handle) => handle.extract(selector, attribute));
+    }
+    async click(sessionId, selector, expectation, timeoutMs) {
+        return this.withHandle(sessionId, "click", (handle) => this.service.click(handle, selector, expectation, timeoutMs));
+    }
+    async type(sessionId, selector, text, clear) {
+        return this.withHandle(sessionId, "type", (handle) => this.service.type(handle, selector, text, clear));
+    }
+    async select(sessionId, selector, value) {
+        return this.withHandle(sessionId, "select", (handle) => this.service.select(handle, selector, value));
+    }
+    async replaceText(sessionId, selector, oldText, newText, occurrence) {
+        return this.withHandle(sessionId, "replace-text", (handle) => this.service.replaceText(handle, selector, oldText, newText, occurrence));
+    }
+    async scroll(sessionId, deltaY) {
+        return this.withHandle(sessionId, "scroll", (handle) => handle.scroll(deltaY));
+    }
+    async wait(sessionId, options) {
+        return this.withHandle(sessionId, "wait", (handle) => handle.wait(options));
+    }
+    async upload(sessionId, selector, paths, approved) {
+        return this.withHandle(sessionId, "upload", (handle) => this.service.upload(handle, selector, paths, {
+            approved: approved || this.isApproved(sessionId),
+        }));
+    }
+    async download(sessionId, selector, destinationDir, approved, timeoutMs) {
+        return this.withHandle(sessionId, "download", (handle) => this.service.download(handle, selector, destinationDir, {
+            approved: approved || this.isApproved(sessionId),
+            timeoutMs,
+        }));
+    }
+    async submit(sessionId, selector, approved, timeoutMs) {
+        return this.withHandle(sessionId, "submit", (handle) => this.service.submit(handle, selector, {
+            approved: approved || this.isApproved(sessionId),
+            timeoutMs,
+        }));
+    }
+    async withHandle(sessionId, operationName, operation) {
+        const session = this.requireSession(sessionId, false);
+        const launch = parseResumeData(session);
+        let handle;
+        try {
+            try {
+                handle = await this.service.connect(launch);
+            }
+            catch (error) {
+                this.store.appendEvent(sessionId, "browser_unreachable", JSON.stringify({
+                    error: error instanceof Error ? error.message : String(error),
+                }));
+                throw error;
+            }
+            const result = await operation(handle);
+            this.store.appendEvent(sessionId, "browser_operation", JSON.stringify({
+                operation: operationName,
+                result: summarizeResult(result),
+            }));
+            return result;
+        }
+        catch (error) {
+            this.store.appendEvent(sessionId, "browser_operation_failed", JSON.stringify({
+                error: error instanceof Error ? error.message : String(error),
+            }));
+            throw error;
+        }
+        finally {
+            await handle?.release().catch(() => undefined);
+        }
+    }
+    isApproved(sessionId) {
+        const session = this.requireSession(sessionId, false);
+        try {
+            return parseResumeData(session).approved === true;
+        }
+        catch {
+            return false;
+        }
+    }
+    requireSession(sessionId, allowCompleted = true) {
+        const session = this.store.get(sessionId);
+        if (!session)
+            throw new Error(`Browser session not found: ${sessionId}`);
+        if (session.provider !== "browser")
+            throw new Error(`Session is not a browser session: ${sessionId}`);
+        if (session.status !== "running" &&
+            (!allowCompleted || session.status !== "completed"))
+            throw new Error(`Browser session is not available: ${session.status}`);
+        return session;
+    }
+}
+function summarizeResult(value) {
+    if (!value || typeof value !== "object")
+        return value;
+    const result = value;
+    return {
+        operation: result.operation,
+        approved: result.approved,
+        verified: result.verified,
+        result: result.result && typeof result.result === "object"
+            ? {
+                url: result.result.url,
+                title: result.result.title,
+                size: result.result.size,
+            }
+            : undefined,
+    };
+}
+export function browserDownloadsPath(sessionId) {
+    return oceanPath(SYSTEM_DIR, "browser", "downloads", sessionId);
+}
+//# sourceMappingURL=browser-session.js.map

package/node_modules/@ocean/services/dist/browser/browser-task-runner.js

@@ -0,0 +1,70 @@
+import { readFile } from "node:fs/promises";
+export class BrowserTaskRunner {
+    manager;
+    constructor(manager) {
+        this.manager = manager;
+    }
+    async run(sessionId, task, approved = false) {
+        if (!Array.isArray(task.steps) || task.steps.length === 0)
+            throw new Error("Browser task must contain at least one step.");
+        if (task.steps.length > 100)
+            throw new Error("Browser task exceeds the 100-step limit.");
+        const retries = Math.max(0, Math.min(3, task.retries ?? 0));
+        const results = [];
+        for (const step of task.steps) {
+            let lastError;
+            for (let attempt = 0; attempt <= retries; attempt += 1) {
+                try {
+                    const result = await this.execute(sessionId, step, approved);
+                    if (isUnverified(result))
+                        throw new Error(`Browser step was not verified: ${step.action}`);
+                    results.push(result);
+                    lastError = undefined;
+                    break;
+                }
+                catch (error) {
+                    lastError = error;
+                    if (attempt < retries)
+                        await new Promise((resolve) => setTimeout(resolve, 100 * (attempt + 1)));
+                }
+            }
+            if (lastError)
+                throw lastError;
+        }
+        return { completed: true, steps: results.length, results };
+    }
+    static async fromFile(path) {
+        return JSON.parse(await readFile(path, "utf8"));
+    }
+    execute(sessionId, step, approved) {
+        switch (step.action) {
+            case "navigate":
+                return this.manager.navigate(sessionId, step.url, approved);
+            case "click":
+                return this.manager.click(sessionId, step.selector, {
+                    kind: step.expect ?? "stays",
+                });
+            case "type":
+                return this.manager.type(sessionId, step.selector, step.text, step.clear ?? true);
+            case "select":
+                return this.manager.select(sessionId, step.selector, step.value);
+            case "scroll":
+                return this.manager.scroll(sessionId, step.deltaY ?? 600);
+            case "wait":
+                return this.manager.wait(sessionId, step);
+            case "read":
+                return this.manager.read(sessionId);
+            case "extract":
+                return this.manager.extract(sessionId, step.selector, step.attribute ?? null);
+            case "submit":
+                return this.manager.submit(sessionId, step.selector, approved);
+        }
+    }
+}
+function isUnverified(value) {
+    return Boolean(value &&
+        typeof value === "object" &&
+        "verified" in value &&
+        value.verified === false);
+}
+//# sourceMappingURL=browser-task-runner.js.map