pi-agent-browser-native 0.9.4 → 0.9.6

package/dist/packaged/lib/config-policy.js

@@ -0,0 +1,599 @@
+// dist/extensions/agent-browser/lib/config-policy.js
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+
+// dist/extensions/agent-browser/lib/config-providers.js
+var BRAVE_API_KEY_ENV = "BRAVE_API_KEY";
+var EXA_API_KEY_ENV = "EXA_API_KEY";
+var WEB_SEARCH_PROVIDER_DESCRIPTORS = Object.freeze({
+  exa: Object.freeze({
+    provider: "exa",
+    apiKeyEnv: EXA_API_KEY_ENV,
+    configKey: "exaApiKey",
+    label: "Exa"
+  }),
+  brave: Object.freeze({
+    provider: "brave",
+    apiKeyEnv: BRAVE_API_KEY_ENV,
+    configKey: "braveApiKey",
+    label: "Brave Search"
+  })
+});
+var WEB_SEARCH_PROVIDERS = Object.freeze(["exa", "brave"]);
+var DEFAULT_WEB_SEARCH_PROVIDER = "exa";
+var EXA_SEARCH_TYPES = Object.freeze([
+  "auto",
+  "fast",
+  "instant",
+  "deep-lite",
+  "deep",
+  "deep-reasoning"
+]);
+var WEB_SEARCH_PROVIDER_CONFIG_KEYS = Object.freeze({
+  exa: WEB_SEARCH_PROVIDER_DESCRIPTORS.exa.configKey,
+  brave: WEB_SEARCH_PROVIDER_DESCRIPTORS.brave.configKey
+});
+var WEB_SEARCH_PROVIDER_ENV_VARS = Object.freeze({
+  exa: WEB_SEARCH_PROVIDER_DESCRIPTORS.exa.apiKeyEnv,
+  brave: WEB_SEARCH_PROVIDER_DESCRIPTORS.brave.apiKeyEnv
+});
+function isWebSearchProvider(value) {
+  return value === "exa" || value === "brave";
+}
+function getWebSearchProviderDescriptor(provider) {
+  if (!isWebSearchProvider(provider)) {
+    throw new Error(`Unknown web-search provider: ${provider}`);
+  }
+  return WEB_SEARCH_PROVIDER_DESCRIPTORS[provider];
+}
+function getWebSearchProviderLabel(provider) {
+  return getWebSearchProviderDescriptor(provider).label;
+}
+function getWebSearchProviderEnvVar(provider) {
+  return getWebSearchProviderDescriptor(provider).apiKeyEnv;
+}
+function getWebSearchProviderConfigKey(provider) {
+  return getWebSearchProviderDescriptor(provider).configKey;
+}
+
+// dist/extensions/agent-browser/lib/config-validation.js
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validateString(value, path, errors) {
+  if (value === void 0) {
+    return;
+  }
+  if (typeof value !== "string") {
+    errors.push(`${path} must be a string.`);
+    return;
+  }
+  return value;
+}
+function validateBoolean(value, path, errors) {
+  if (value === void 0) {
+    return;
+  }
+  if (typeof value !== "boolean") {
+    errors.push(`${path} must be a boolean.`);
+    return;
+  }
+  return value;
+}
+function validateWebSearchProvider(value, path, errors) {
+  if (value === void 0) {
+    return;
+  }
+  const provider = validateString(value, path, errors)?.trim();
+  if (provider === void 0) {
+    return;
+  }
+  if (!isWebSearchProvider(provider)) {
+    errors.push(`${path} must be one of ${WEB_SEARCH_PROVIDERS.join(", ")}.`);
+    return;
+  }
+  return provider;
+}
+function validateExaSearchType(value, path, errors) {
+  if (value === void 0) {
+    return;
+  }
+  const searchType = validateString(value, path, errors)?.trim();
+  if (searchType === void 0) {
+    return;
+  }
+  const supported = EXA_SEARCH_TYPES.find((candidate) => candidate === searchType);
+  if (supported === void 0) {
+    errors.push(`${path} must be one of ${EXA_SEARCH_TYPES.join(", ")}.`);
+  }
+  return supported;
+}
+function validateBrowserDefaultProfile(value, path, errors) {
+  if (value === void 0) {
+    return;
+  }
+  if (!isRecord(value)) {
+    errors.push(`${path} must be an object.`);
+    return;
+  }
+  const name = validateString(value.name, `${path}.name`, errors)?.trim();
+  if (name === void 0 || name.length === 0) {
+    errors.push(`${path}.name must not be blank.`);
+    return;
+  }
+  const policy = validateString(value.policy, `${path}.policy`, errors) ?? "authenticated-only";
+  if (policy !== "explicit-only" && policy !== "authenticated-only" && policy !== "always") {
+    errors.push(`${path}.policy must be one of explicit-only, authenticated-only, always.`);
+    return;
+  }
+  return { name, policy };
+}
+function validateWebSearchConfig(value, path, errors) {
+  if (value === void 0) {
+    return;
+  }
+  if (!isRecord(value)) {
+    errors.push(`${path} must be an object.`);
+    return;
+  }
+  const enabled = validateBoolean(value.enabled, `${path}.enabled`, errors);
+  const preferredProvider = validateWebSearchProvider(value.preferredProvider, `${path}.preferredProvider`, errors);
+  const defaultSearchType = validateExaSearchType(value.defaultSearchType, `${path}.defaultSearchType`, errors);
+  const keys = {};
+  for (const provider of WEB_SEARCH_PROVIDERS) {
+    const { configKey } = getWebSearchProviderDescriptor(provider);
+    const apiKey = validateString(value[configKey], `${path}.${configKey}`, errors);
+    if (apiKey !== void 0) {
+      keys[configKey] = apiKey;
+    }
+  }
+  const config = {
+    ...enabled !== void 0 ? { enabled } : {},
+    ...preferredProvider !== void 0 ? { preferredProvider } : {},
+    ...defaultSearchType !== void 0 ? { defaultSearchType } : {},
+    ...keys
+  };
+  return Object.keys(config).length > 0 ? config : void 0;
+}
+function validateBrowserConfig(value, path, errors) {
+  if (value === void 0) {
+    return;
+  }
+  if (!isRecord(value)) {
+    errors.push(`${path} must be an object.`);
+    return;
+  }
+  const defaultProfile = validateBrowserDefaultProfile(value.defaultProfile, `${path}.defaultProfile`, errors);
+  const executablePath = validateString(value.executablePath, `${path}.executablePath`, errors)?.trim();
+  return {
+    ...defaultProfile !== void 0 ? { defaultProfile } : {},
+    ...executablePath !== void 0 && executablePath.length > 0 ? { executablePath } : {}
+  };
+}
+function validateAgentBrowserConfig(value, path, errors, warnings) {
+  if (!isRecord(value)) {
+    errors.push(`${path} must contain a JSON object.`);
+    return;
+  }
+  if (value.version !== void 0 && value.version !== 1) {
+    errors.push(`${path}.version must be 1 when present.`);
+  }
+  const webSearch = validateWebSearchConfig(value.webSearch, `${path}.webSearch`, errors);
+  const browser = validateBrowserConfig(value.browser, `${path}.browser`, errors);
+  for (const key of Object.keys(value)) {
+    if (!["version", "webSearch", "browser"].includes(key)) {
+      warnings.push(`${path}.${key} is not a recognized pi-agent-browser-native config field and was ignored.`);
+    }
+  }
+  return {
+    ...value.version === 1 ? { version: 1 } : {},
+    ...webSearch !== void 0 ? { webSearch } : {},
+    ...browser !== void 0 ? { browser } : {}
+  };
+}
+function parseAgentBrowserConfigJson(raw) {
+  try {
+    return { ok: true, value: JSON.parse(raw) };
+  } catch (error) {
+    const location = error instanceof Error ? error.message.match(/at position \d+(?: \(line \d+ column \d+\))?/)?.[0] : void 0;
+    return {
+      ok: false,
+      error: location === void 0 ? "Invalid JSON." : `Invalid JSON ${location}.`
+    };
+  }
+}
+function parseAgentBrowserConfigLayer(raw, path, scope, errors, warnings) {
+  const parsed = parseAgentBrowserConfigJson(raw);
+  if (!parsed.ok) {
+    errors.push(`Could not parse ${scope} config ${path}: ${parsed.error}`);
+    return;
+  }
+  const config = validateAgentBrowserConfig(parsed.value, path, errors, warnings);
+  return config ? { config, path, scope } : void 0;
+}
+function describeUnknownError(value) {
+  switch (typeof value) {
+    case "string":
+      return value;
+    case "number":
+    case "bigint":
+    case "boolean":
+    case "symbol":
+      return String(value);
+    case "undefined":
+      return "undefined";
+    case "object":
+      return value === null ? "null" : Object.prototype.toString.call(value);
+    case "function":
+      return value.toString();
+  }
+}
+
+// dist/extensions/agent-browser/lib/config-policy.js
+var CONFIG_DIR_NAME = ".pi";
+var AGENT_BROWSER_CONFIG_ENV = "PI_AGENT_BROWSER_CONFIG";
+var CONFIG_RELATIVE_PATH = (
+  /** @type {const} */
+  [
+    CONFIG_DIR_NAME,
+    "config",
+    "pi-agent-browser-native",
+    "config.json"
+  ]
+);
+var GLOBAL_CONFIG_RELATIVE_PATH = (
+  /** @type {const} */
+  [
+    CONFIG_DIR_NAME,
+    "config",
+    "pi-agent-browser-native",
+    "config.json"
+  ]
+);
+var SECRET_COMMAND_TIMEOUT_MS = 15e3;
+function getGlobalAgentBrowserConfigPath(env = process.env) {
+  const home = [env.HOME?.trim(), env.USERPROFILE?.trim()].find((value) => value !== void 0 && value.length > 0) ?? homedir();
+  return join(home, ...GLOBAL_CONFIG_RELATIVE_PATH);
+}
+function getProjectAgentBrowserConfigPath(cwd = process.cwd()) {
+  return resolve(cwd, ...CONFIG_RELATIVE_PATH);
+}
+function getAgentBrowserConfigPaths(options = {}) {
+  const env = options.env ?? process.env;
+  const override = env[AGENT_BROWSER_CONFIG_ENV]?.trim();
+  return {
+    global: getGlobalAgentBrowserConfigPath(env),
+    project: getProjectAgentBrowserConfigPath(options.cwd),
+    ...override !== void 0 && override.length > 0 ? { override: resolve(override) } : {}
+  };
+}
+function mergeAgentBrowserConfig(base, override) {
+  return {
+    ...base,
+    ...override,
+    browser: {
+      ...base.browser,
+      ...override.browser,
+      defaultProfile: override.browser?.defaultProfile ?? base.browser?.defaultProfile
+    },
+    webSearch: {
+      ...base.webSearch,
+      ...override.webSearch
+    }
+  };
+}
+function classifyCredentialSource(rawValue, scope, provider) {
+  const trimmed = rawValue.trim();
+  if (trimmed.length === 0) {
+    return;
+  }
+  if (trimmed.startsWith("!")) {
+    return { kind: "command", provider, rawValue: trimmed, scope };
+  }
+  if (trimmed.includes("$")) {
+    return { kind: "env", provider, rawValue: trimmed, scope };
+  }
+  return { kind: "literal", provider, rawValue: trimmed, scope };
+}
+function getBrowserDefaultProfile(config) {
+  const profile = config.browser?.defaultProfile;
+  if (!profile || profile.name.trim().length === 0) {
+    return;
+  }
+  return { name: profile.name.trim(), policy: profile.policy ?? "authenticated-only" };
+}
+function getBrowserExecutablePath(config) {
+  const executablePath = config.browser?.executablePath?.trim();
+  return executablePath !== void 0 && executablePath.length > 0 ? executablePath : void 0;
+}
+function getBrowserDefaultProfileScope(layers) {
+  for (let index = layers.length - 1; index >= 0; index -= 1) {
+    const layer = layers.at(index);
+    if (layer?.config.browser?.defaultProfile !== void 0) {
+      return layer.scope;
+    }
+  }
+  return;
+}
+function getBrowserExecutablePathScope(layers) {
+  for (let index = layers.length - 1; index >= 0; index -= 1) {
+    const layer = layers.at(index);
+    if (layer?.config.browser?.executablePath !== void 0) {
+      return layer.scope;
+    }
+  }
+  return;
+}
+function getTrustedBrowserDefaultProfile(layers) {
+  for (let index = layers.length - 1; index >= 0; index -= 1) {
+    const layer = layers.at(index);
+    if (!layer) {
+      continue;
+    }
+    const profile = getBrowserDefaultProfile(layer.config);
+    if (profile) {
+      return { profile, scope: layer.scope };
+    }
+  }
+  return;
+}
+function getTrustedBrowserExecutablePath(layers) {
+  for (let index = layers.length - 1; index >= 0; index -= 1) {
+    const layer = layers.at(index);
+    if (!layer) {
+      continue;
+    }
+    const executablePath = getBrowserExecutablePath(layer.config);
+    if (executablePath !== void 0 && executablePath.length > 0) {
+      return { executablePath, scope: layer.scope };
+    }
+  }
+  return;
+}
+function getWebSearchCredentialScope(layers, key) {
+  for (let index = layers.length - 1; index >= 0; index -= 1) {
+    const layer = layers.at(index);
+    if (layer?.config.webSearch?.[key] !== void 0) {
+      return layer.scope;
+    }
+  }
+  return "global";
+}
+function buildWebSearchCredentialSources(options) {
+  const sources = {};
+  for (const provider of WEB_SEARCH_PROVIDERS) {
+    const descriptor = getWebSearchProviderDescriptor(provider);
+    const apiKey = options.mergedConfig.webSearch?.[descriptor.configKey];
+    if (apiKey !== void 0) {
+      sources[provider] = classifyCredentialSource(apiKey, getWebSearchCredentialScope(options.layers, descriptor.configKey), provider);
+    }
+    if (!sources[provider] && (options.env[descriptor.apiKeyEnv]?.trim().length ?? 0) > 0) {
+      sources[provider] = {
+        kind: "literal",
+        provider,
+        rawValue: options.env[descriptor.apiKeyEnv] ?? "",
+        scope: "env-fallback"
+      };
+    }
+  }
+  return sources;
+}
+function buildAgentBrowserConfigState(options) {
+  const webSearchCredentialSources = buildWebSearchCredentialSources(options);
+  const trustedBrowserDefaultProfile = getTrustedBrowserDefaultProfile(options.layers);
+  const trustedBrowserExecutablePath = getTrustedBrowserExecutablePath(options.layers);
+  return {
+    browserDefaultProfile: getBrowserDefaultProfile(options.mergedConfig),
+    browserDefaultProfileScope: getBrowserDefaultProfileScope(options.layers),
+    browserExecutablePath: getBrowserExecutablePath(options.mergedConfig),
+    browserExecutablePathScope: getBrowserExecutablePathScope(options.layers),
+    trustedBrowserDefaultProfile: trustedBrowserDefaultProfile?.profile,
+    trustedBrowserDefaultProfileScope: trustedBrowserDefaultProfile?.scope,
+    trustedBrowserExecutablePath: trustedBrowserExecutablePath?.executablePath,
+    trustedBrowserExecutablePathScope: trustedBrowserExecutablePath?.scope,
+    config: options.mergedConfig,
+    webSearchCredentialSources,
+    webSearchEnabled: options.mergedConfig.webSearch?.enabled !== false,
+    webSearchPreferredProvider: options.mergedConfig.webSearch?.preferredProvider ?? DEFAULT_WEB_SEARCH_PROVIDER,
+    errors: options.errors,
+    layers: options.layers,
+    paths: options.paths,
+    projectConfigIncluded: options.projectConfigIncluded ?? options.layers.some((layer) => layer.scope === "project"),
+    warnings: options.warnings
+  };
+}
+function readConfigLayerSync(path, scope, errors, warnings) {
+  let raw;
+  try {
+    raw = readFileSync(path, "utf8");
+  } catch (error) {
+    if (error !== null && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+      return;
+    }
+    errors.push(`Could not read ${scope} config ${path}: ${error instanceof Error ? error.message : describeUnknownError(error)}`);
+    return;
+  }
+  return parseAgentBrowserConfigLayer(raw, path, scope, errors, warnings);
+}
+function loadAgentBrowserConfigStateSync(options = {}) {
+  const env = options.env ?? process.env;
+  const paths = getAgentBrowserConfigPaths({ cwd: options.cwd, env });
+  const includeProjectConfig = options.includeProjectConfig !== false;
+  const errors = [];
+  const warnings = [];
+  const layerCandidates = [{ path: paths.global, scope: "global" }];
+  if (includeProjectConfig) {
+    layerCandidates.push({ path: paths.project, scope: "project" });
+  }
+  if (paths.override !== void 0 && paths.override.length > 0) {
+    layerCandidates.push({ path: paths.override, scope: "override" });
+  }
+  const layers = [];
+  let mergedConfig = {};
+  for (const candidate of layerCandidates) {
+    const layer = readConfigLayerSync(candidate.path, candidate.scope, errors, warnings);
+    if (!layer) {
+      continue;
+    }
+    layers.push(layer);
+    mergedConfig = mergeAgentBrowserConfig(mergedConfig, layer.config);
+  }
+  return buildAgentBrowserConfigState({
+    env,
+    errors,
+    layers,
+    mergedConfig,
+    paths,
+    projectConfigIncluded: includeProjectConfig,
+    warnings
+  });
+}
+function resolveEnvInterpolations(rawValue, env) {
+  let output = "";
+  for (let index = 0; index < rawValue.length; index += 1) {
+    const char = rawValue[index];
+    if (char !== "$") {
+      output += char;
+      continue;
+    }
+    const next = rawValue[index + 1];
+    if (next === "$" || next === "!") {
+      output += next;
+      index += 1;
+      continue;
+    }
+    let name = "";
+    if (next === "{") {
+      const end = rawValue.indexOf("}", index + 2);
+      if (end === -1) {
+        return;
+      }
+      name = rawValue.slice(index + 2, end);
+      index = end;
+    } else {
+      const match = rawValue.slice(index + 1).match(/^([A-Za-z_][A-Za-z0-9_]*)/);
+      if (!match) {
+        output += "$";
+        continue;
+      }
+      name = match[1];
+      index += name.length;
+    }
+    if (name.length === 0) {
+      return;
+    }
+    const value = env[name];
+    if (value === void 0) {
+      return;
+    }
+    output += value;
+  }
+  return output;
+}
+function getWebSearchProviderOrder(state, requestedProvider) {
+  if (requestedProvider !== void 0 && requestedProvider !== "auto") {
+    return [requestedProvider];
+  }
+  const preferred = state.webSearchPreferredProvider;
+  return [preferred, ...WEB_SEARCH_PROVIDERS.filter((provider) => provider !== preferred)];
+}
+function getWebSearchCredentialSource(state, provider) {
+  return state.webSearchCredentialSources[provider];
+}
+function hasPotentialCredentialSource(source, env) {
+  if (!source) {
+    return false;
+  }
+  if (source.kind === "command") {
+    return true;
+  }
+  if (source.kind === "env") {
+    return Boolean(resolveEnvInterpolations(source.rawValue, env)?.trim());
+  }
+  return Boolean(source.rawValue.trim());
+}
+function canRegisterWebSearchTool(state, env = process.env) {
+  if (!state.webSearchEnabled || state.errors.length > 0) {
+    return false;
+  }
+  return WEB_SEARCH_PROVIDERS.some((provider) => hasPotentialCredentialSource(state.webSearchCredentialSources[provider], env));
+}
+function getCredentialSourceSummary(source, provider) {
+  if (!source) {
+    return "not configured";
+  }
+  if (source.kind === "command") {
+    return `configured via command (${source.scope})`;
+  }
+  if (source.kind === "env") {
+    return `configured via environment interpolation (${source.scope})`;
+  }
+  if (source.scope === "env-fallback") {
+    return `configured via ${getWebSearchProviderEnvVar(provider ?? source.provider ?? DEFAULT_WEB_SEARCH_PROVIDER)} environment fallback`;
+  }
+  return `configured as plaintext ${source.scope} value [redacted]`;
+}
+function formatBrowserProfileStatus(state) {
+  const profile = state.browserDefaultProfile;
+  if (!profile) {
+    return "not configured";
+  }
+  const scope = state.browserDefaultProfileScope ?? "unknown";
+  return `${profile.name} (policy: ${profile.policy}; ${scope})`;
+}
+function formatBrowserExecutableStatus(state) {
+  const executablePath = state.browserExecutablePath;
+  if (executablePath === void 0 || executablePath.length === 0) {
+    return "not configured";
+  }
+  const scope = state.browserExecutablePathScope ?? "unknown";
+  return `${executablePath} (${scope})`;
+}
+function summarizeConfigFiles(state, exists = existsSync) {
+  return [
+    ["global", state.paths.global],
+    ["project", state.paths.project],
+    ...state.paths.override !== void 0 && state.paths.override.length > 0 ? [["override", state.paths.override]] : []
+  ].map(([scope, path]) => ({ scope, path, exists: exists(path) }));
+}
+export {
+  AGENT_BROWSER_CONFIG_ENV,
+  BRAVE_API_KEY_ENV,
+  CONFIG_RELATIVE_PATH,
+  DEFAULT_WEB_SEARCH_PROVIDER,
+  EXA_API_KEY_ENV,
+  EXA_SEARCH_TYPES,
+  GLOBAL_CONFIG_RELATIVE_PATH,
+  SECRET_COMMAND_TIMEOUT_MS,
+  WEB_SEARCH_PROVIDERS,
+  WEB_SEARCH_PROVIDER_CONFIG_KEYS,
+  WEB_SEARCH_PROVIDER_DESCRIPTORS,
+  WEB_SEARCH_PROVIDER_ENV_VARS,
+  buildAgentBrowserConfigState,
+  buildWebSearchCredentialSources,
+  canRegisterWebSearchTool,
+  classifyCredentialSource,
+  formatBrowserExecutableStatus,
+  formatBrowserProfileStatus,
+  getAgentBrowserConfigPaths,
+  getCredentialSourceSummary,
+  getGlobalAgentBrowserConfigPath,
+  getProjectAgentBrowserConfigPath,
+  getWebSearchCredentialSource,
+  getWebSearchProviderConfigKey,
+  getWebSearchProviderDescriptor,
+  getWebSearchProviderEnvVar,
+  getWebSearchProviderLabel,
+  getWebSearchProviderOrder,
+  hasPotentialCredentialSource,
+  isWebSearchProvider,
+  loadAgentBrowserConfigStateSync,
+  mergeAgentBrowserConfig,
+  parseAgentBrowserConfigJson,
+  parseAgentBrowserConfigLayer,
+  resolveEnvInterpolations,
+  summarizeConfigFiles,
+  validateAgentBrowserConfig,
+  validateWebSearchProvider
+};

package/dist/packaged/lib/parsing.js

@@ -0,0 +1,34 @@
+// dist/extensions/agent-browser/lib/parsing.js
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function parseRefId(selector) {
+  const trimmed = selector.trim();
+  const prefixed = trimmed.startsWith("@") || trimmed.startsWith("ref=");
+  let candidate = trimmed;
+  if (trimmed.startsWith("@")) {
+    candidate = trimmed.slice(1);
+  } else if (trimmed.startsWith("ref=")) {
+    candidate = trimmed.slice(4);
+  }
+  return (prefixed ? /^e\d*$/ : /^e\d+$/).test(candidate) ? candidate : void 0;
+}
+function parsePositiveInteger(rawValue) {
+  if (typeof rawValue !== "string") {
+    return void 0;
+  }
+  const normalizedValue = rawValue.trim();
+  if (!/^\d+$/.test(normalizedValue)) {
+    return void 0;
+  }
+  const parsedValue = Number(normalizedValue);
+  if (!Number.isSafeInteger(parsedValue) || parsedValue <= 0) {
+    return void 0;
+  }
+  return parsedValue;
+}
+export {
+  isRecord,
+  parsePositiveInteger,
+  parseRefId
+};