diff --git a/package.json b/package.json
index 6f65c1638..d5ec8ffe0 100644
--- a/package.json
+++ b/package.json
@@ -3,17 +3,21 @@
   "version": "0.17.1",
   "description": "MCP server for Chrome DevTools",
   "type": "module",
-  "bin": "./build/src/index.js",
+  "bin": {
+    "chrome-devtools-mcp": "./build/src/index.js",
+    "chrome-devtools": "./build/src/bin/chrome-devtools.js"
+  },
   "main": "index.js",
   "scripts": {
     "clean": "node -e \"require('fs').rmSync('build', {recursive: true, force: true})\"",
     "bundle": "npm run clean && npm run build && rollup -c rollup.config.mjs && node -e \"require('fs').rmSync('build/node_modules', {recursive: true, force: true})\"",
     "build": "tsc && node --experimental-strip-types --no-warnings=ExperimentalWarning scripts/post-build.ts",
     "typecheck": "tsc --noEmit",
-    "format": "eslint --cache --fix . && prettier --write --cache .",
+    "format": "prettier --write --cache . && eslint --cache --fix .",
     "check-format": "eslint --cache . && prettier --check --cache .;",
     "docs": "npm run build && npm run docs:generate && npm run format",
     "docs:generate": "node --experimental-strip-types scripts/generate-docs.ts",
+    "cli:generate": "node --experimental-strip-types scripts/generate-cli.ts && npm run format && npm run build",
     "start": "npm run build && node build/src/index.js",
     "start-debug": "DEBUG=mcp:* DEBUG_COLORS=false npm run build && node build/src/index.js",
     "test": "npm run build && node scripts/test.mjs",
diff --git a/scripts/generate-cli.ts b/scripts/generate-cli.ts
new file mode 100644
index 000000000..29e300bf0
--- /dev/null
+++ b/scripts/generate-cli.ts
@@ -0,0 +1,153 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+
+import {Client} from '@modelcontextprotocol/sdk/client/index.js';
+import {StdioClientTransport} from '@modelcontextprotocol/sdk/client/stdio.js';
+
+const OUTPUT_PATH = path.join(
+  path.dirname(fileURLToPath(import.meta.url)),
+  '../src/bin/cliDefinitions.ts',
+);
+
+async function fetchTools() {
+  console.log('Connecting to chrome-devtools-mcp to fetch tools...');
+  // Use the local build of the server
+  const serverPath = path.join(
+    path.dirname(fileURLToPath(import.meta.url)),
+    '../build/src/index.js',
+  );
+
+  const transport = new StdioClientTransport({
+    command: 'node',
+    args: [serverPath],
+    env: {...process.env, CHROME_DEVTOOLS_MCP_NO_USAGE_STATISTICS: 'true'},
+  });
+
+  const client = new Client(
+    {
+      name: 'chrome-devtools-cli-generator',
+      version: '0.1.0',
+    },
+    {
+      capabilities: {},
+    },
+  );
+
+  await client.connect(transport);
+  try {
+    const toolsResponse = await client.listTools();
+    const tools = toolsResponse.tools || [];
+    console.log(`Fetched ${tools.length} tools`);
+    return tools;
+  } finally {
+    await client.close();
+  }
+}
+
+interface CliOption {
+  name: string;
+  type: string;
+  description: string;
+  required: boolean;
+  default?: unknown;
+  enum?: unknown[];
+}
+
+interface JsonSchema {
+  type?: string | string[];
+  description?: string;
+  properties?: Record<string, JsonSchema>;
+  required?: string[];
+  default?: unknown;
+  enum?: unknown[];
+}
+
+function schemaToCLIOptions(schema: JsonSchema): CliOption[] {
+  if (!schema || !schema.properties) {
+    return [];
+  }
+  const required = schema.required || [];
+  const properties = schema.properties;
+  return Object.entries(properties).map(([name, prop]) => {
+    const isRequired = required.includes(name);
+    let type = prop.type || 'string';
+    if (Array.isArray(type)) {
+      type = type[0];
+    }
+    const description = prop.description || '';
+
+    return {
+      name,
+      type: type as string,
+      description,
+      required: isRequired,
+      default: prop.default,
+      enum: prop.enum,
+    };
+  });
+}
+
+async function generateCli() {
+  const tools = await fetchTools();
+  // Sort tools by name
+  const sortedTools = tools.sort((a, b) => a.name.localeCompare(b.name));
+
+  const commands: Record<
+    string,
+    {description: string; args: Record<string, CliOption>}
+  > = {};
+
+  for (const tool of sortedTools) {
+    const options = schemaToCLIOptions(tool.inputSchema);
+    const args: Record<string, CliOption> = {};
+    for (const opt of options) {
+      args[opt.name] = opt;
+    }
+    commands[tool.name] = {
+      description: tool.description || '',
+      args,
+    };
+  }
+
+  const lines: string[] = [];
+  lines.push(`/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// NOTE: do not edit manually. Auto-generated by 'npm run cli:generate'.
+
+export interface ArgDef {
+  name: string;
+  type: string;
+  description: string;
+  required: boolean;
+  default?: string | number | boolean;
+  enum?: ReadonlyArray<string | number>;
+}
+export type Commands = Record<
+  string,
+  {
+    description: string;
+    args: Record<string, ArgDef>
+  }
+>
+export const commands: Commands = ${JSON.stringify(commands, null, 2)} as const;
+`);
+
+  fs.writeFileSync(OUTPUT_PATH, lines.join(''));
+  console.log(`Generated CLI at ${OUTPUT_PATH}`);
+}
+
+generateCli().catch(err => {
+  console.error('Error during generation:', err);
+  process.exit(1);
+});
diff --git a/src/bin/chrome-devtools.ts b/src/bin/chrome-devtools.ts
new file mode 100644
index 000000000..89459b79d
--- /dev/null
+++ b/src/bin/chrome-devtools.ts
@@ -0,0 +1,171 @@
+#!/usr/bin/env node
+
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {createConnection} from 'node:net';
+import process from 'node:process';
+
+import yargs, {type Options, type PositionalOptions} from 'yargs';
+import {hideBin} from 'yargs/helpers';
+
+import {commands} from './cliDefinitions.js';
+import {
+  getSocketPath,
+  isDaemonRunning,
+  startDaemon,
+  stopDaemon,
+} from './daemonClient.js';
+
+async function sendToDaemon(
+  request: unknown,
+): Promise<{success: boolean; result: unknown; error: unknown}> {
+  const socketPath = await getSocketPath();
+  return new Promise((resolve, reject) => {
+    const client = createConnection({path: socketPath}, () => {
+      client.write(JSON.stringify(request) + '\0');
+    });
+
+    let buffer = '';
+    client.on('data', data => {
+      buffer += data.toString();
+      if (buffer.endsWith('\0')) {
+        try {
+          const response = JSON.parse(buffer.slice(0, -1));
+          client.end();
+          resolve(response);
+        } catch (e) {
+          reject(e);
+        }
+      }
+    });
+
+    client.on('error', err => {
+      reject(err);
+    });
+  });
+}
+
+const y = yargs(hideBin(process.argv))
+  .scriptName('chrome-devtools')
+  .help()
+  .showHelpOnFail(true)
+  .demandCommand()
+  .strict();
+
+y.command(
+  'start',
+  'Starts or restarts the daemon process',
+  y => y.help(false), // Disable help for start command to avoid parsing issues with passed args
+  async () => {
+    if (await isDaemonRunning()) {
+      await stopDaemon();
+    }
+    // Extract args after 'start'
+    const startIndex = process.argv.indexOf('start');
+    const args = startIndex !== -1 ? process.argv.slice(startIndex + 1) : [];
+    await startDaemon(args);
+  },
+);
+
+y.command('status', 'Checks if the MCP server process is running', async () => {
+  if (await isDaemonRunning()) {
+    console.log('Daemon is running');
+  } else {
+    console.log('Daemon is not running');
+  }
+});
+
+y.command('stop', 'Stop the running MCP server if any', async () => {
+  await stopDaemon();
+});
+
+for (const [commandName, commandDef] of Object.entries(commands)) {
+  const args = commandDef.args;
+  const requiredArgNames = Object.keys(args).filter(
+    name => args[name].required,
+  );
+
+  let commandStr = commandName;
+  for (const arg of requiredArgNames) {
+    commandStr += ` <${arg}>`;
+  }
+
+  y.command(
+    commandStr,
+    commandDef.description,
+    y => {
+      for (const [argName, opt] of Object.entries(args)) {
+        const type =
+          opt.type === 'integer' || opt.type === 'number'
+            ? 'number'
+            : opt.type === 'boolean'
+              ? 'boolean'
+              : opt.type === 'array'
+                ? 'array'
+                : 'string';
+
+        if (opt.required) {
+          const options: PositionalOptions = {
+            describe: opt.description,
+            type: type as PositionalOptions['type'],
+          };
+          if (opt.default !== undefined) {
+            options.default = opt.default;
+          }
+          if (opt.enum) {
+            options.choices = opt.enum as Array<string | number>;
+          }
+          y.positional(argName, options);
+        } else {
+          const options: Options = {
+            describe: opt.description,
+            type: type as Options['type'],
+          };
+          if (opt.default !== undefined) {
+            options.default = opt.default;
+          }
+          if (opt.enum) {
+            options.choices = opt.enum as Array<string | number>;
+          }
+          y.option(argName, options);
+        }
+      }
+    },
+    async argv => {
+      try {
+        if (!(await isDaemonRunning())) {
+          await startDaemon(['--via-cli']);
+        }
+
+        const commandArgs: Record<string, unknown> = {};
+        for (const argName of Object.keys(args)) {
+          if (argName in argv) {
+            commandArgs[argName] = argv[argName];
+          }
+        }
+
+        const response = await sendToDaemon({
+          method: 'invoke_tool',
+          tool: commandName,
+          args: commandArgs,
+        });
+
+        if (response.success) {
+          console.log(response.result);
+        } else {
+          console.error('Error:', response.error);
+          process.exit(1);
+        }
+      } catch (error) {
+        console.error('Failed to execute command:', error);
+        process.exit(1);
+      }
+    },
+  );
+}
+
+await y.parse();
diff --git a/src/bin/cliDefinitions.ts b/src/bin/cliDefinitions.ts
new file mode 100644
index 000000000..7061ce3f1
--- /dev/null
+++ b/src/bin/cliDefinitions.ts
@@ -0,0 +1,649 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export interface ArgDef {
+  name: string;
+  type: string;
+  description: string;
+  required: boolean;
+  default?: string | number | boolean;
+  enum?: ReadonlyArray<string | number>;
+}
+export type Commands = Record<
+  string,
+  {
+    description: string;
+    args: Record<string, ArgDef>;
+  }
+>;
+export const commands: Commands = {
+  click: {
+    description: 'Clicks on the provided element',
+    args: {
+      uid: {
+        name: 'uid',
+        type: 'string',
+        description:
+          'The uid of an element on the page from the page content snapshot',
+        required: true,
+      },
+      dblClick: {
+        name: 'dblClick',
+        type: 'boolean',
+        description: 'Set to true for double clicks. Default is false.',
+        required: false,
+      },
+      includeSnapshot: {
+        name: 'includeSnapshot',
+        type: 'boolean',
+        description:
+          'Whether to include a snapshot in the response. Default is false.',
+        required: false,
+      },
+    },
+  },
+  close_page: {
+    description:
+      'Closes the page by its index. The last open page cannot be closed.',
+    args: {
+      pageId: {
+        name: 'pageId',
+        type: 'number',
+        description:
+          'The ID of the page to close. Call list_pages to list pages.',
+        required: true,
+      },
+    },
+  },
+  drag: {
+    description: 'Drag an element onto another element',
+    args: {
+      from_uid: {
+        name: 'from_uid',
+        type: 'string',
+        description: 'The uid of the element to drag',
+        required: true,
+      },
+      to_uid: {
+        name: 'to_uid',
+        type: 'string',
+        description: 'The uid of the element to drop into',
+        required: true,
+      },
+      includeSnapshot: {
+        name: 'includeSnapshot',
+        type: 'boolean',
+        description:
+          'Whether to include a snapshot in the response. Default is false.',
+        required: false,
+      },
+    },
+  },
+  emulate: {
+    description: 'Emulates various features on the selected page.',
+    args: {
+      networkConditions: {
+        name: 'networkConditions',
+        type: 'string',
+        description:
+          'Throttle network. Set to "No emulation" to disable. If omitted, conditions remain unchanged.',
+        required: false,
+        enum: [
+          'No emulation',
+          'Offline',
+          'Slow 3G',
+          'Fast 3G',
+          'Slow 4G',
+          'Fast 4G',
+        ],
+      },
+      cpuThrottlingRate: {
+        name: 'cpuThrottlingRate',
+        type: 'number',
+        description:
+          'Represents the CPU slowdown factor. Set the rate to 1 to disable throttling. If omitted, throttling remains unchanged.',
+        required: false,
+      },
+      geolocation: {
+        name: 'geolocation',
+        type: 'string',
+        description:
+          'Geolocation to emulate. Set to null to clear the geolocation override.',
+        required: false,
+      },
+      userAgent: {
+        name: 'userAgent',
+        type: 'string',
+        description:
+          'User agent to emulate. Set to null to clear the user agent override.',
+        required: false,
+      },
+      colorScheme: {
+        name: 'colorScheme',
+        type: 'string',
+        description:
+          'Emulate the dark or the light mode. Set to "auto" to reset to the default.',
+        required: false,
+        enum: ['dark', 'light', 'auto'],
+      },
+      viewport: {
+        name: 'viewport',
+        type: 'string',
+        description:
+          'Viewport to emulate. Set to null to reset to the default viewport.',
+        required: false,
+      },
+    },
+  },
+  evaluate_script: {
+    description:
+      'Evaluate a JavaScript function inside the currently selected page. Returns the response as JSON,\nso returned values have to be JSON-serializable.',
+    args: {
+      function: {
+        name: 'function',
+        type: 'string',
+        description:
+          'A JavaScript function declaration to be executed by the tool in the currently selected page.\nExample without arguments: `() => {\n  return document.title\n}` or `async () => {\n  return await fetch("example.com")\n}`.\nExample with arguments: `(el) => {\n  return el.innerText;\n}`\n',
+        required: true,
+      },
+      args: {
+        name: 'args',
+        type: 'array',
+        description: 'An optional list of arguments to pass to the function.',
+        required: false,
+      },
+    },
+  },
+  fill: {
+    description:
+      'Type text into a input, text area or select an option from a <select> element.',
+    args: {
+      uid: {
+        name: 'uid',
+        type: 'string',
+        description:
+          'The uid of an element on the page from the page content snapshot',
+        required: true,
+      },
+      value: {
+        name: 'value',
+        type: 'string',
+        description: 'The value to fill in',
+        required: true,
+      },
+      includeSnapshot: {
+        name: 'includeSnapshot',
+        type: 'boolean',
+        description:
+          'Whether to include a snapshot in the response. Default is false.',
+        required: false,
+      },
+    },
+  },
+  fill_form: {
+    description: 'Fill out multiple form elements at once',
+    args: {
+      elements: {
+        name: 'elements',
+        type: 'array',
+        description: 'Elements from snapshot to fill out.',
+        required: true,
+      },
+      includeSnapshot: {
+        name: 'includeSnapshot',
+        type: 'boolean',
+        description:
+          'Whether to include a snapshot in the response. Default is false.',
+        required: false,
+      },
+    },
+  },
+  get_console_message: {
+    description:
+      'Gets a console message by its ID. You can get all messages by calling list_console_messages.',
+    args: {
+      msgid: {
+        name: 'msgid',
+        type: 'number',
+        description:
+          'The msgid of a console message on the page from the listed console messages',
+        required: true,
+      },
+    },
+  },
+  get_network_request: {
+    description:
+      'Gets a network request by an optional reqid, if omitted returns the currently selected request in the DevTools Network panel.',
+    args: {
+      reqid: {
+        name: 'reqid',
+        type: 'number',
+        description:
+          'The reqid of the network request. If omitted returns the currently selected request in the DevTools Network panel.',
+        required: false,
+      },
+      requestFilePath: {
+        name: 'requestFilePath',
+        type: 'string',
+        description:
+          'The absolute or relative path to save the request body to. If omitted, the body is returned inline.',
+        required: false,
+      },
+      responseFilePath: {
+        name: 'responseFilePath',
+        type: 'string',
+        description:
+          'The absolute or relative path to save the response body to. If omitted, the body is returned inline.',
+        required: false,
+      },
+    },
+  },
+  handle_dialog: {
+    description:
+      'If a browser dialog was opened, use this command to handle it',
+    args: {
+      action: {
+        name: 'action',
+        type: 'string',
+        description: 'Whether to dismiss or accept the dialog',
+        required: true,
+        enum: ['accept', 'dismiss'],
+      },
+      promptText: {
+        name: 'promptText',
+        type: 'string',
+        description: 'Optional prompt text to enter into the dialog.',
+        required: false,
+      },
+    },
+  },
+  hover: {
+    description: 'Hover over the provided element',
+    args: {
+      uid: {
+        name: 'uid',
+        type: 'string',
+        description:
+          'The uid of an element on the page from the page content snapshot',
+        required: true,
+      },
+      includeSnapshot: {
+        name: 'includeSnapshot',
+        type: 'boolean',
+        description:
+          'Whether to include a snapshot in the response. Default is false.',
+        required: false,
+      },
+    },
+  },
+  list_console_messages: {
+    description:
+      'List all console messages for the currently selected page since the last navigation.',
+    args: {
+      pageSize: {
+        name: 'pageSize',
+        type: 'integer',
+        description:
+          'Maximum number of messages to return. When omitted, returns all requests.',
+        required: false,
+      },
+      pageIdx: {
+        name: 'pageIdx',
+        type: 'integer',
+        description:
+          'Page number to return (0-based). When omitted, returns the first page.',
+        required: false,
+      },
+      types: {
+        name: 'types',
+        type: 'array',
+        description:
+          'Filter messages to only return messages of the specified resource types. When omitted or empty, returns all messages.',
+        required: false,
+      },
+      includePreservedMessages: {
+        name: 'includePreservedMessages',
+        type: 'boolean',
+        description:
+          'Set to true to return the preserved messages over the last 3 navigations.',
+        required: false,
+        default: false,
+      },
+    },
+  },
+  list_network_requests: {
+    description:
+      'List all requests for the currently selected page since the last navigation.',
+    args: {
+      pageSize: {
+        name: 'pageSize',
+        type: 'integer',
+        description:
+          'Maximum number of requests to return. When omitted, returns all requests.',
+        required: false,
+      },
+      pageIdx: {
+        name: 'pageIdx',
+        type: 'integer',
+        description:
+          'Page number to return (0-based). When omitted, returns the first page.',
+        required: false,
+      },
+      resourceTypes: {
+        name: 'resourceTypes',
+        type: 'array',
+        description:
+          'Filter requests to only return requests of the specified resource types. When omitted or empty, returns all requests.',
+        required: false,
+      },
+      includePreservedRequests: {
+        name: 'includePreservedRequests',
+        type: 'boolean',
+        description:
+          'Set to true to return the preserved requests over the last 3 navigations.',
+        required: false,
+        default: false,
+      },
+    },
+  },
+  list_pages: {
+    description: 'Get a list of pages open in the browser.',
+    args: {},
+  },
+  navigate_page: {
+    description: 'Navigates the currently selected page to a URL.',
+    args: {
+      type: {
+        name: 'type',
+        type: 'string',
+        description:
+          'Navigate the page by URL, back or forward in history, or reload.',
+        required: false,
+        enum: ['url', 'back', 'forward', 'reload'],
+      },
+      url: {
+        name: 'url',
+        type: 'string',
+        description: 'Target URL (only type=url)',
+        required: false,
+      },
+      ignoreCache: {
+        name: 'ignoreCache',
+        type: 'boolean',
+        description: 'Whether to ignore cache on reload.',
+        required: false,
+      },
+      handleBeforeUnload: {
+        name: 'handleBeforeUnload',
+        type: 'string',
+        description:
+          'Whether to auto accept or beforeunload dialogs triggered by this navigation. Default is accept.',
+        required: false,
+        enum: ['accept', 'decline'],
+      },
+      initScript: {
+        name: 'initScript',
+        type: 'string',
+        description:
+          'A JavaScript script to be executed on each new document before any other scripts for the next navigation.',
+        required: false,
+      },
+      timeout: {
+        name: 'timeout',
+        type: 'integer',
+        description:
+          'Maximum wait time in milliseconds. If set to 0, the default timeout will be used.',
+        required: false,
+      },
+    },
+  },
+  new_page: {
+    description: 'Creates a new page',
+    args: {
+      url: {
+        name: 'url',
+        type: 'string',
+        description: 'URL to load in a new page.',
+        required: true,
+      },
+      background: {
+        name: 'background',
+        type: 'boolean',
+        description:
+          'Whether to open the page in the background without bringing it to the front. Default is false (foreground).',
+        required: false,
+      },
+      timeout: {
+        name: 'timeout',
+        type: 'integer',
+        description:
+          'Maximum wait time in milliseconds. If set to 0, the default timeout will be used.',
+        required: false,
+      },
+    },
+  },
+  performance_analyze_insight: {
+    description:
+      'Provides more detailed information on a specific Performance Insight of an insight set that was highlighted in the results of a trace recording.',
+    args: {
+      insightSetId: {
+        name: 'insightSetId',
+        type: 'string',
+        description:
+          'The id for the specific insight set. Only use the ids given in the "Available insight sets" list.',
+        required: true,
+      },
+      insightName: {
+        name: 'insightName',
+        type: 'string',
+        description:
+          'The name of the Insight you want more information on. For example: "DocumentLatency" or "LCPBreakdown"',
+        required: true,
+      },
+    },
+  },
+  performance_start_trace: {
+    description:
+      'Starts a performance trace recording on the selected page. This can be used to look for performance problems and insights to improve the performance of the page. It will also report Core Web Vital (CWV) scores for the page.',
+    args: {
+      reload: {
+        name: 'reload',
+        type: 'boolean',
+        description:
+          'Determines if, once tracing has started, the current selected page should be automatically reloaded. Navigate the page to the right URL using the navigate_page tool BEFORE starting the trace if reload or autoStop is set to true.',
+        required: true,
+      },
+      autoStop: {
+        name: 'autoStop',
+        type: 'boolean',
+        description:
+          'Determines if the trace recording should be automatically stopped.',
+        required: true,
+      },
+      filePath: {
+        name: 'filePath',
+        type: 'string',
+        description:
+          'The absolute file path, or a file path relative to the current working directory, to save the raw trace data. For example, trace.json.gz (compressed) or trace.json (uncompressed).',
+        required: false,
+      },
+    },
+  },
+  performance_stop_trace: {
+    description:
+      'Stops the active performance trace recording on the selected page.',
+    args: {
+      filePath: {
+        name: 'filePath',
+        type: 'string',
+        description:
+          'The absolute file path, or a file path relative to the current working directory, to save the raw trace data. For example, trace.json.gz (compressed) or trace.json (uncompressed).',
+        required: false,
+      },
+    },
+  },
+  press_key: {
+    description:
+      'Press a key or key combination. Use this when other input methods like fill() cannot be used (e.g., keyboard shortcuts, navigation keys, or special key combinations).',
+    args: {
+      key: {
+        name: 'key',
+        type: 'string',
+        description:
+          'A key or a combination (e.g., "Enter", "Control+A", "Control++", "Control+Shift+R"). Modifiers: Control, Shift, Alt, Meta',
+        required: true,
+      },
+      includeSnapshot: {
+        name: 'includeSnapshot',
+        type: 'boolean',
+        description:
+          'Whether to include a snapshot in the response. Default is false.',
+        required: false,
+      },
+    },
+  },
+  resize_page: {
+    description:
+      "Resizes the selected page's window so that the page has specified dimension",
+    args: {
+      width: {
+        name: 'width',
+        type: 'number',
+        description: 'Page width',
+        required: true,
+      },
+      height: {
+        name: 'height',
+        type: 'number',
+        description: 'Page height',
+        required: true,
+      },
+    },
+  },
+  select_page: {
+    description: 'Select a page as a context for future tool calls.',
+    args: {
+      pageId: {
+        name: 'pageId',
+        type: 'number',
+        description:
+          'The ID of the page to select. Call list_pages to get available pages.',
+        required: true,
+      },
+      bringToFront: {
+        name: 'bringToFront',
+        type: 'boolean',
+        description: 'Whether to focus the page and bring it to the top.',
+        required: false,
+      },
+    },
+  },
+  take_screenshot: {
+    description: 'Take a screenshot of the page or element.',
+    args: {
+      format: {
+        name: 'format',
+        type: 'string',
+        description:
+          'Type of format to save the screenshot as. Default is "png"',
+        required: false,
+        default: 'png',
+        enum: ['png', 'jpeg', 'webp'],
+      },
+      quality: {
+        name: 'quality',
+        type: 'number',
+        description:
+          'Compression quality for JPEG and WebP formats (0-100). Higher values mean better quality but larger file sizes. Ignored for PNG format.',
+        required: false,
+      },
+      uid: {
+        name: 'uid',
+        type: 'string',
+        description:
+          'The uid of an element on the page from the page content snapshot. If omitted takes a pages screenshot.',
+        required: false,
+      },
+      fullPage: {
+        name: 'fullPage',
+        type: 'boolean',
+        description:
+          'If set to true takes a screenshot of the full page instead of the currently visible viewport. Incompatible with uid.',
+        required: false,
+      },
+      filePath: {
+        name: 'filePath',
+        type: 'string',
+        description:
+          'The absolute path, or a path relative to the current working directory, to save the screenshot to instead of attaching it to the response.',
+        required: false,
+      },
+    },
+  },
+  take_snapshot: {
+    description:
+      'Take a text snapshot of the currently selected page based on the a11y tree. The snapshot lists page elements along with a unique\nidentifier (uid). Always use the latest snapshot. Prefer taking a snapshot over taking a screenshot. The snapshot indicates the element selected\nin the DevTools Elements panel (if any).',
+    args: {
+      verbose: {
+        name: 'verbose',
+        type: 'boolean',
+        description:
+          'Whether to include all possible information available in the full a11y tree. Default is false.',
+        required: false,
+      },
+      filePath: {
+        name: 'filePath',
+        type: 'string',
+        description:
+          'The absolute path, or a path relative to the current working directory, to save the snapshot to instead of attaching it to the response.',
+        required: false,
+      },
+    },
+  },
+  upload_file: {
+    description: 'Upload a file through a provided element.',
+    args: {
+      uid: {
+        name: 'uid',
+        type: 'string',
+        description:
+          'The uid of the file input element or an element that will open file chooser on the page from the page content snapshot',
+        required: true,
+      },
+      filePath: {
+        name: 'filePath',
+        type: 'string',
+        description: 'The local path of the file to upload',
+        required: true,
+      },
+      includeSnapshot: {
+        name: 'includeSnapshot',
+        type: 'boolean',
+        description:
+          'Whether to include a snapshot in the response. Default is false.',
+        required: false,
+      },
+    },
+  },
+  wait_for: {
+    description: 'Wait for the specified text to appear on the selected page.',
+    args: {
+      text: {
+        name: 'text',
+        type: 'string',
+        description: 'Text to appear on the page',
+        required: true,
+      },
+      timeout: {
+        name: 'timeout',
+        type: 'integer',
+        description:
+          'Maximum wait time in milliseconds. If set to 0, the default timeout will be used.',
+        required: false,
+      },
+    },
+  },
+} as const;
diff --git a/src/bin/daemon.ts b/src/bin/daemon.ts
new file mode 100755
index 000000000..327998af8
--- /dev/null
+++ b/src/bin/daemon.ts
@@ -0,0 +1,291 @@
+#!/usr/bin/env node
+
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import fs from 'node:fs/promises';
+import {createServer, type Server} from 'node:net';
+import os from 'node:os';
+import process from 'node:process';
+
+import {Client} from '@modelcontextprotocol/sdk/client/index.js';
+import {StdioClientTransport} from '@modelcontextprotocol/sdk/client/stdio.js';
+
+import {getDaemonPaths, INDEX_SCRIPT_PATH} from './daemonUtils.js';
+
+const {pidFile: PID_FILE, socketPath: SOCKET_PATH} = await getDaemonPaths();
+
+const IS_WINDOWS = os.platform() === 'win32';
+
+let mcpClient: Client | null = null;
+let mcpTransport: StdioClientTransport | null = null;
+let server: Server | null = null;
+
+async function setupMCPClient() {
+  console.log('Setting up MCP client connection...');
+
+  const args = process.argv.slice(2);
+  // Create stdio transport for chrome-devtools-mcp
+  mcpTransport = new StdioClientTransport({
+    command: process.execPath,
+    args: [INDEX_SCRIPT_PATH, ...args],
+    env: process.env as Record<string, string>,
+  });
+  mcpClient = new Client(
+    {
+      name: 'chrome-devtools-cli-daemon',
+      version: '0.1.0',
+    },
+    {
+      capabilities: {},
+    },
+  );
+  await mcpClient.connect(mcpTransport);
+
+  console.log('MCP client connected');
+}
+
+interface McpContent {
+  type: string;
+  text?: string;
+}
+
+interface McpResult {
+  content?: McpContent[] | string;
+  text?: string;
+}
+
+async function handleRequest(message: unknown) {
+  try {
+    if (
+      typeof message !== 'object' ||
+      message === null ||
+      !('method' in message)
+    ) {
+      throw new Error('Invalid message format');
+    }
+
+    const msg = message as {
+      method: string;
+      tool?: string;
+      args?: Record<string, unknown>;
+    };
+
+    if (msg.method === 'invoke_tool') {
+      if (!mcpClient) {
+        throw new Error('MCP client not initialized');
+      }
+      const {tool, args} = msg;
+      if (!tool) {
+        throw new Error('Tool name required');
+      }
+
+      const result = (await mcpClient.callTool({
+        name: tool,
+        arguments: args || {},
+      })) as McpResult | McpContent[];
+
+      // Extract text content from MCP response
+      let textContent = '';
+
+      // Check if result is an array of content blocks
+      if (Array.isArray(result)) {
+        textContent = result
+          .filter(block => block && block.type === 'text' && block.text)
+          .map(block => block.text)
+          .join('\n');
+      }
+      // Check if result has a content property
+      else if (result && result.content) {
+        if (Array.isArray(result.content)) {
+          // Extract text from all text-type content blocks
+          textContent = result.content
+            .filter(block => block && block.type === 'text' && block.text)
+            .map(block => block.text)
+            .join('\n');
+        } else if (typeof result.content === 'string') {
+          textContent = result.content;
+        }
+      }
+      // Check if result has a text property
+      else if (result && result.text) {
+        textContent = result.text;
+      }
+      // Check if result is a string
+      else if (typeof result === 'string') {
+        textContent = result;
+      }
+
+      // Fallback: stringify if we couldn't extract text
+      if (!textContent) {
+        textContent = JSON.stringify(result, null, 2);
+      }
+      return {
+        success: true,
+        result: textContent,
+      };
+    } else if (msg.method === 'stop') {
+      // Trigger cleanup asynchronously
+      setImmediate(() => {
+        void cleanup();
+      });
+      return {
+        success: true,
+        message: 'stopping',
+      };
+    } else {
+      return {
+        success: false,
+        error: `Unknown method: ${msg.method}`,
+      };
+    }
+  } catch (error: unknown) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      error: errorMessage,
+    };
+  }
+}
+
+function startSocketServer() {
+  const startServer = () => {
+    return new Promise<void>((resolve, reject) => {
+      server = createServer(socket => {
+        let buffer = '';
+        socket.on('data', async data => {
+          buffer += data.toString();
+
+          // Try to parse complete JSON messages
+          try {
+            // Check if buffer ends with null terminator
+            if (buffer.endsWith('\0')) {
+              const message = JSON.parse(buffer.slice(0, -1));
+              buffer = ''; // Clear buffer after successful parse
+
+              const response = await handleRequest(message);
+              socket.write(JSON.stringify(response) + '\0');
+              socket.end();
+            }
+          } catch {
+            // Not complete JSON yet, wait for more data
+            if (buffer.includes('\0')) {
+              // Try parsing split by null terminator
+              const parts = buffer.split('\0');
+              buffer = parts.pop() || ''; // Keep incomplete part in buffer
+
+              for (const part of parts) {
+                if (part.trim()) {
+                  try {
+                    const message = JSON.parse(part);
+                    const response = await handleRequest(message);
+                    socket.write(JSON.stringify(response) + '\0');
+                  } catch {
+                    socket.write(
+                      JSON.stringify({success: false, error: 'Invalid JSON'}) +
+                        '\0',
+                    );
+                  }
+                }
+              }
+              socket.end();
+            }
+          }
+        });
+        socket.on('error', error => {
+          console.error('Socket error:', error);
+        });
+      });
+
+      server.listen(SOCKET_PATH, async () => {
+        console.log(`Daemon server listening on ${SOCKET_PATH}`);
+
+        // Write PID file
+        await fs.writeFile(PID_FILE, String(process.pid), 'utf-8');
+
+        try {
+          // Setup MCP client
+          await setupMCPClient();
+          resolve();
+        } catch (err) {
+          reject(err);
+        }
+      });
+
+      server.on('error', error => {
+        console.error('Server error:', error);
+        reject(error);
+      });
+    });
+  };
+
+  // Remove existing socket file if it exists (only on non-Windows)
+  if (!IS_WINDOWS) {
+    return fs
+      .unlink(SOCKET_PATH)
+      .catch(() => {
+        // Ignore if file doesn't exist
+      })
+      .then(() => startServer());
+  } else {
+    return startServer();
+  }
+}
+
+async function cleanup() {
+  console.log('Cleaning up daemon...');
+
+  if (mcpClient) {
+    try {
+      await mcpClient.close();
+    } catch (error) {
+      console.error('Error closing MCP client:', error);
+    }
+  }
+  if (mcpTransport) {
+    try {
+      await mcpTransport.close();
+    } catch (error) {
+      console.error('Error closing MCP transport:', error);
+    }
+  }
+  if (server) {
+    server.close(() => {
+      if (!IS_WINDOWS) {
+        void fs.unlink(SOCKET_PATH).catch(() => undefined);
+      }
+    });
+  }
+  await fs.unlink(PID_FILE).catch(() => undefined);
+  process.exit(0);
+}
+
+// Handle shutdown signals
+process.on('SIGTERM', () => {
+  void cleanup();
+});
+process.on('SIGINT', () => {
+  void cleanup();
+});
+process.on('SIGHUP', () => {
+  void cleanup();
+});
+
+// Handle uncaught errors
+process.on('uncaughtException', error => {
+  console.error('Uncaught exception:', error);
+  void cleanup();
+});
+process.on('unhandledRejection', error => {
+  console.error('Unhandled rejection:', error);
+  void cleanup();
+});
+
+// Start the server
+startSocketServer().catch(error => {
+  console.error('Failed to start daemon server:', error);
+  process.exit(1);
+});
diff --git a/src/bin/daemonClient.ts b/src/bin/daemonClient.ts
new file mode 100644
index 000000000..79b09758f
--- /dev/null
+++ b/src/bin/daemonClient.ts
@@ -0,0 +1,138 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {spawn} from 'node:child_process';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+
+import {DAEMON_SCRIPT_PATH, getDaemonPaths} from './daemonUtils.js';
+
+export async function isDaemonRunning() {
+  try {
+    const {pidFile} = await getDaemonPaths();
+    const pidContent = await fs.readFile(pidFile, 'utf-8');
+    const pid = parseInt(pidContent.trim(), 10);
+
+    if (isNaN(pid)) {
+      return false;
+    }
+    // Check if process is still running (signal 0 doesn't kill, just checks)
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch {
+      // Process doesn't exist
+      return false;
+    }
+  } catch {
+    // PID file doesn't exist or can't be read
+    return false;
+  }
+}
+
+export async function startDaemon(mcpArgs: string[] = []) {
+  if (await isDaemonRunning()) {
+    console.log('Daemon is already running');
+    return;
+  }
+  console.log('Starting daemon...');
+
+  // Spawn daemon server process
+  const child = spawn(process.execPath, [DAEMON_SCRIPT_PATH, ...mcpArgs], {
+    detached: true,
+    stdio: 'inherit',
+    cwd: process.cwd(),
+  });
+  child.unref();
+
+  // Wait a bit for the process to start and write PID
+  await new Promise(resolve => setTimeout(resolve, 500));
+
+  // Verify PID file was created
+  try {
+    const {pidFile} = await getDaemonPaths();
+    const pidContent = await fs.readFile(pidFile, 'utf-8');
+    const pid = parseInt(pidContent.trim(), 10);
+    if (pid === child.pid) {
+      console.log(`Daemon started with PID ${pid}`);
+    }
+  } catch (error: unknown) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.warn('Warning: Could not verify daemon PID file:', errorMessage);
+  }
+}
+
+export async function stopDaemon() {
+  if (!(await isDaemonRunning())) {
+    console.log('Daemon is not running');
+    return;
+  }
+  try {
+    const {pidFile, socketPath} = await getDaemonPaths();
+    const pidContent = await fs.readFile(pidFile, 'utf-8');
+    const pid = parseInt(pidContent.trim(), 10);
+
+    if (isNaN(pid)) {
+      console.log('Invalid PID file');
+      await fs.unlink(pidFile).catch(() => undefined);
+      return;
+    }
+
+    // Try graceful shutdown first
+    try {
+      process.kill(pid, 'SIGTERM');
+
+      // Wait for process to exit
+      let attempts = 0;
+      while (attempts < 10) {
+        await new Promise(resolve => setTimeout(resolve, 100));
+        try {
+          process.kill(pid, 0);
+          attempts++;
+        } catch {
+          // Process has exited
+          break;
+        }
+      }
+
+      // If still running, force kill
+      try {
+        process.kill(pid, 0);
+        process.kill(pid, 'SIGKILL');
+      } catch {
+        // Already dead
+      }
+    } catch {
+      // Process might already be dead
+    }
+
+    // Clean up files
+    await fs.unlink(pidFile).catch(() => undefined);
+    if (os.platform() !== 'win32') {
+      await fs.unlink(socketPath).catch(() => undefined);
+    }
+
+    console.log('Daemon stopped');
+  } catch (error: unknown) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error('Error stopping daemon:', errorMessage);
+    // Try to clean up anyway
+    try {
+      const {pidFile, socketPath} = await getDaemonPaths();
+      await fs.unlink(pidFile).catch(() => undefined);
+      if (os.platform() !== 'win32') {
+        await fs.unlink(socketPath).catch(() => undefined);
+      }
+    } catch {
+      // Ignore errors during cleanup of cleanup
+    }
+  }
+}
+
+export async function getSocketPath() {
+  const {socketPath} = await getDaemonPaths();
+  return socketPath;
+}
diff --git a/src/bin/daemonUtils.ts b/src/bin/daemonUtils.ts
new file mode 100644
index 000000000..49d4f6997
--- /dev/null
+++ b/src/bin/daemonUtils.ts
@@ -0,0 +1,61 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+import {fileURLToPath} from 'node:url';
+
+// Polyfill for import.meta.dirname and import.meta.filename if not available
+// (Node.js < 20.11 / 21.2)
+const _filename = import.meta.filename ?? fileURLToPath(import.meta.url);
+const _dirname = import.meta.dirname ?? path.dirname(_filename);
+
+export const DAEMON_SCRIPT_PATH = path.join(_dirname, 'daemon.js');
+export const INDEX_SCRIPT_PATH = path.join(_dirname, '..', 'index.js');
+
+function getDataHome(): string {
+  if (process.env.XDG_DATA_HOME) {
+    return process.env.XDG_DATA_HOME;
+  }
+  const platform = os.platform();
+  const home = os.homedir();
+
+  switch (platform) {
+    case 'win32':
+      return process.env.APPDATA || path.join(home, 'AppData', 'Roaming');
+    case 'darwin':
+      return path.join(home, 'Library', 'Application Support');
+    default:
+      // linux, etc.
+      return path.join(home, '.local', 'share');
+  }
+}
+
+function getDaemonDir(): string {
+  const dataHome = getDataHome();
+  // Using a vendor-prefixed name for safety/standard practice
+  return path.join(dataHome, 'google', 'chrome-devtools-mcp');
+}
+
+export async function getDaemonPaths() {
+  const daemonDir = getDaemonDir();
+  await fs.mkdir(daemonDir, {recursive: true});
+
+  const pidFile = path.join(daemonDir, 'server.pid');
+
+  const isWindows = os.platform() === 'win32';
+  const socketPath = isWindows
+    ? '\\\\.\\pipe\\chrome-devtools-mcp-daemon'
+    : path.join(daemonDir, 'server.sock');
+
+  return {
+    pidFile,
+    socketPath,
+    daemonDir,
+  };
+}
diff --git a/src/main.ts b/src/main.ts
index e51e4ca98..5abd0331a 100644
--- a/src/main.ts
+++ b/src/main.ts
@@ -257,6 +257,7 @@ for (const tool of tools) {
 await loadIssueDescriptions();
 const transport = new StdioServerTransport();
 await server.connect(transport);
+
 logger('Chrome DevTools MCP Server connected');
 logDisclaimers();
 void clearcutLogger?.logDailyActiveIfNeeded();
diff --git a/tests/daemon.test.ts b/tests/daemon.test.ts
new file mode 100644
index 000000000..aa665c87d
--- /dev/null
+++ b/tests/daemon.test.ts
@@ -0,0 +1,207 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {spawn, execSync} from 'node:child_process';
+import fs from 'node:fs/promises';
+import net from 'node:net';
+import os from 'node:os';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {describe, it, after, before} from 'node:test';
+import assert from 'node:assert';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const DAEMON_SCRIPT = path.join(__dirname, '..', 'src', 'bin', 'daemon.js');
+
+describe('Daemon', () => {
+  let tmpDir: string;
+  let daemonProcess: any;
+
+  before(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcp-daemon-test-'));
+  });
+
+  after(async () => {
+    if (daemonProcess) {
+      try {
+        process.kill(daemonProcess.pid, 0);
+        daemonProcess.kill();
+      } catch {
+        // Process already dead
+      }
+    }
+    await fs.rm(tmpDir, {recursive: true, force: true});
+  });
+
+  it('should terminate chrome instance when transport is closed', async () => {
+    if (os.platform() === 'win32') {
+      // Skip on Windows due to named pipe conflicts in parallel tests
+      return;
+    }
+
+    daemonProcess = spawn(process.execPath, [DAEMON_SCRIPT], {
+      env: {
+        ...process.env,
+        XDG_DATA_HOME: tmpDir,
+      },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    const socketPath = path.join(
+      tmpDir,
+      'google',
+      'chrome-devtools-mcp',
+      'server.sock',
+    );
+
+    // Wait for daemon to be ready
+    await new Promise<void>((resolve, reject) => {
+      const onData = (data: Buffer) => {
+        const output = data.toString();
+        // Wait for MCP client to connect
+        if (output.includes('MCP client connected')) {
+          daemonProcess.stdout.off('data', onData);
+          resolve();
+        }
+      };
+      daemonProcess.stdout.on('data', onData);
+      daemonProcess.stderr.on('data', (data: Buffer) =>
+        console.error('Daemon stderr:', data.toString()),
+      );
+      daemonProcess.on('error', reject);
+      daemonProcess.on('exit', (code: number) => {
+        if (code !== 0 && code !== null)
+          reject(new Error(`Daemon exited with code ${code}`));
+      });
+    });
+
+    // Connect to daemon
+    const socket = net.createConnection(socketPath);
+    await new Promise<void>(resolve => socket.on('connect', resolve));
+
+    // Invoke a tool to trigger browser launch
+    const message =
+      JSON.stringify({
+        method: 'invoke_tool',
+        tool: 'list_pages',
+        args: {},
+      }) + '\0';
+    socket.write(message);
+
+    // Wait for response
+    await new Promise<void>((resolve, reject) => {
+      const onData = (data: Buffer) => {
+        const str = data.toString();
+        // The daemon sends messages terminated by null byte
+        const parts = str.split('\0').filter(p => p.trim());
+        for (const part of parts) {
+           try {
+             const response = JSON.parse(part);
+             if (response.success === true) {
+               socket.off('data', onData);
+               resolve();
+               return;
+             }
+           } catch (e) {
+             console.error('Failed to parse response:', part);
+           }
+        }
+      };
+      socket.on('data', onData);
+      
+      // Timeout if no success response received
+      setTimeout(() => {
+          socket.off('data', onData);
+          reject(new Error('Timeout waiting for tool success response'));
+      }, 5000);
+    });
+
+    // Verify Chrome is running
+    const getAllProcesses = () => {
+        try {
+            const output = execSync('ps -A -o pid,ppid,command').toString();
+            return output.split('\n').slice(1).map(line => {
+                const parts = line.trim().split(/\s+/);
+                const pid = parseInt(parts[0], 10);
+                const ppid = parseInt(parts[1], 10);
+                const command = parts.slice(2).join(' ');
+                return { pid, ppid, command };
+            }).filter(p => !isNaN(p.pid) && !isNaN(p.ppid));
+        } catch (e) {
+            console.error('ps error:', e);
+            return [];
+        }
+    };
+
+    const findDescendants = (rootPid: number) => {
+        const all = getAllProcesses();
+        const descendants = new Set<number>();
+        const queue = [rootPid];
+        
+        // Safety loop break
+        let iterations = 0;
+        while (queue.length > 0 && iterations < 1000) {
+            iterations++;
+            const current = queue.shift()!;
+            const children = all.filter(p => p.ppid === current);
+            for (const child of children) {
+                if (!descendants.has(child.pid)) {
+                    descendants.add(child.pid);
+                    queue.push(child.pid);
+                }
+            }
+        }
+        return Array.from(descendants).map(pid => {
+             return all.find(p => p.pid === pid);
+        }).filter(p => p !== undefined) as { pid: number, ppid: number, command: string }[];
+    };
+
+    const daemonPid = daemonProcess.pid;
+    let chromePids: number[] = [];
+    
+    // Poll for Chrome
+    for (let i = 0; i < 50; i++) {
+        const descendants = findDescendants(daemonPid);
+        const chromeProcesses = descendants.filter(p => p.command.includes('Google Chrome') || p.command.includes('Chromium'));
+        
+        if (chromeProcesses.length > 0) {
+            chromePids = chromeProcesses.map(p => p.pid);
+            break;
+        }
+        await new Promise(r => setTimeout(r, 100));
+    }
+
+    assert.ok(chromePids.length > 0, 'Chrome process not found');
+
+    // Stop daemon
+    const stopMessage = JSON.stringify({method: 'stop'}) + '\0';
+    socket.write(stopMessage);
+
+    // Wait for daemon to exit
+    await new Promise<void>(resolve => daemonProcess.on('exit', resolve));
+
+    // Wait a bit for children to be cleaned up
+    await new Promise(r => setTimeout(r, 1000));
+
+    // Verify Chrome is gone
+    const chromeStillRunning = chromePids.some(pid => {
+      try {
+        process.kill(pid, 0);
+        return true;
+      } catch {
+        return false;
+      }
+    });
+
+    assert.strictEqual(
+      chromeStillRunning,
+      false,
+      'Chrome process should have been terminated',
+    );
+  });
+});