@amoree-code/ocean 0.0.0-stage → 1.2.0

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