chrome-control-proxy 1.0.0

package/lib/browser-controller.js

@@ -0,0 +1,182 @@
+const { exec } = require('child_process');
+const os = require('os');
+const path = require('path');
+const log = require('./logger');
+
+const CHROME_PORT = process.env.CHROME_PORT || 9222;
+const CHROME_PROFILE_DIR =
+  process.env.CHROME_PROFILE_DIR || path.join(os.homedir(), '.chrome-control-proxy', 'chrome-cdp');
+const CHROME_BINARY =
+  process.env.CHROME_BINARY ||
+  '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome';
+
+function runCommand(command) {
+  return new Promise((resolve) => {
+    log.debug('browser', `exec: ${command.slice(0, 200)}${command.length > 200 ? '…' : ''}`);
+    exec(command, { shell: '/bin/bash' }, (error, stdout, stderr) => {
+      const out = {
+        ok: !error,
+        code: error ? error.code : 0,
+        stdout: stdout?.trim() || '',
+        stderr: stderr?.trim() || '',
+      };
+      if (!out.ok) {
+        log.debug('browser', `exec exit ${out.code}`, out.stderr || error?.message);
+      }
+      resolve(out);
+    });
+  });
+}
+
+async function getChromeStatus() {
+  const checkPortCmd = `lsof -nP -iTCP:${CHROME_PORT} -sTCP:LISTEN`;
+  const result = await runCommand(checkPortCmd);
+
+  if (!result.ok || !result.stdout) {
+    return {
+      running: false,
+      port: Number(CHROME_PORT),
+      pid: null,
+      raw: result.stdout || '',
+    };
+  }
+
+  const lines = result.stdout.split('\n').filter(Boolean);
+  const chromeLine = lines.find((line) => line.includes('Google Chrome') || line.includes('Chrome'));
+
+  if (!chromeLine) {
+    return {
+      running: true,
+      port: Number(CHROME_PORT),
+      pid: null,
+      raw: result.stdout,
+    };
+  }
+
+  const parts = chromeLine.trim().split(/\s+/);
+  const pid = parts[1] ? Number(parts[1]) : null;
+
+  return {
+    running: true,
+    port: Number(CHROME_PORT),
+    pid,
+    raw: chromeLine,
+  };
+}
+
+function buildStartChromeCommand() {
+  return [
+    'nohup',
+    `"${CHROME_BINARY}"`,
+    `--remote-debugging-port=${CHROME_PORT}`,
+    `--user-data-dir="${CHROME_PROFILE_DIR}"`,
+    '--lang=zh-CN',
+    '--disable-dev-shm-usage',
+    '--no-first-run',
+    '--no-default-browser-check',
+    '>/tmp/chrome-cdp.log 2>&1 &',
+  ].join(' ');
+}
+
+async function startChrome() {
+  log.info('browser', 'startChrome requested');
+  const status = await getChromeStatus();
+  if (status.running) {
+    log.info('browser', 'Chrome already running', { port: CHROME_PORT });
+    return {
+      changed: false,
+      message: 'Chrome is already running',
+      status,
+    };
+  }
+
+  await runCommand(`mkdir -p "${CHROME_PROFILE_DIR}"`);
+  const cmd = buildStartChromeCommand();
+  log.info('browser', 'launching Chrome', { port: CHROME_PORT, profile: CHROME_PROFILE_DIR });
+  const result = await runCommand(cmd);
+
+  await new Promise((r) => setTimeout(r, 15000));
+  const nextStatus = await getChromeStatus();
+  log.info('browser', 'startChrome done', { running: nextStatus.running, commandOk: result.ok });
+
+  return {
+    changed: true,
+    message: nextStatus.running
+      ? 'Chrome started successfully'
+      : 'Chrome start command executed, but browser is not confirmed running yet',
+    commandOk: result.ok,
+    status: nextStatus,
+    stderr: result.stderr,
+  };
+}
+
+function resetPlaywrightConnectionLazy() {
+  log.info('browser', 'reset Playwright CDP connection (Chrome stopped)');
+  require('./playwright-controller').resetPlaywrightConnection();
+}
+
+async function stopChrome() {
+  log.info('browser', 'stopChrome requested');
+  const status = await getChromeStatus();
+  if (!status.running) {
+    log.info('browser', 'Chrome not running, skip stop');
+    return {
+      changed: false,
+      message: 'Chrome is not running',
+      status,
+    };
+  }
+
+  let result;
+  if (status.pid) {
+    log.info('browser', `sending SIGTERM to Chrome pid ${status.pid}`);
+    result = await runCommand(`kill ${status.pid}`);
+    await new Promise((r) => setTimeout(r, 1000));
+  } else {
+    log.info('browser', 'no pid, using pkill pattern for Chrome');
+    result = await runCommand(`pkill -f "Google Chrome.*--remote-debugging-port=${CHROME_PORT}"`);
+    await new Promise((r) => setTimeout(r, 1000));
+  }
+
+  const nextStatus = await getChromeStatus();
+  log.info('browser', 'stopChrome done', { stillRunning: nextStatus.running });
+
+  if (!nextStatus.running) {
+    resetPlaywrightConnectionLazy();
+  }
+
+  return {
+    changed: true,
+    message: nextStatus.running
+      ? 'Chrome stop command executed, but browser still appears to be running'
+      : 'Chrome stopped successfully',
+    commandOk: result.ok,
+    status: nextStatus,
+    stderr: result.stderr,
+  };
+}
+
+async function restartChrome() {
+  log.info('browser', 'restartChrome requested');
+  const stopResult = await stopChrome();
+  await new Promise((r) => setTimeout(r, 1200));
+  const startResult = await startChrome();
+  log.info('browser', 'restartChrome completed');
+
+  return {
+    changed: true,
+    message: 'Chrome restart completed',
+    stop: stopResult,
+    start: startResult,
+  };
+}
+
+module.exports = {
+  CHROME_PORT,
+  CHROME_PROFILE_DIR,
+  CHROME_BINARY,
+  getChromeStatus,
+  startChrome,
+  stopChrome,
+  restartChrome,
+};

package/lib/logger.js

@@ -0,0 +1,192 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const LEVELS = { error: 0, warn: 1, info: 2, debug: 3 };
+const LOG_LEVEL = (process.env.LOG_LEVEL || 'info').toLowerCase();
+const threshold = LEVELS[LOG_LEVEL] !== undefined ? LEVELS[LOG_LEVEL] : 2;
+
+const PREFIX = '[chrome-control-proxy]';
+const LOG_DIR = process.env.LOG_DIR || '';
+const LOG_CONSOLE = !/^(0|false|no)$/i.test(String(process.env.LOG_CONSOLE ?? 'true'));
+const LOG_MAX_FILE_MB = Math.max(0, Number(process.env.LOG_MAX_FILE_MB) || 0);
+const LOG_MAX_BYTES = LOG_MAX_FILE_MB > 0 ? Math.floor(LOG_MAX_FILE_MB * 1024 * 1024) : 0;
+
+let fileStream = null;
+let streamDateKey = null;
+let streamPart = 0;
+let bytesInCurrentFile = 0;
+
+function ts() {
+  return new Date().toISOString();
+}
+
+function dateKey() {
+  return new Date().toISOString().slice(0, 10);
+}
+
+function formatErr(e) {
+  if (e === undefined || e === null) {
+    return '';
+  }
+  if (e instanceof Error) {
+    return `${e.message}\n${e.stack || ''}`;
+  }
+  if (typeof e === 'object') {
+    try {
+      return JSON.stringify(e);
+    } catch {
+      return String(e);
+    }
+  }
+  return String(e);
+}
+
+function fmtMeta(meta) {
+  if (meta === undefined || meta === null) {
+    return '';
+  }
+  if (typeof meta === 'object' && !(meta instanceof Error)) {
+    try {
+      return JSON.stringify(meta);
+    } catch {
+      return String(meta);
+    }
+  }
+  return String(meta);
+}
+
+function buildFileText(level, ns, msg, extra) {
+  let text = `${PREFIX} ${ts()} [${level}] [${ns}] ${msg}`;
+  if (extra !== undefined && extra !== '') {
+    if (level === 'error') {
+      text += `\n${formatErr(extra)}`;
+    } else {
+      text += ` ${fmtMeta(extra)}`;
+    }
+  }
+  return `${text}\n`;
+}
+
+function fileNameForPart(dk, part) {
+  return part === 0
+    ? `ccp-${dk}.log`
+    : `ccp-${dk}.${part}.log`;
+}
+
+function openNewStream(dk, part) {
+  fs.mkdirSync(LOG_DIR, { recursive: true });
+  const fullPath = path.join(LOG_DIR, fileNameForPart(dk, part));
+  return fs.createWriteStream(fullPath, { flags: 'a' });
+}
+
+function closeFileStreamSync() {
+  if (!fileStream) {
+    return;
+  }
+  try {
+    fileStream.end();
+  } catch (_) {
+    /* */
+  }
+  fileStream = null;
+}
+
+function closeFileStream() {
+  return new Promise((resolve) => {
+    if (!fileStream) {
+      resolve();
+      return;
+    }
+    const s = fileStream;
+    fileStream = null;
+    streamDateKey = null;
+    streamPart = 0;
+    bytesInCurrentFile = 0;
+    s.end(() => resolve());
+  });
+}
+
+function ensureFileStreamBeforeWrite(chunkByteLength) {
+  const dk = dateKey();
+
+  if (!fileStream) {
+    streamDateKey = dk;
+    streamPart = 0;
+    bytesInCurrentFile = 0;
+    fileStream = openNewStream(streamDateKey, streamPart);
+    return;
+  }
+
+  if (streamDateKey !== dk) {
+    closeFileStreamSync();
+    streamDateKey = dk;
+    streamPart = 0;
+    bytesInCurrentFile = 0;
+    fileStream = openNewStream(streamDateKey, streamPart);
+    return;
+  }
+
+  if (
+    LOG_MAX_BYTES > 0 &&
+    bytesInCurrentFile + chunkByteLength > LOG_MAX_BYTES &&
+    bytesInCurrentFile > 0
+  ) {
+    closeFileStreamSync();
+    streamPart += 1;
+    bytesInCurrentFile = 0;
+    fileStream = openNewStream(streamDateKey, streamPart);
+  }
+}
+
+function writeFileLog(level, ns, msg, extra) {
+  if (!LOG_DIR) {
+    return;
+  }
+  const chunk = buildFileText(level, ns, msg, extra);
+  const bufLen = Buffer.byteLength(chunk, 'utf8');
+
+  try {
+    ensureFileStreamBeforeWrite(bufLen);
+    if (fileStream) {
+      fileStream.write(chunk);
+      bytesInCurrentFile += bufLen;
+    }
+  } catch (e) {
+    console.error(`${PREFIX} logger file sink error`, e);
+  }
+}
+
+function emit(level, ns, msg, extra) {
+  if (LEVELS[level] > threshold) {
+    return;
+  }
+  const line = `${PREFIX} ${ts()} [${level}] [${ns}] ${msg}`;
+  if (LOG_CONSOLE) {
+    if (level === 'error') {
+      console.error(line, extra !== undefined && extra !== '' ? formatErr(extra) : '');
+    } else if (level === 'warn') {
+      console.warn(line, extra !== undefined ? fmtMeta(extra) : '');
+    } else {
+      console.log(line, extra !== undefined ? fmtMeta(extra) : '');
+    }
+  }
+  writeFileLog(level, ns, msg, extra);
+}
+
+module.exports = {
+  error(ns, msg, err) {
+    emit('error', ns, msg, err);
+  },
+  warn(ns, msg, meta) {
+    emit('warn', ns, msg, meta);
+  },
+  info(ns, msg, meta) {
+    emit('info', ns, msg, meta);
+  },
+  debug(ns, msg, meta) {
+    emit('debug', ns, msg, meta);
+  },
+  closeFileSink: closeFileStream,
+};