@narumitw/pi-chrome-devtools 0.53.2 → 0.53.4

package/src/render.ts

@@ -4,117 +4,108 @@ import { sanitizeChromeDevtoolsDisplay } from "./display.js";
 
 const STATUS_KEY = "chrome-devtools";
 interface StatusContext {
-	sessionManager: object;
-	ui: { setStatus: (key: string, value: string | undefined) => void };
+  sessionManager: object;
+  ui: { setStatus: (key: string, value: string | undefined) => void };
 }
 interface RenderTheme {
-	bold(text: string): string;
-	fg(color: string, text: string): string;
+  bold(text: string): string;
+  fg(color: string, text: string): string;
 }
 const activeStatuses = new WeakMap<object, Array<{ status: string; token: symbol }>>();
 
 interface RenderComponent {
-	invalidate(): void;
-	render(width: number): string[];
+  invalidate(): void;
+  render(width: number): string[];
 }
 
 export function renderToolCall(action: string) {
-	return () => new PiTextComponent(`Chrome DevTools: ${action}`);
+  return () => new PiTextComponent(`Chrome DevTools: ${action}`);
 }
 
 export function renderTextResult(
-	result: AgentToolResult<unknown>,
-	options: ToolRenderResultOptions,
-	theme: RenderTheme,
+  result: AgentToolResult<unknown>,
+  options: ToolRenderResultOptions,
+  theme: RenderTheme,
 ) {
-	const output = formatCollapsibleOutput(textContent(result), options);
-	return new PiTextComponent(output.text, theme, output.color);
+  const output = formatCollapsibleOutput(textContent(result), options);
+  return new PiTextComponent(output.text, theme, output.color);
 }
 
 export function renderScreenshotResult(
-	result: AgentToolResult<unknown>,
-	options: ToolRenderResultOptions,
-	theme: RenderTheme,
+  result: AgentToolResult<unknown>,
+  options: ToolRenderResultOptions,
+  theme: RenderTheme,
 ): RenderComponent {
-	const output = formatCollapsibleOutput(screenshotTextContent(result), options);
-	return new PiTextComponent(output.text, theme, output.color);
+  const output = formatCollapsibleOutput(screenshotTextContent(result), options);
+  return new PiTextComponent(output.text, theme, output.color);
 }
 
 function textContent(result: AgentToolResult<unknown>) {
-	return result.content
-		.flatMap((content) => (content.type === "text" ? [content.text] : []))
-		.join("\n");
+  return result.content.flatMap((content) => (content.type === "text" ? [content.text] : [])).join("\n");
 }
 
 function screenshotTextContent(result: AgentToolResult<unknown>) {
-	const text = textContent(result);
-	if (text.trim()) return text;
+  const text = textContent(result);
+  if (text.trim()) return text;
 
-	const details = result.details as { savedPath?: unknown; bytes?: unknown } | undefined;
-	if (typeof details?.savedPath !== "string") return text;
-	const bytes = typeof details.bytes === "number" ? ` (${details.bytes} bytes)` : "";
-	return `Saved screenshot to ${details.savedPath}${bytes}`;
+  const details = result.details as { savedPath?: unknown; bytes?: unknown } | undefined;
+  if (typeof details?.savedPath !== "string") return text;
+  const bytes = typeof details.bytes === "number" ? ` (${details.bytes} bytes)` : "";
+  return `Saved screenshot to ${details.savedPath}${bytes}`;
 }
 
-function formatCollapsibleOutput(
-	text: string,
-	options: ToolRenderResultOptions,
-): { text: string; color?: string } {
-	if (options.isPartial) return { text: "Running...", color: "warning" };
-	if (options.expanded) return { text, color: "toolOutput" };
+function formatCollapsibleOutput(text: string, options: ToolRenderResultOptions): { text: string; color?: string } {
+  if (options.isPartial) return { text: "Running...", color: "warning" };
+  if (options.expanded) return { text, color: "toolOutput" };
 
-	return { text: "" };
+  return { text: "" };
 }
 
 class PiTextComponent implements RenderComponent {
-	private text: string;
-	private readonly theme?: RenderTheme;
-	private readonly color?: string;
-
-	constructor(text = "", theme?: RenderTheme, color?: string) {
-		this.text = text;
-		this.theme = theme;
-		this.color = color;
-	}
-
-	setText(text: string) {
-		this.text = text;
-	}
-
-	invalidate() {
-		// Stateless renderer: no cached layout to invalidate.
-	}
-
-	render(width: number) {
-		const sanitizedText = sanitizeChromeDevtoolsDisplay(this.text);
-		if (!sanitizedText.trim()) return [];
-		return sanitizedText
-			.replace(/\t/g, "   ")
-			.split(/\r?\n/)
-			.map((line) => {
-				const truncatedLine = truncateToWidth(line, Math.max(0, width), "");
-				return this.theme && this.color ? this.theme.fg(this.color, truncatedLine) : truncatedLine;
-			});
-	}
+  private text: string;
+  private readonly theme?: RenderTheme;
+  private readonly color?: string;
+
+  constructor(text = "", theme?: RenderTheme, color?: string) {
+    this.text = text;
+    this.theme = theme;
+    this.color = color;
+  }
+
+  setText(text: string) {
+    this.text = text;
+  }
+
+  invalidate() {
+    // Stateless renderer: no cached layout to invalidate.
+  }
+
+  render(width: number) {
+    const sanitizedText = sanitizeChromeDevtoolsDisplay(this.text);
+    if (!sanitizedText.trim()) return [];
+    return sanitizedText
+      .replace(/\t/g, "   ")
+      .split(/\r?\n/)
+      .map((line) => {
+        const truncatedLine = truncateToWidth(line, Math.max(0, width), "");
+        return this.theme && this.color ? this.theme.fg(this.color, truncatedLine) : truncatedLine;
+      });
+  }
 }
 
-export async function withStatus<T>(
-	ctx: StatusContext,
-	status: string,
-	callback: () => Promise<T>,
-) {
-	const token = Symbol(status);
-	const statuses = activeStatuses.get(ctx.sessionManager) ?? [];
-	statuses.push({ status, token });
-	activeStatuses.set(ctx.sessionManager, statuses);
-	ctx.ui.setStatus(STATUS_KEY, status);
-	try {
-		return await callback();
-	} finally {
-		const index = statuses.findIndex((entry) => entry.token === token);
-		if (index >= 0) statuses.splice(index, 1);
-		const remaining = statuses.at(-1)?.status;
-		if (statuses.length === 0) activeStatuses.delete(ctx.sessionManager);
-		ctx.ui.setStatus(STATUS_KEY, remaining);
-	}
+export async function withStatus<T>(ctx: StatusContext, status: string, callback: () => Promise<T>) {
+  const token = Symbol(status);
+  const statuses = activeStatuses.get(ctx.sessionManager) ?? [];
+  statuses.push({ status, token });
+  activeStatuses.set(ctx.sessionManager, statuses);
+  ctx.ui.setStatus(STATUS_KEY, status);
+  try {
+    return await callback();
+  } finally {
+    const index = statuses.findIndex((entry) => entry.token === token);
+    if (index >= 0) statuses.splice(index, 1);
+    const remaining = statuses.at(-1)?.status;
+    if (statuses.length === 0) activeStatuses.delete(ctx.sessionManager);
+    ctx.ui.setStatus(STATUS_KEY, remaining);
+  }
 }

package/src/runtime.ts

@@ -1,9 +1,9 @@
 import type { ChildProcess } from "node:child_process";
 import {
-	DEFAULT_BROWSER_HOST,
-	DEFAULT_BROWSER_PORT,
-	type EffectiveBrowserSettings,
-	parseConfiguredPort,
+  DEFAULT_BROWSER_HOST,
+  DEFAULT_BROWSER_PORT,
+  type EffectiveBrowserSettings,
+  parseConfiguredPort,
 } from "./settings.js";
 
 export const DEFAULT_HOST = DEFAULT_BROWSER_HOST;
@@ -17,197 +17,194 @@ export const DEVTOOLS_ACTIVE_PORT_FILE = "DevToolsActivePort";
 export const BROWSER_SHUTDOWN_WAIT_MS = 1_500;
 
 export interface DevToolsPage {
-	id: string;
-	type: string;
-	title: string;
-	url: string;
-	webSocketDebuggerUrl?: string;
+  id: string;
+  type: string;
+  title: string;
+  url: string;
+  webSocketDebuggerUrl?: string;
 }
 
 export interface ChromeDevToolsState {
-	host: string;
-	port: number;
-	configuredPort: number;
-	hostConfigured: boolean;
-	portConfigured: boolean;
-	autoLaunchEnabled: boolean;
-	endpointSource: EffectiveBrowserSettings["endpointSource"];
-	autoLaunchSource: EffectiveBrowserSettings["autoLaunchSource"];
-	browserExecutable?: string;
-	extensionPaths: string[];
-	browserExecutableSource: EffectiveBrowserSettings["executablePathSource"];
-	extensionPathsSource: EffectiveBrowserSettings["extensionPathsSource"];
-	settingsFilePath?: string;
-	projectSettingsFilePath?: string;
-	projectSettingsTrusted: boolean;
-	activePageId?: string;
-	managedBrowser?: ManagedBrowser;
-	launchPromise?: Promise<void>;
-	lastLaunchAttempt?: BrowserLaunchAttempt;
-	shuttingDown: boolean;
-	sessionGeneration: number;
-	sessionController: AbortController;
-	settingsNotice?: string;
+  host: string;
+  port: number;
+  configuredPort: number;
+  hostConfigured: boolean;
+  portConfigured: boolean;
+  autoLaunchEnabled: boolean;
+  endpointSource: EffectiveBrowserSettings["endpointSource"];
+  autoLaunchSource: EffectiveBrowserSettings["autoLaunchSource"];
+  browserExecutable?: string;
+  extensionPaths: string[];
+  browserExecutableSource: EffectiveBrowserSettings["executablePathSource"];
+  extensionPathsSource: EffectiveBrowserSettings["extensionPathsSource"];
+  settingsFilePath?: string;
+  projectSettingsFilePath?: string;
+  projectSettingsTrusted: boolean;
+  activePageId?: string;
+  managedBrowser?: ManagedBrowser;
+  launchPromise?: Promise<void>;
+  lastLaunchAttempt?: BrowserLaunchAttempt;
+  shuttingDown: boolean;
+  sessionGeneration: number;
+  sessionController: AbortController;
+  settingsNotice?: string;
 }
 
 export interface ManagedBrowser {
-	process: ChildProcess;
-	userDataDir: string;
-	port?: number;
-	exited: boolean;
-	ready: boolean;
-	ownerGeneration: number;
-	sessionOwner?: object;
-	cleanupPromise?: Promise<void>;
+  process: ChildProcess;
+  userDataDir: string;
+  port?: number;
+  exited: boolean;
+  ready: boolean;
+  ownerGeneration: number;
+  sessionOwner?: object;
+  cleanupPromise?: Promise<void>;
 }
 
 export interface BrowserLaunchAttempt {
-	candidateLabels: string[];
-	mode: "dynamic-port" | "explicit-port";
-	selectedCandidate?: string;
-	userDataDir?: string;
-	lastError?: string;
+  candidateLabels: string[];
+  mode: "dynamic-port" | "explicit-port";
+  selectedCandidate?: string;
+  userDataDir?: string;
+  lastError?: string;
 }
 
 export interface BrowserCandidateDefinition {
-	label: string;
-	executable: string;
-	source: "env" | "path" | "wellKnownPath";
+  label: string;
+  executable: string;
+  source: "env" | "path" | "wellKnownPath";
 }
 
 export interface BrowserCandidate extends BrowserCandidateDefinition {
-	resolvedExecutable: string;
+  resolvedExecutable: string;
 }
 
 export { parseConfiguredPort };
 
 export const state: ChromeDevToolsState = {
-	host: DEFAULT_HOST,
-	port: DEFAULT_PORT,
-	configuredPort: DEFAULT_PORT,
-	hostConfigured: false,
-	portConfigured: false,
-	autoLaunchEnabled: true,
-	endpointSource: "default",
-	autoLaunchSource: "default",
-	extensionPaths: [],
-	browserExecutableSource: "default",
-	extensionPathsSource: "default",
-	projectSettingsTrusted: false,
-	shuttingDown: false,
-	sessionGeneration: 0,
-	sessionController: new AbortController(),
+  host: DEFAULT_HOST,
+  port: DEFAULT_PORT,
+  configuredPort: DEFAULT_PORT,
+  hostConfigured: false,
+  portConfigured: false,
+  autoLaunchEnabled: true,
+  endpointSource: "default",
+  autoLaunchSource: "default",
+  extensionPaths: [],
+  browserExecutableSource: "default",
+  extensionPathsSource: "default",
+  projectSettingsTrusted: false,
+  shuttingDown: false,
+  sessionGeneration: 0,
+  sessionController: new AbortController(),
 };
 
 interface WebMcpSessionRuntime {
-	controller: AbortController;
-	enabled: boolean;
-	controllers: Set<AbortController>;
-	generation: number;
-	sessionGeneration: number;
+  controller: AbortController;
+  enabled: boolean;
+  controllers: Set<AbortController>;
+  generation: number;
+  sessionGeneration: number;
 }
 
 const webMcpRuntimeByOwner = new WeakMap<object, WebMcpSessionRuntime>();
 
 export function setWebMcpSessionOwner(owner: object) {
-	const runtime = webMcpRuntime(owner);
-	runtime.enabled = false;
-	runtime.sessionGeneration += 1;
+  const runtime = webMcpRuntime(owner);
+  runtime.enabled = false;
+  runtime.sessionGeneration += 1;
 }
 
 export function beginWebMcpOperation(owner: object, toolSignal?: AbortSignal) {
-	const runtime = webMcpRuntime(owner);
-	const controller = new AbortController();
-	runtime.controllers.add(controller);
-	const signals = [controller.signal, runtime.controller.signal];
-	if (toolSignal) signals.push(toolSignal);
-	const signal = AbortSignal.any(signals);
-	return {
-		signal,
-		owner,
-		sessionGeneration: runtime.sessionGeneration,
-		webMcpGeneration: runtime.generation,
-		dispose() {
-			runtime.controllers.delete(controller);
-		},
-	};
+  const runtime = webMcpRuntime(owner);
+  const controller = new AbortController();
+  runtime.controllers.add(controller);
+  const signals = [controller.signal, runtime.controller.signal];
+  if (toolSignal) signals.push(toolSignal);
+  const signal = AbortSignal.any(signals);
+  return {
+    signal,
+    owner,
+    sessionGeneration: runtime.sessionGeneration,
+    webMcpGeneration: runtime.generation,
+    dispose() {
+      runtime.controllers.delete(controller);
+    },
+  };
 }
 
 export function invalidateWebMcpOperations(owner: object, reason: string) {
-	const runtime = webMcpRuntime(owner);
-	runtime.generation += 1;
-	const controllers = [...runtime.controllers];
-	runtime.controllers.clear();
-	const error = new DOMException(reason, "AbortError");
-	runtime.controller.abort(error);
-	runtime.controller = new AbortController();
-	for (const controller of controllers) controller.abort(error);
+  const runtime = webMcpRuntime(owner);
+  runtime.generation += 1;
+  const controllers = [...runtime.controllers];
+  runtime.controllers.clear();
+  const error = new DOMException(reason, "AbortError");
+  runtime.controller.abort(error);
+  runtime.controller = new AbortController();
+  for (const controller of controllers) controller.abort(error);
 }
 
 export function currentWebMcpGeneration(owner: object) {
-	return webMcpRuntime(owner).generation;
+  return webMcpRuntime(owner).generation;
 }
 
 export function webMcpSessionSignal(owner: object) {
-	return webMcpRuntime(owner).controller.signal;
+  return webMcpRuntime(owner).controller.signal;
 }
 
 export function applyRuntimeWebMcpSetting(enabled: boolean, owner: object) {
-	const runtime = webMcpRuntime(owner);
-	if (runtime.enabled !== enabled) {
-		invalidateWebMcpOperations(owner, `WebMCP ${enabled ? "enabled" : "disabled"}`);
-	}
-	runtime.enabled = enabled;
+  const runtime = webMcpRuntime(owner);
+  if (runtime.enabled !== enabled) {
+    invalidateWebMcpOperations(owner, `WebMCP ${enabled ? "enabled" : "disabled"}`);
+  }
+  runtime.enabled = enabled;
 }
 
 export function webMcpEnabled(owner: object) {
-	return webMcpRuntime(owner).enabled;
+  return webMcpRuntime(owner).enabled;
 }
 
 export function webMcpOperationIsCurrent(operation: {
-	owner: object;
-	sessionGeneration: number;
-	webMcpGeneration: number;
+  owner: object;
+  sessionGeneration: number;
+  webMcpGeneration: number;
 }) {
-	const runtime = webMcpRuntime(operation.owner);
-	return (
-		operation.sessionGeneration === runtime.sessionGeneration &&
-		operation.webMcpGeneration === runtime.generation
-	);
+  const runtime = webMcpRuntime(operation.owner);
+  return operation.sessionGeneration === runtime.sessionGeneration && operation.webMcpGeneration === runtime.generation;
 }
 
 function webMcpRuntime(owner: object) {
-	const existing = webMcpRuntimeByOwner.get(owner);
-	if (existing) return existing;
-	const created: WebMcpSessionRuntime = {
-		controller: new AbortController(),
-		controllers: new Set(),
-		enabled: false,
-		generation: 0,
-		sessionGeneration: 0,
-	};
-	webMcpRuntimeByOwner.set(owner, created);
-	return created;
+  const existing = webMcpRuntimeByOwner.get(owner);
+  if (existing) return existing;
+  const created: WebMcpSessionRuntime = {
+    controller: new AbortController(),
+    controllers: new Set(),
+    enabled: false,
+    generation: 0,
+    sessionGeneration: 0,
+  };
+  webMcpRuntimeByOwner.set(owner, created);
+  return created;
 }
 
 export function applyRuntimeBrowserSettings(
-	browser: EffectiveBrowserSettings,
-	paths: { user: string; project?: string },
-	projectTrusted: boolean,
+  browser: EffectiveBrowserSettings,
+  paths: { user: string; project?: string },
+  projectTrusted: boolean,
 ) {
-	state.host = browser.host;
-	state.port = browser.port;
-	state.configuredPort = browser.port;
-	state.hostConfigured = browser.hostConfigured;
-	state.portConfigured = browser.portConfigured;
-	state.autoLaunchEnabled = browser.autoLaunchEnabled;
-	state.endpointSource = browser.endpointSource;
-	state.autoLaunchSource = browser.autoLaunchSource;
-	state.browserExecutable = browser.executablePath;
-	state.extensionPaths = [...browser.extensionPaths];
-	state.browserExecutableSource = browser.executablePathSource;
-	state.extensionPathsSource = browser.extensionPathsSource;
-	state.settingsFilePath = paths.user;
-	state.projectSettingsFilePath = paths.project;
-	state.projectSettingsTrusted = projectTrusted;
+  state.host = browser.host;
+  state.port = browser.port;
+  state.configuredPort = browser.port;
+  state.hostConfigured = browser.hostConfigured;
+  state.portConfigured = browser.portConfigured;
+  state.autoLaunchEnabled = browser.autoLaunchEnabled;
+  state.endpointSource = browser.endpointSource;
+  state.autoLaunchSource = browser.autoLaunchSource;
+  state.browserExecutable = browser.executablePath;
+  state.extensionPaths = [...browser.extensionPaths];
+  state.browserExecutableSource = browser.executablePathSource;
+  state.extensionPathsSource = browser.extensionPathsSource;
+  state.settingsFilePath = paths.user;
+  state.projectSettingsFilePath = paths.project;
+  state.projectSettingsTrusted = projectTrusted;
 }