@crouton-kit/capture 1.3.8 → 1.3.9

package/src/cdp/detect.ts

@@ -118,6 +118,37 @@ function getLocalhostListeningPorts(): number[] {
   }
 }
 
+function getListeningProcessNames(): Map<number, string> {
+  const names = new Map<number, string>();
+  try {
+    const output = execSync('lsof -nP -iTCP -sTCP:LISTEN -Fpcn 2>/dev/null', {
+      encoding: 'utf-8',
+    });
+    let command: string | null = null;
+    for (const line of output.split('\n')) {
+      if (line.startsWith('c')) {
+        command = line.slice(1);
+      } else if (command && line.startsWith('n')) {
+        const match = line.match(/:(\d+)(?:\s|$)/);
+        if (match) names.set(Number(match[1]), command);
+      }
+    }
+  } catch {
+    // Process identity is an optional refinement; CDP probing still works.
+  }
+  return names;
+}
+
+export function identifyBrowserBundleId(browser: string, processName?: string): string {
+  // A listening process is stronger identity than Chromium's generic
+  // Browser/User-Agent strings: Arc and Spotify both report as "Chrome".
+  const identity = (processName ?? browser).toLowerCase();
+  for (const [bundleId, patterns] of Object.entries(BROWSER_PATTERNS)) {
+    if (patterns.some((pattern) => identity.includes(pattern))) return bundleId;
+  }
+  return 'unknown';
+}
+
 export interface CdpEndpoint {
   port: number;
   app: string;
@@ -128,25 +159,18 @@ export interface CdpEndpoint {
 
 export async function detectCdpPortsAsync(): Promise<CdpEndpoint[]> {
   const ports = getLocalhostListeningPorts();
+  const processNames = getListeningProcessNames();
   const results: CdpEndpoint[] = [];
 
   // Probe ports in parallel for speed
   const probes = ports.map(async (port) => {
     const probe = await probeCdpPort(port);
     if (probe) {
-      // Map browser string to bundle ID for default browser matching
-      const lower = probe.browser.toLowerCase();
-      let bundleId = 'unknown';
-      for (const [bid, patterns] of Object.entries(BROWSER_PATTERNS)) {
-        if (patterns.some((p) => lower.includes(p))) {
-          bundleId = bid;
-          break;
-        }
-      }
+      const processName = processNames.get(port);
       results.push({
         port,
-        app: probe.app,
-        bundleId,
+        app: processName ?? probe.app,
+        bundleId: identifyBrowserBundleId(probe.browser, processName),
         isElectron: probe.isElectron,
         hasPageTarget: probe.hasPageTarget,
       });
@@ -179,8 +203,13 @@ export function pickPreferredEndpoint(
     if (match) return match;
   }
 
-  // Fall back to first non-Electron, then first found
-  const nonElectron = candidates.find((p) => !p.isElectron);
+  // Prefer a recognized browser over other Chromium hosts (Spotify, app
+  // shells), then fall back to the original non-Electron ordering.
+  const knownBrowser = candidates.find(
+    (endpoint) => endpoint.bundleId !== 'unknown' && !endpoint.isElectron,
+  );
+  if (knownBrowser) return knownBrowser;
+  const nonElectron = candidates.find((endpoint) => !endpoint.isElectron);
   return nonElectron ?? candidates[0];
 }
 

package/src/cdp/dispatch.ts

@@ -1,40 +1,86 @@
-import { parseCliArgs } from './args.js';
-import { CDP_USAGE } from './usage.js';
-import { cmdDetect, cmdList, cmdOpen, cmdResetTab } from './commands/tabs.js';
-import { cmdExec } from './commands/exec.js';
-import { cmdScreenshot, cmdClick, cmdType, cmdA11y } from './commands/ui.js';
-import { cmdRecord, cmdNavigate, cmdNetwork } from './commands/traffic.js';
-import { cmdHar } from './commands/har.js';
+/**
+ * Shared dispatch for every routed command. Two jobs live here:
+ *
+ *  1. Route each root (`session`, `page`, `tab`, `measure`, `motion`,
+ *     `cdp`, `lib`, hidden `__bridge-serve`) to its branch main.
+ *  2. Invoke the `--gate` guard ONCE for the whole surface: every command
+ *     that is not `measure check|diff` rejects the flag structurally here,
+ *     before any branch main runs.
+ */
+import { parseCliSyntax, resolveCliContext, validateCliInvocation } from './args.js';
+import { type ParsedArgs } from './types.js';
+import { isGateLeaf, rejectUnsupportedGate } from './commands/gate-guard.js';
+import { getActiveSession } from '../session-context.js';
+import { admitSessionOperation } from '../session/coordinator.js';
+import { sessionMain } from '../session/commands.js';
+import { pageMain } from './commands/page/index.js';
+import { tabMain } from './commands/tab/index.js';
 import { cmdLib } from './commands/lib.js';
 import { cmdCdp } from './commands/cdp.js';
 import { cmdBridgeServe } from './commands/bridge-serve.js';
 import { measureMain } from './commands/measure/index.js';
 import { motionMain } from './commands/motion/index.js';
 
+/** The dotted leaf name the gate rejection reports, derived from the parsed
+ * command plus its first positional (the branch-leaf token). */
+function gateLeafName(parsed: ParsedArgs): string {
+  const branch =
+    parsed.command === 'session' ||
+    parsed.command === 'page' ||
+    parsed.command === 'tab' ||
+    parsed.command === 'measure' ||
+    parsed.command === 'motion' ||
+    parsed.command === 'lib';
+  const leaf = parsed.positional[0];
+  return branch && leaf ? `${parsed.command} ${leaf}` : parsed.command;
+}
+
+/**
+ * Registers a session-bound operation (`page`/`measure`/`motion`) with the
+ * lifecycle coordinator BEFORE its first side effect and releases in `finally`,
+ * so a concurrent `session stop` (via `beginSessionStop`) waits for in-flight
+ * artifact writers to drain and excludes any operation that starts after stop
+ * marking (admission throws `session_stopping`). When there is no active
+ * session the operation is a one-shot with nothing to coordinate against, so it
+ * runs unwrapped. The active-session read here is never the first for these
+ * leaves — `resolveCliContext` already hydrated the same session — so it adds
+ * no new active-index side effect on the validation-rejected path.
+ */
+async function withActiveSessionAdmission(parsed: ParsedArgs, run: () => Promise<void>): Promise<void> {
+  const active = getActiveSession();
+  if (!active) return run();
+  const operation = await admitSessionOperation(active.dir);
+  try {
+    return await run();
+  } finally {
+    await operation.release();
+  }
+}
+
 export async function cdpMain(): Promise<void> {
   const args = process.argv.slice(2);
-  const parsed = parseCliArgs(args);
+  const parsed = parseCliSyntax(args);
+
+  if (parsed.gate && !isGateLeaf(parsed)) {
+    rejectUnsupportedGate(parsed, gateLeafName(parsed));
+    return;
+  }
+
+  validateCliInvocation(parsed);
+  const resolved = resolveCliContext(parsed);
 
-  switch (parsed.command) {
-    case 'detect': return cmdDetect(parsed, args);
-    case 'list': return cmdList(parsed, args);
-    case 'open': return cmdOpen(parsed, args);
-    case 'reset-tab': return cmdResetTab(parsed, args);
-    case 'exec': return cmdExec(parsed, args);
-    case 'screenshot': return cmdScreenshot(parsed, args);
-    case 'click': return cmdClick(parsed, args);
-    case 'type': return cmdType(parsed, args);
-    case 'a11y': return cmdA11y(parsed, args);
-    case 'record': return cmdRecord(parsed, args);
-    case 'navigate': return cmdNavigate(parsed, args);
-    case 'network': return cmdNetwork(parsed, args);
-    case 'har': return cmdHar(parsed, args);
-    case 'lib': return cmdLib(parsed, args);
-    case 'cdp': return cmdCdp(parsed, args);
-    case 'measure': return measureMain(parsed, args);
-    case 'motion': return motionMain(parsed, args);
-    case '__bridge-serve': return cmdBridgeServe(parsed, args);
+  switch (resolved.command) {
+    case 'session': return sessionMain(resolved, args);
+    case 'page': return withActiveSessionAdmission(resolved, () => pageMain(resolved, args));
+    case 'tab': return tabMain(resolved, args);
+    case 'lib': return cmdLib(resolved, args);
+    case 'cdp': return cmdCdp(resolved, args);
+    case 'measure': return withActiveSessionAdmission(resolved, () => measureMain(resolved, args));
+    case 'motion': return withActiveSessionAdmission(resolved, () => motionMain(resolved, args));
+    case '__bridge-serve': return cmdBridgeServe(resolved, args);
     default:
-      console.log(CDP_USAGE);
+      // capture.ts routes only the known roots into cdpMain(); an unknown
+      // token gets its structured error there and never reaches this switch.
+      throw new Error(`dispatch: unroutable command ${JSON.stringify(resolved.command)}`);
   }
 }