import fs from "node:fs";

import path from "node:path";

import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";

import type { BrowserProfileConfig } from "../config/config.js";

import { getRuntimeConfig, mutateConfigFile } from "../config/config.js";

import { deriveDefaultBrowserCdpPortRange } from "../config/port-defaults.js";

import { getRuntimeConfig } from "../config/config.js";

import { formatErrorMessage } from "../infra/errors.js";

import { resolveUserPath } from "../utils.js";

import { assertCdpEndpointAllowed } from "./cdp.helpers.js";

import { resolveOpenClawUserDataDir } from "./chrome.js";

import { parseHttpUrl, resolveBrowserConfig, resolveProfile } from "./config.js";

import { createBrowserProfileConfig, deleteBrowserProfileConfig } from "./config-mutations.js";

import { parseHttpUrl, resolveProfile } from "./config.js";

import {

BrowserConflictError,

BrowserProfileNotFoundError,

BrowserResourceExhaustedError,

BrowserValidationError,

} from "./errors.js";

import { getBrowserProfileCapabilities } from "./profile-capabilities.js";

import {

allocateCdpPort,

allocateColor,

getUsedColors,

getUsedPorts,

isValidProfileName,

} from "./profiles.js";

import { isValidProfileName } from "./profiles.js";

import type { BrowserRouteContext, ProfileStatus } from "./server-context.js";

import { movePathToTrash } from "./trash.js";

const HEX_COLOR_RE = /^#[0-9A-Fa-f]{6}$/;

const cdpPortRange = (resolved: {

controlPort: number;

cdpPortRangeStart?: number;

cdpPortRangeEnd?: number;

}): { start: number; end: number } => {

const start = resolved.cdpPortRangeStart;

const end = resolved.cdpPortRangeEnd;

if (

typeof start === "number" &&

Number.isFinite(start) &&

Number.isInteger(start) &&

typeof end === "number" &&

Number.isFinite(end) &&

Number.isInteger(end) &&

start > 0 &&

end >= start &&

end <= 65535

) {

return { start, end };

}

return deriveDefaultBrowserCdpPortRange(resolved.controlPort);

};

export function createBrowserProfilesService(ctx: BrowserRouteContext) {

const listProfiles = async (): Promise<ProfileStatus[]> => {

return await ctx.listProfiles();

parsedCdpUrl = parsed.normalized;

}

const mutation = await mutateConfigFile<BrowserProfileConfig>({

afterWrite: { mode: "auto" },

mutate: async (draft) => {

const latestResolved = resolveBrowserConfig({

...state.resolved,

...draft.browser,

profiles: draft.browser?.profiles ?? state.resolved.profiles,

});

const latestProfiles = draft.browser?.profiles ?? {};

if (name in latestProfiles || name in latestResolved.profiles) {

throw new BrowserConflictError(`profile "${name}" already exists`);

}

const profileColor =

explicitProfileColor ?? allocateColor(getUsedColors(latestResolved.profiles));

let nextProfileConfig: BrowserProfileConfig;

if (parsedCdpUrl) {

try {

await assertCdpEndpointAllowed(parsedCdpUrl, latestResolved.ssrfPolicy);

} catch (err) {

throw new BrowserValidationError(formatErrorMessage(err));

}

nextProfileConfig = {

cdpUrl: parsedCdpUrl,

...(driver ? { driver } : {}),

color: profileColor,

};

} else if (driver === "existing-session") {

// existing-session uses Chrome MCP auto-connect; no CDP port needed.

nextProfileConfig = {

driver,

attachOnly: true,

...(normalizedUserDataDir ? { userDataDir: normalizedUserDataDir } : {}),

color: profileColor,

};

} else {

const usedPorts = getUsedPorts(latestResolved.profiles);

const rangeStart = draft.browser?.cdpPortRangeStart ?? state.resolved.cdpPortRangeStart;

const range = cdpPortRange({

controlPort: state.resolved.controlPort,

cdpPortRangeStart: rangeStart,

cdpPortRangeEnd:

draft.browser?.cdpPortRangeStart === undefined

? state.resolved.cdpPortRangeEnd

: latestResolved.cdpPortRangeEnd,

});

const cdpPort = allocateCdpPort(usedPorts, range);

if (cdpPort === null) {

throw new BrowserResourceExhaustedError("no available CDP ports in range");

}

nextProfileConfig = {

cdpPort,

...(driver ? { driver } : {}),

color: profileColor,

};

}

draft.browser = {

...draft.browser,

profiles: {

...draft.browser?.profiles,

[name]: nextProfileConfig,

},

};

return nextProfileConfig;

},

const profileConfig = await createBrowserProfileConfig({

name,

resolved: state.resolved,

...(explicitProfileColor ? { color: explicitProfileColor } : {}),

...(parsedCdpUrl ? { parsedCdpUrl } : {}),

...(normalizedUserDataDir ? { userDataDir: normalizedUserDataDir } : {}),

...(driver ? { driver } : {}),

});

const profileConfig = mutation.result;

if (!profileConfig) {

throw new BrowserProfileNotFoundError(`profile "${name}" not found after creation`);

}

}

}

await mutateConfigFile({

afterWrite: { mode: "auto" },

mutate: (draft) => {

const { [name]: _removed, ...remainingProfiles } = draft.browser?.profiles ?? {};

const nextBrowser = {

...draft.browser,

profiles: remainingProfiles,

};

if (nextBrowser.defaultProfile === name) {

delete nextBrowser.defaultProfile;

}

draft.browser = {

...nextBrowser,

};

},

});

await deleteBrowserProfileConfig(name);

delete state.resolved.profiles[name];

state.profiles.delete(name);