comisai 1.0.4

package/node_modules/@comis/skills/dist/browser/playwright-snapshots.js

@@ -0,0 +1,287 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Accessibility snapshot generation.
+ *
+ * Takes accessibility snapshots of web pages using Playwright's
+ * ariaSnapshot() API, producing text representations with element
+ * references (e.g., "e12: button 'Submit'") that agents use to
+ * decide what to interact with.
+ *
+ * Supports "role" format (ariaSnapshot + ref annotation) and
+ * filtering options (interactive-only, compact, selector scoping).
+ *
+ * Ported from Comis browser/pw-role-snapshot.ts +
+ * pw-tools-core.snapshot.ts, simplified without frame handling
+ * or label/image overlay mode.
+ *
+ * @module
+ */
+import { ensurePageState, storeRoleRefs, } from "./playwright-session.js";
+// ── Role Classification ──────────────────────────────────────────────
+const INTERACTIVE_ROLES = new Set([
+    "button",
+    "link",
+    "textbox",
+    "checkbox",
+    "radio",
+    "combobox",
+    "listbox",
+    "menuitem",
+    "menuitemcheckbox",
+    "menuitemradio",
+    "option",
+    "searchbox",
+    "slider",
+    "spinbutton",
+    "switch",
+    "tab",
+    "treeitem",
+]);
+const CONTENT_ROLES = new Set([
+    "heading",
+    "cell",
+    "gridcell",
+    "columnheader",
+    "rowheader",
+    "listitem",
+    "article",
+    "region",
+    "main",
+    "navigation",
+]);
+const STRUCTURAL_ROLES = new Set([
+    "generic",
+    "group",
+    "list",
+    "table",
+    "row",
+    "rowgroup",
+    "grid",
+    "treegrid",
+    "menu",
+    "menubar",
+    "toolbar",
+    "tablist",
+    "tree",
+    "directory",
+    "document",
+    "application",
+    "presentation",
+    "none",
+]);
+// ── Snapshot Building ────────────────────────────────────────────────
+function getIndentLevel(line) {
+    const match = line.match(/^(\s*)/);
+    return match ? Math.floor(match[1].length / 2) : 0;
+}
+function createRoleNameTracker() {
+    const counts = new Map();
+    const refsByKey = new Map();
+    return {
+        counts,
+        refsByKey,
+        getKey(role, name) {
+            return `${role}:${name ?? ""}`;
+        },
+        getNextIndex(role, name) {
+            const key = this.getKey(role, name);
+            const current = counts.get(key) ?? 0;
+            counts.set(key, current + 1);
+            return current;
+        },
+        trackRef(role, name, ref) {
+            const key = this.getKey(role, name);
+            const list = refsByKey.get(key) ?? [];
+            list.push(ref);
+            refsByKey.set(key, list);
+        },
+        getDuplicateKeys() {
+            const out = new Set();
+            for (const [key, refs] of refsByKey) {
+                if (refs.length > 1)
+                    out.add(key);
+            }
+            return out;
+        },
+    };
+}
+function removeNthFromNonDuplicates(refs, tracker) {
+    const duplicates = tracker.getDuplicateKeys();
+    for (const [ref, data] of Object.entries(refs)) {
+        const key = tracker.getKey(data.role, data.name);
+        if (!duplicates.has(key)) {
+            delete refs[ref]?.nth;
+        }
+    }
+}
+function compactTree(tree) {
+    const lines = tree.split("\n");
+    const result = [];
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i];
+        if (line.includes("[ref=")) {
+            result.push(line);
+            continue;
+        }
+        if (line.includes(":") && !line.trimEnd().endsWith(":")) {
+            result.push(line);
+            continue;
+        }
+        const currentIndent = getIndentLevel(line);
+        let hasRelevantChildren = false;
+        for (let j = i + 1; j < lines.length; j += 1) {
+            const childIndent = getIndentLevel(lines[j]);
+            if (childIndent <= currentIndent)
+                break;
+            if (lines[j]?.includes("[ref=")) {
+                hasRelevantChildren = true;
+                break;
+            }
+        }
+        if (hasRelevantChildren)
+            result.push(line);
+    }
+    return result.join("\n");
+}
+function processLine(line, refs, options, tracker, nextRef) {
+    const depth = getIndentLevel(line);
+    if (options.maxDepth !== undefined && depth > options.maxDepth)
+        return null;
+    const match = line.match(/^(\s*-\s*)(\w+)(?:\s+"([^"]*)")?(.*)$/);
+    if (!match)
+        return options.interactive ? null : line;
+    const [, prefix, roleRaw, name, suffix] = match;
+    if (roleRaw.startsWith("/"))
+        return options.interactive ? null : line;
+    const role = roleRaw.toLowerCase();
+    const isInteractive = INTERACTIVE_ROLES.has(role);
+    const isContent = CONTENT_ROLES.has(role);
+    const isStructural = STRUCTURAL_ROLES.has(role);
+    if (options.interactive && !isInteractive)
+        return null;
+    if (options.compact && isStructural && !name)
+        return null;
+    const shouldHaveRef = isInteractive || (isContent && Boolean(name));
+    if (!shouldHaveRef)
+        return line;
+    const ref = nextRef();
+    const nth = tracker.getNextIndex(role, name);
+    tracker.trackRef(role, name, ref);
+    refs[ref] = { role, name, nth };
+    let enhanced = `${prefix}${roleRaw}`;
+    if (name)
+        enhanced += ` "${name}"`;
+    enhanced += ` [ref=${ref}]`;
+    if (nth > 0)
+        enhanced += ` [nth=${nth}]`;
+    if (suffix)
+        enhanced += suffix;
+    return enhanced;
+}
+function buildRoleSnapshotFromAriaSnapshot(ariaSnapshot, options = {}) {
+    const lines = ariaSnapshot.split("\n");
+    const refs = {};
+    const tracker = createRoleNameTracker();
+    let counter = 0;
+    const nextRef = () => {
+        counter += 1;
+        return `e${counter}`;
+    };
+    if (options.interactive) {
+        const result = [];
+        for (const line of lines) {
+            const depth = getIndentLevel(line);
+            if (options.maxDepth !== undefined && depth > options.maxDepth)
+                continue;
+            const match = line.match(/^(\s*-\s*)(\w+)(?:\s+"([^"]*)")?(.*)$/);
+            if (!match)
+                continue;
+            const [, , roleRaw, name, suffix] = match;
+            if (roleRaw.startsWith("/"))
+                continue;
+            const role = roleRaw.toLowerCase();
+            if (!INTERACTIVE_ROLES.has(role))
+                continue;
+            const ref = nextRef();
+            const nth = tracker.getNextIndex(role, name);
+            tracker.trackRef(role, name, ref);
+            refs[ref] = { role, name, nth };
+            let enhanced = `- ${roleRaw}`;
+            if (name)
+                enhanced += ` "${name}"`;
+            enhanced += ` [ref=${ref}]`;
+            if (nth > 0)
+                enhanced += ` [nth=${nth}]`;
+            if (suffix.includes("["))
+                enhanced += suffix;
+            result.push(enhanced);
+        }
+        removeNthFromNonDuplicates(refs, tracker);
+        return {
+            snapshot: result.join("\n") || "(no interactive elements)",
+            refs,
+        };
+    }
+    const result = [];
+    for (const line of lines) {
+        const processed = processLine(line, refs, options, tracker, nextRef);
+        if (processed !== null)
+            result.push(processed);
+    }
+    removeNthFromNonDuplicates(refs, tracker);
+    const tree = result.join("\n") || "(empty)";
+    return {
+        snapshot: options.compact ? compactTree(tree) : tree,
+        refs,
+    };
+}
+function getSnapshotStats(snapshot, refs) {
+    const interactive = Object.values(refs).filter((r) => INTERACTIVE_ROLES.has(r.role)).length;
+    return {
+        lines: snapshot.split("\n").length,
+        chars: snapshot.length,
+        refs: Object.keys(refs).length,
+        interactive,
+    };
+}
+// ── Public API ───────────────────────────────────────────────────────
+/**
+ * Take an accessibility snapshot of a page.
+ *
+ * Uses Playwright's ariaSnapshot() to produce a structured text
+ * representation of the page's accessibility tree, annotated with
+ * element refs (e.g., [ref=e12]) for use in subsequent actions.
+ *
+ * @param page - Playwright Page instance
+ * @param options - Snapshot options (interactive, compact, selector, maxChars)
+ * @returns Snapshot text, ref map, and page metadata
+ */
+export async function takeSnapshot(page, options = {}) {
+    ensurePageState(page);
+    const selector = options.selector?.trim() || "";
+    const locator = selector
+        ? page.locator(selector)
+        : page.locator(":root");
+    const ariaSnapshot = await locator.ariaSnapshot();
+    const built = buildRoleSnapshotFromAriaSnapshot(String(ariaSnapshot ?? ""), options);
+    let { snapshot } = built;
+    let truncated = false;
+    if (options.maxChars &&
+        options.maxChars > 0 &&
+        snapshot.length > options.maxChars) {
+        snapshot = `${snapshot.slice(0, options.maxChars)}\n\n[...TRUNCATED - page too large]`;
+        truncated = true;
+    }
+    // Store role refs on the page for subsequent action resolution
+    storeRoleRefs(page, built.refs, "role");
+    const url = page.url();
+    const title = await page.title().catch(() => "");
+    return {
+        snapshot,
+        refs: built.refs,
+        url,
+        title,
+        ...(truncated ? { truncated } : {}),
+        stats: getSnapshotStats(snapshot, built.refs),
+    };
+}

package/node_modules/@comis/skills/dist/browser/profile-decoration.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Chrome profile decoration.
+ *
+ * Writes Chrome "Local State" and "Default/Preferences" JSON files
+ * to configure profile identity (name, visual appearance).
+ *
+ * All path construction uses safePath() to prevent directory traversal.
+ *
+ * @module
+ */
+import type { Result } from "@comis/shared";
+/** Options for profile decoration. */
+export interface DecorateProfileOptions {
+    /** Profile display name. */
+    name: string;
+    /** Hex color string for visual identity. */
+    color: string;
+}
+/**
+ * Decorate a Chrome profile directory with identity metadata.
+ *
+ * Writes:
+ * - `Local State` JSON with profile name and user_name
+ * - `Default/Preferences` JSON with browser theme defaults
+ *
+ * @param profileDir - Absolute path to the profile's user data directory
+ * @param opts - Profile name and color for decoration
+ * @returns ok(void) on success, err on write failure
+ */
+export declare function decorateProfile(profileDir: string, opts: DecorateProfileOptions): Promise<Result<void, Error>>;

package/node_modules/@comis/skills/dist/browser/profile-decoration.js

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Chrome profile decoration.
+ *
+ * Writes Chrome "Local State" and "Default/Preferences" JSON files
+ * to configure profile identity (name, visual appearance).
+ *
+ * All path construction uses safePath() to prevent directory traversal.
+ *
+ * @module
+ */
+import * as fs from "node:fs";
+import { ok, err } from "@comis/shared";
+import { safePath } from "@comis/core";
+// ── Functions ─────────────────────────────────────────────────────────
+/**
+ * Decorate a Chrome profile directory with identity metadata.
+ *
+ * Writes:
+ * - `Local State` JSON with profile name and user_name
+ * - `Default/Preferences` JSON with browser theme defaults
+ *
+ * @param profileDir - Absolute path to the profile's user data directory
+ * @param opts - Profile name and color for decoration
+ * @returns ok(void) on success, err on write failure
+ */
+export async function decorateProfile(profileDir, opts) {
+    try {
+        // Ensure the profile directory exists
+        await fs.promises.mkdir(profileDir, { recursive: true });
+        // Write Local State JSON
+        const localStatePath = safePath(profileDir, "Local State");
+        const localState = {
+            profile: {
+                info_cache: {
+                    Default: {
+                        name: opts.name,
+                        user_name: `${opts.name}@comis`,
+                    },
+                },
+            },
+        };
+        await fs.promises.writeFile(localStatePath, JSON.stringify(localState, null, 2), "utf-8");
+        // Ensure Default subdirectory exists
+        const defaultDir = safePath(profileDir, "Default");
+        await fs.promises.mkdir(defaultDir, { recursive: true });
+        // Write Default/Preferences JSON
+        const prefsPath = safePath(profileDir, "Default", "Preferences");
+        const preferences = {
+            browser: {
+                theme: { color: -1 },
+            },
+            ntp: {
+                custom_background_dict: {},
+            },
+        };
+        await fs.promises.writeFile(prefsPath, JSON.stringify(preferences, null, 2), "utf-8");
+        return ok(undefined);
+    }
+    catch (e) {
+        return err(e instanceof Error ? e : new Error(String(e)));
+    }
+}

package/node_modules/@comis/skills/dist/browser/profiles-service.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Browser profile manager service.
+ *
+ * Provides CRUD operations for named Chrome profiles with unique CDP
+ * port allocation, color assignment, and directory isolation. Profile
+ * metadata is persisted in a profiles.json file within the profiles
+ * directory.
+ *
+ * All path operations use safePath() to prevent directory traversal.
+ *
+ * @module
+ */
+import type { Result } from "@comis/shared";
+/** Dependencies for creating a profile manager. */
+export interface ProfileManagerDeps {
+    baseCdpPort: number;
+    maxProfiles: number;
+    profilesDir: string;
+    logger: {
+        info(msg: string): void;
+        warn(msg: string): void;
+    };
+}
+/** Information about a registered profile. */
+export interface ProfileInfo {
+    name: string;
+    cdpPort: number;
+    profileDir: string;
+    color: string;
+    index: number;
+}
+/** Profile manager interface for CRUD operations on named profiles. */
+export interface ProfileManager {
+    /** List all registered profiles. */
+    list(): Promise<Result<ProfileInfo[], Error>>;
+    /** Create a new named profile. */
+    create(params: {
+        name: string;
+    }): Promise<Result<ProfileInfo, Error>>;
+    /** Delete (deregister) a profile by name. Does not remove Chrome data. */
+    delete(name: string): Promise<Result<void, Error>>;
+    /** Synchronous lookup of a profile by name from cached state. */
+    resolve(name: string): Result<ProfileInfo, Error>;
+}
+/**
+ * Create a profile manager for named Chrome profiles.
+ *
+ * @param deps - Dependencies including base CDP port, max profiles, directory, and logger
+ * @returns ProfileManager instance
+ */
+export declare function createProfileManager(deps: ProfileManagerDeps): ProfileManager;

package/node_modules/@comis/skills/dist/browser/profiles-service.js

@@ -0,0 +1,137 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Browser profile manager service.
+ *
+ * Provides CRUD operations for named Chrome profiles with unique CDP
+ * port allocation, color assignment, and directory isolation. Profile
+ * metadata is persisted in a profiles.json file within the profiles
+ * directory.
+ *
+ * All path operations use safePath() to prevent directory traversal.
+ *
+ * @module
+ */
+import * as fs from "node:fs";
+import { ok, err } from "@comis/shared";
+import { safePath } from "@comis/core";
+import { validateProfileName, allocateCdpPort, getProfileColor } from "./profiles.js";
+import { decorateProfile } from "./profile-decoration.js";
+// ── Factory ───────────────────────────────────────────────────────────
+/**
+ * Create a profile manager for named Chrome profiles.
+ *
+ * @param deps - Dependencies including base CDP port, max profiles, directory, and logger
+ * @returns ProfileManager instance
+ */
+export function createProfileManager(deps) {
+    let cache = null;
+    function manifestPath() {
+        return safePath(deps.profilesDir, "profiles.json");
+    }
+    async function loadProfiles() {
+        if (cache !== null)
+            return cache;
+        try {
+            const raw = await fs.promises.readFile(manifestPath(), "utf-8");
+            const parsed = JSON.parse(raw);
+            cache = Array.isArray(parsed.profiles) ? parsed.profiles : [];
+        }
+        catch {
+            // File doesn't exist or is invalid -- start fresh
+            cache = [];
+        }
+        return cache;
+    }
+    async function saveProfiles(profiles) {
+        await fs.promises.mkdir(deps.profilesDir, { recursive: true });
+        const data = { profiles };
+        await fs.promises.writeFile(manifestPath(), JSON.stringify(data, null, 2), "utf-8");
+        cache = profiles;
+    }
+    function findNextIndex(profiles) {
+        const usedIndices = new Set(profiles.map((p) => p.index));
+        let index = 0;
+        while (usedIndices.has(index)) {
+            index++;
+        }
+        return index;
+    }
+    const manager = {
+        async list() {
+            try {
+                const profiles = await loadProfiles();
+                return ok([...profiles]);
+            }
+            catch (e) {
+                return err(e instanceof Error ? e : new Error(String(e)));
+            }
+        },
+        async create(params) {
+            try {
+                // Validate name
+                const nameResult = validateProfileName(params.name);
+                if (!nameResult.ok)
+                    return nameResult;
+                const name = nameResult.value;
+                // Load existing profiles
+                const profiles = await loadProfiles();
+                // Check max profiles limit
+                if (profiles.length >= deps.maxProfiles) {
+                    return err(new Error(`Maximum profiles (${deps.maxProfiles}) reached`));
+                }
+                // Check name uniqueness
+                if (profiles.some((p) => p.name === name)) {
+                    return err(new Error(`Profile "${name}" already exists`));
+                }
+                // Allocate next available index
+                const index = findNextIndex(profiles);
+                const cdpPort = allocateCdpPort(deps.baseCdpPort, index);
+                const color = getProfileColor(index);
+                const profileDir = safePath(deps.profilesDir, name);
+                // Create directory and decorate
+                await fs.promises.mkdir(profileDir, { recursive: true });
+                const decorateResult = await decorateProfile(profileDir, { name, color });
+                if (!decorateResult.ok) {
+                    return decorateResult;
+                }
+                // Build profile info
+                const info = { name, cdpPort, profileDir, color, index };
+                // Persist
+                profiles.push(info);
+                await saveProfiles(profiles);
+                deps.logger.info(`Created profile "${name}" on CDP port ${cdpPort}`);
+                return ok(info);
+            }
+            catch (e) {
+                return err(e instanceof Error ? e : new Error(String(e)));
+            }
+        },
+        async delete(name) {
+            try {
+                const profiles = await loadProfiles();
+                const idx = profiles.findIndex((p) => p.name === name);
+                if (idx === -1) {
+                    return err(new Error(`Profile "${name}" not found`));
+                }
+                profiles.splice(idx, 1);
+                await saveProfiles(profiles);
+                deps.logger.info(`Deleted profile "${name}"`);
+                return ok(undefined);
+            }
+            catch (e) {
+                return err(e instanceof Error ? e : new Error(String(e)));
+            }
+        },
+        resolve(name) {
+            if (cache === null) {
+                return err(new Error("Profile manager not initialized -- call list() or create() first"));
+            }
+            const found = cache.find((p) => p.name === name);
+            if (!found) {
+                return err(new Error(`Profile "${name}" not found`));
+            }
+            return ok(found);
+        },
+    };
+    return manager;
+}

package/node_modules/@comis/skills/dist/browser/profiles.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Chrome profile utilities.
+ *
+ * Provides profile name validation, CDP port allocation, and a color
+ * palette for visual identity in Chrome's profile switcher.
+ *
+ * @module
+ */
+import type { Result } from "@comis/shared";
+/**
+ * Valid profile name pattern: 2-50 chars, lowercase alphanumeric + hyphens,
+ * no leading or trailing hyphen.
+ */
+export declare const PROFILE_NAME_PATTERN: RegExp;
+/**
+ * Color palette for profile visual identity (10 distinct colors).
+ * Used in Chrome's profile switcher for quick visual identification.
+ */
+export declare const PROFILE_COLORS: readonly string[];
+/**
+ * Validate a profile name against the safe pattern.
+ *
+ * @param name - Profile name to validate
+ * @returns ok(trimmed name) or err describing the validation failure
+ */
+export declare function validateProfileName(name: string): Result<string, Error>;
+/**
+ * Allocate a CDP port for a profile based on its index.
+ *
+ * @param baseCdpPort - Base port number
+ * @param profileIndex - Zero-based profile index
+ * @returns The allocated port number
+ * @throws Error if the resulting port exceeds 65535
+ */
+export declare function allocateCdpPort(baseCdpPort: number, profileIndex: number): number;
+/**
+ * Get the profile color for a given index, cycling through the palette.
+ *
+ * @param profileIndex - Zero-based profile index
+ * @returns Hex color string
+ */
+export declare function getProfileColor(profileIndex: number): string;

package/node_modules/@comis/skills/dist/browser/profiles.js

@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Chrome profile utilities.
+ *
+ * Provides profile name validation, CDP port allocation, and a color
+ * palette for visual identity in Chrome's profile switcher.
+ *
+ * @module
+ */
+import { ok, err } from "@comis/shared";
+// ── Constants ─────────────────────────────────────────────────────────
+/**
+ * Valid profile name pattern: 2-50 chars, lowercase alphanumeric + hyphens,
+ * no leading or trailing hyphen.
+ */
+export const PROFILE_NAME_PATTERN = /^[a-z0-9][a-z0-9-]{0,48}[a-z0-9]$/;
+/**
+ * Color palette for profile visual identity (10 distinct colors).
+ * Used in Chrome's profile switcher for quick visual identification.
+ */
+export const PROFILE_COLORS = [
+    "#4285F4",
+    "#EA4335",
+    "#FBBC05",
+    "#34A853",
+    "#FF6D01",
+    "#46BDC6",
+    "#7B1FA2",
+    "#C2185B",
+    "#00ACC1",
+    "#FFB300",
+];
+// ── Functions ─────────────────────────────────────────────────────────
+/**
+ * Validate a profile name against the safe pattern.
+ *
+ * @param name - Profile name to validate
+ * @returns ok(trimmed name) or err describing the validation failure
+ */
+export function validateProfileName(name) {
+    const trimmed = name.trim();
+    if (!PROFILE_NAME_PATTERN.test(trimmed)) {
+        return err(new Error(`Invalid profile name "${trimmed}": must be 2-50 chars, lowercase alphanumeric + hyphens, no leading/trailing hyphen`));
+    }
+    return ok(trimmed);
+}
+/**
+ * Allocate a CDP port for a profile based on its index.
+ *
+ * @param baseCdpPort - Base port number
+ * @param profileIndex - Zero-based profile index
+ * @returns The allocated port number
+ * @throws Error if the resulting port exceeds 65535
+ */
+export function allocateCdpPort(baseCdpPort, profileIndex) {
+    const port = baseCdpPort + profileIndex;
+    if (port < 1 || port > 65535) {
+        throw new Error(`Allocated CDP port ${port} is out of range (1-65535)`);
+    }
+    return port;
+}
+/**
+ * Get the profile color for a given index, cycling through the palette.
+ *
+ * @param profileIndex - Zero-based profile index
+ * @returns Hex color string
+ */
+export function getProfileColor(profileIndex) {
+    return PROFILE_COLORS[profileIndex % PROFILE_COLORS.length];
+}