@thegitai/cli 1.0.0-preview.4 → 1.0.0-preview.41

package/README.md

@@ -1,6 +1,6 @@
 # TheGitAI — AI coding agent for your terminal
 
-TheGitAI is an AI coding agent for your terminal. It indexes your repository,
+TheGitAI is an AI coding agent for your terminal. It reads and searches your repository,
 writes and edits files, runs commands, and builds features with you.
 
 Talk to your repo in plain English. TheGitAI can keep long-running processes
@@ -12,14 +12,14 @@ going while you work, all with your approval.
 npm i -g @thegitai/cli
 ```
 
-Requires Node.js 24 or newer.
+Supports Node.js 22 and newer. Node.js 24 is recommended.
 
 ## Usage
 
 ```text
-ai                  start an interactive session in the current repo
+ai                  sign in if needed, then start a session in the current repo
 ai "<request>"      start a session with <request> as the first message
-ai login            sign in via your browser (--no-browser for SSH/headless)
+ai login            the same as `ai`; kept for muscle memory
 ai whoami           show the signed-in account
 ai --usage          show account usage and reset times
 ai logout           sign out
@@ -34,6 +34,51 @@ always be viewed or resumed from that computer. Continuing it through the
 service requires the TheGitAI account used for that session. Local sessions can
 also be listed while signed out or offline.
 
+Signing in opens your browser. The same screen also prints a URL you can open on
+any other device and a box for an authorization code, so SSH and headless
+machines need no separate command: open the URL wherever you have a browser,
+choose "On another computer" on that page, and paste the code it shows.
+
+CLI login tokens use a rolling 48-hour inactivity timeout. If one expires during
+any server request, the CLI removes the expired credential and signs you in
+again on the next run.
+
+## Chrome browser control
+
+The TheGitAI Chrome extension is separately installed. After installing it,
+start `ai` normally and ask about your current tab or a website task. It uses
+your existing Chrome profile, website sessions, and terminal login. Connection
+is automatic; no setup/start command, second sign-in, or manual tab attachment
+is required. Tabs used by the agent join a TheGitAI tab group in an existing
+window. The conversation stays in your terminal.
+
+Default mode asks before using a website and can remember that site for the
+session. Auto-Accept allows browser actions; Plan mode reads pages without
+clicking, typing, or navigating. Use Stop/Resume in the extension popup to
+pause browser control, or Disable to disconnect it. Chrome's protected pages,
+including browser settings and extension management, cannot be controlled.
+
+The extension is currently a development download and is not yet listed in the
+Chrome Web Store. Its version and distribution are independent of this npm
+package. Ubuntu with Chrome is the initial validation target.
+
+## Structured questions
+
+
+The agent can pause its current turn to ask up to four related questions in one
+form. Use **↑ / ↓**, the displayed option number, or **Enter** to choose, and
+**← / →** to move between questions. **Something else / add details** is the
+numbered final option; focus it and type, paste, or press **Enter** to add a
+single-line note. On single-select questions it is mutually exclusive with the
+listed choices, and **↑ / ↓** leaves its editor when the note is empty.
+Multi-select questions toggle choices. The last question has an explicit
+**Submit answers** row. **Esc** closes an open note first and otherwise cancels
+the form; **Ctrl+C** cancels the whole turn.
+
+Answers return to the same turn, and completed question/answer records remain
+readable when the session is resumed. Default, Auto-Accept, and Plan modes all
+support the form; Auto-Accept does not choose answers for you.
+
 ## Visible to-do list
 
 For larger multi-step tasks, the agent keeps a compact to-do list on screen so

package/dist/bin/ai.js

@@ -1,68 +1,49 @@
 #!/usr/bin/env node
 import chalk from '../src/colors.js';
-import { stdin as input, stdout as output } from 'node:process';
-import readline from 'node:readline/promises';
 import { ServerApi } from '../src/api/index.js';
-import { loginViaBrowser } from '../src/api/browser-login.js';
-import { isTransientNetworkError } from '../src/api/http.js';
+import { DEFAULT_THEGITAI_HOST } from '../src/api/default-host.js';
+import { isSignInCancelled } from '../src/api/browser-login.js';
+import { runSignIn } from '../src/signin.js';
+import { STARTUP_RETRY_BUDGET, authenticationErrorMessage, isAuthenticationError, isTransientNetworkError, } from '../src/api/http.js';
 import { formatCliHelpText } from '../src/help-text.js';
-import { createIndex } from '../src/project-index.js';
-import { createSession } from '../src/session.js';
-import { applySessionSnapshot, listSessionMetadata, loadSessionSnapshot, saveSessionState, } from '../src/session-store.js';
+import { createSession, disposeSession } from '../src/session.js';
+import { applySessionSnapshot, listSessionMetadata, loadSessionSnapshot, saveSessionState, sessionHasUserMessage, } from '../src/session-store.js';
 import { runClientInteractive } from '../src/ui/repl.js';
+import { startBrowserDiscoveryInBackground } from '../src/browser/session-bridge.js';
 import { appendPromptToFile } from '../src/ui/prompt-history-store.js';
 import { formatSessionExitNotice } from '../src/session-exit.js';
 import { formatUsageText } from '../src/usage.js';
 import { formatVersionLine } from '../src/version.js';
 import { parseArgs } from '../src/cli-args.js';
-const DEFAULT_SERVER_URL = 'https://thegit.ai';
 const { auth, chat, models, sessions } = ServerApi;
 function printUsage() {
     console.log(formatCliHelpText({ color: process.stdout.isTTY === true }));
 }
-async function promptText(question, fallback = null) {
-    const rl = readline.createInterface({ input, output });
-    try {
-        const suffix = fallback ? ` (${fallback})` : '';
-        const answer = await rl.question(`${question}${suffix}: `);
-        return answer.trim() || fallback || '';
-    }
-    finally {
-        rl.close();
+function unreachableReason(error) {
+    const err = error;
+    const code = err?.code ?? err?.cause?.code;
+    if (err?.name === 'TimeoutError' || err?.name === 'AbortError') {
+        return 'network timeout';
     }
+    if (code === 'ENOTFOUND' || code === 'EAI_AGAIN')
+        return 'DNS lookup failed';
+    if (code === 'ECONNREFUSED')
+        return 'connection refused';
+    if (code === 'ECONNRESET' || code === 'EPIPE')
+        return 'connection reset';
+    return err?.message ? String(err.message) : 'network error';
 }
 function appendPromptHistory(prompt, env = process.env) {
     appendPromptToFile(prompt, env);
 }
-async function runAuthCommand(command, args) {
-    if (command === 'login') {
-        const serverUrl = DEFAULT_SERVER_URL;
-        const noBrowser = args.includes('--no-browser');
-        console.log(chalk.dim(noBrowser
-            ? 'Sign in on the website, then paste the authorization code here.'
-            : 'Opening your browser to sign in…'));
-        const result = await loginViaBrowser({
-            serverUrl,
-            noBrowser,
-            onUrl: (url) => {
-                console.log(chalk.dim(noBrowser ? 'Open this URL to sign in:' : 'If your browser did not open, visit:'));
-                console.log(`  ${url}`);
-            },
-            onWaiting: () => console.log(chalk.dim('Waiting for you to finish signing in…')),
-            promptCode: noBrowser
-                ? () => promptText('Paste the authorization code')
-                : undefined,
-            deviceName: process.env.THEGITAI_DEVICE_NAME?.trim() || undefined,
-        });
-        auth.writeCliAuthConfig(result);
-        console.log(chalk.green(`✓ Logged in as ${result.customer.email}`));
-        console.log(chalk.dim(`Server: ${result.serverUrl}`));
-        console.log(chalk.dim('You can close the browser tab. Run `ai` in a repo to start.'));
-        return;
-    }
+async function runAuthCommand(command) {
     const config = auth.readCliAuthConfig();
     if (!config) {
-        throw new Error('Not logged in. Run `ai login` first.');
+        if (command === 'logout') {
+            console.log(chalk.green('Already signed out.'));
+            return;
+        }
+        throw new Error('Not signed in. Run `ai` to sign in.');
     }
     if (command === 'whoami') {
         const customer = await auth.fetchWhoami({ config });
@@ -70,19 +51,25 @@ async function runAuthCommand(command, args) {
         return;
     }
     if (command === 'logout') {
-        await auth.logoutFromServer({ config });
+        try {
+            await auth.logoutFromServer({ config });
+        }
+        catch {
+        }
         auth.clearCliAuthConfig();
         console.log(chalk.green('Logged out.'));
         return;
     }
     throw new Error(`Unknown auth command: ${command}`);
 }
-function requireCliAuthConfig() {
+async function ensureCliAuthConfig() {
     const config = auth.readCliAuthConfig();
-    if (!config) {
-        throw new Error('Not logged in. Run `ai login` first.');
+    if (config)
+        return config;
+    if (process.stdin.isTTY !== true || process.stdout.isTTY !== true) {
+        throw new Error('Not signed in. Run `ai login` on a terminal to sign in.');
     }
-    return config;
+    return await runSignIn();
 }
 function formatSessionName(name) {
     return name ? `"${name}"` : '(unnamed)';
@@ -116,6 +103,8 @@ function modelLabel(serverModels, modelId) {
         `Model ${modelId}`);
 }
 async function saveSessionBoth({ session, serverSessionClient, }) {
+    if (!sessionHasUserMessage(session))
+        return;
     saveSessionState(session);
     try {
         await serverSessionClient.save(session);
@@ -138,7 +127,7 @@ function requireInteractiveTerminal() {
     return true;
 }
 export async function main() {
-    const { autoYes, help, version, usage, command, commandArgs, session: sessionIdentifier, listSessions, unknownOption, prompt, } = parseArgs(process.argv);
+    const { autoYes, help, version, usage, command, session: sessionIdentifier, listSessions, unknownOption, prompt, } = parseArgs(process.argv);
     if (version) {
         console.log(formatVersionLine());
         return;
@@ -153,18 +142,18 @@ export async function main() {
         process.exitCode = 2;
         return;
     }
-    if (command) {
-        await runAuthCommand(command, commandArgs);
+    if (command && command !== 'login') {
+        await runAuthCommand(command);
         return;
     }
     if (usage) {
-        const authConfig = requireCliAuthConfig();
+        const authConfig = await ensureCliAuthConfig();
         console.log(formatUsageText(await auth.fetchWhoamiResponse({ config: authConfig })));
         return;
     }
     const rootDir = process.cwd();
     if (listSessions) {
-        const activeServerUrl = auth.readCliAuthConfig()?.serverUrl ?? DEFAULT_SERVER_URL;
+        const activeServerUrl = auth.readCliAuthConfig()?.serverUrl ?? DEFAULT_THEGITAI_HOST;
         printSessionList(rootDir, listSessionMetadata(rootDir), models.selectCacheForServer(models.readCachedServerModels(), activeServerUrl));
         return;
     }
@@ -179,44 +168,54 @@ export async function main() {
     if (!requireInteractiveTerminal()) {
         return;
     }
-    const authConfig = requireCliAuthConfig();
+    const authConfig = await ensureCliAuthConfig();
     const serverSessionClient = sessions.createServerSessionClient({ config: authConfig });
     const cachedModels = models.selectCacheForServer(models.readCachedServerModels(), authConfig.serverUrl);
+    const [modelsOutcome, whoamiOutcome] = await Promise.allSettled([
+        models.fetchServerModels({
+            config: authConfig,
+            budget: STARTUP_RETRY_BUDGET,
+        }),
+        auth.fetchWhoamiResponse({
+            config: authConfig,
+            budget: STARTUP_RETRY_BUDGET,
+        }),
+    ]);
     let offlineNotice = null;
     let serverModels;
-    try {
-        serverModels = await models.fetchServerModels({ config: authConfig });
+    if (modelsOutcome.status === 'fulfilled') {
+        serverModels = modelsOutcome.value;
     }
-    catch (error) {
-        if (isTransientNetworkError(error) && cachedModels?.models.length) {
-            serverModels = { models: cachedModels.models };
-            offlineNotice = error?.message ? String(error.message) : 'network error';
-        }
-        else {
-            throw error;
-        }
+    else if (isTransientNetworkError(modelsOutcome.reason) &&
+        cachedModels?.models.length) {
+        serverModels = { models: cachedModels.models };
+        offlineNotice = unreachableReason(modelsOutcome.reason);
+    }
+    else if (isTransientNetworkError(modelsOutcome.reason)) {
+        throw new Error(`Couldn't reach TheGitAI to load your models (${unreachableReason(modelsOutcome.reason)}).\nCheck your internet connection and run \`ai\` again.`);
+    }
+    else {
+        throw modelsOutcome.reason;
     }
     let whoami;
-    try {
-        whoami = await auth.fetchWhoamiResponse({ config: authConfig });
+    if (whoamiOutcome.status === 'fulfilled') {
+        whoami = whoamiOutcome.value;
     }
-    catch (error) {
-        if (isTransientNetworkError(error)) {
-            whoami = {
-                customer: {
-                    id: '',
-                    uuid: '',
-                    email: authConfig.email,
-                    customer_type: authConfig.customerType ?? 'USER',
-                    scopes: [],
-                },
-                debugUi: { showSessionId: false },
-            };
-            offlineNotice ??= error?.message ? String(error.message) : 'network error';
-        }
-        else {
-            throw error;
-        }
+    else if (isTransientNetworkError(whoamiOutcome.reason)) {
+        whoami = {
+            customer: {
+                id: '',
+                uuid: '',
+                email: authConfig.email,
+                customer_type: authConfig.customerType ?? 'USER',
+                scopes: [],
+            },
+            debugUi: { showSessionId: false },
+        };
+        offlineNotice ??= unreachableReason(whoamiOutcome.reason);
+    }
+    else {
+        throw whoamiOutcome.reason;
     }
     if (offlineNotice) {
         console.error(chalk.yellow(`⚠ Couldn't reach TheGitAI (${offlineNotice}). Starting with cached settings — it will reconnect on your next message.`));
@@ -239,35 +238,44 @@ export async function main() {
     if (sourceSnapshot) {
         applySessionSnapshot(session, sourceSnapshot);
     }
-    const projectIndex = createIndex({
-        rootDir,
-        onStatus: (message) => {
-            if (message.trim()) {
-                console.log(chalk.dim(`  ${message}`));
-            }
-        },
-        onContextLog: (message) => {
-            if (message.trim()) {
-                console.log(chalk.cyan(`  ${message}`));
-            }
-        },
-    });
+    startBrowserDiscoveryInBackground({ cwd: rootDir, env: session.env });
     const initialPrompt = prompt || undefined;
-    await runClientInteractive({
-        appendPromptHistory: (value) => appendPromptHistory(value, session.env),
-        authConfig,
-        debugUi: whoami.debugUi,
-        projectIndex,
-        serverModels,
-        serverSessionClient,
-        session,
-        initialPrompt,
-        usageText: async () => formatUsageText(await auth.fetchWhoamiResponse({ config: authConfig })),
-    });
-    await saveSessionBoth({ session, serverSessionClient });
-    printSessionExit(session);
+    try {
+        const outcome = await runClientInteractive({
+            appendPromptHistory: (value) => appendPromptHistory(value, session.env),
+            authConfig,
+            debugUi: whoami.debugUi,
+            serverModels,
+            serverSessionClient,
+            session,
+            initialPrompt,
+            usageText: async () => formatUsageText(await auth.fetchWhoamiResponse({ config: authConfig })),
+        });
+        if (outcome.signedOut) {
+            if (sessionHasUserMessage(session)) {
+                saveSessionState(session);
+            }
+            console.log(chalk.green('\n✓ Logged out.\n'));
+            return;
+        }
+        await saveSessionBoth({ session, serverSessionClient });
+        printSessionExit(session);
+    }
+    finally {
+        await disposeSession(session);
+    }
 }
 main().catch((error) => {
-    console.error(chalk.red(`\n✖ Error: ${error.message}\n`));
+    if (isSignInCancelled(error)) {
+        console.error(chalk.dim('\nSign-in cancelled. Nothing was saved.\n'));
+        process.exit(130);
+    }
+    if (isAuthenticationError(error)) {
+        auth.clearCliAuthConfig();
+        console.error(chalk.red(`\n✖ Error: ${authenticationErrorMessage(error)}\n`));
+    }
+    else {
+        console.error(chalk.red(`\n✖ Error: ${error.message}\n`));
+    }
     process.exit(1);
 });

package/dist/bin/browser-host.js

@@ -0,0 +1,265 @@
+#!/usr/bin/env node
+import { execFileSync } from 'node:child_process';
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import net from 'node:net';
+import path from 'node:path';
+import { decodeFrames, encodeFrame, fragmentPayload, MAX_FRAME_BYTES } from '../src/browser/framing.js';
+import { BROWSER_PROTOCOL_VERSION, browserRuntimeDir, sessionKeyFromRecordFile, sessionSocketPath, socketIsFile, } from '../src/browser/protocol.js';
+const SCAN_INTERVAL_MS = 1000;
+const NUL = String.fromCharCode(0);
+const sessions = new Map();
+const runtimeDir = browserRuntimeDir(process.env);
+let extensionVersion = '';
+let extensionProfileId = '';
+let extensionPlatform = '';
+function log(message) {
+    process.stderr.write(`[thegitai-browser-host] ${message}\n`);
+}
+function writeToExtension(frame) {
+    const payload = Buffer.from(JSON.stringify(frame), 'utf8');
+    if (payload.length > MAX_FRAME_BYTES) {
+        for (const fragment of fragmentPayload(payload, crypto.randomUUID())) {
+            writeToExtension(fragment);
+        }
+        return;
+    }
+    process.stdout.write(encodeFrame(payload));
+}
+let inbound = Buffer.alloc(0);
+process.stdin.on('data', (chunk) => {
+    inbound = Buffer.concat([inbound, Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, 'utf8')]);
+    const { frames, rest, unparseable } = decodeFrames(inbound);
+    inbound = rest;
+    for (let i = 0; i < unparseable; i += 1) {
+        log('discarded an unparseable frame from the extension');
+    }
+    for (const frame of frames)
+        handleExtensionFrame(frame);
+});
+process.stdin.on('end', () => {
+    for (const link of sessions.values())
+        link.socket.destroy();
+    process.exit(0);
+});
+function describeParentBrowser() {
+    const cmdline = process.platform === 'win32' ? windowsParentCommandLine() : unixParentCommandLine();
+    return describeFromCommandLine(cmdline);
+}
+function windowsParentCommandLine() {
+    const PASS_THROUGH = /^(cmd|conhost|powershell|pwsh|node)\.exe$/i;
+    try {
+        const rows = execFileSync('powershell.exe', [
+            '-NoProfile',
+            '-NonInteractive',
+            '-Command',
+            'Get-CimInstance Win32_Process | ForEach-Object {' +
+                ' "{0}`t{1}`t{2}`t{3}" -f $_.ProcessId, $_.ParentProcessId, $_.Name, $_.CommandLine }',
+        ], {
+            encoding: 'utf8',
+            timeout: 15000,
+            maxBuffer: 8 * 1024 * 1024,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        const byPid = new Map();
+        for (const line of rows.split(/\r?\n/)) {
+            const [pid, parent, name, ...rest] = line.split('\t');
+            const id = Number(pid);
+            if (!Number.isInteger(id))
+                continue;
+            byPid.set(id, {
+                parent: Number(parent),
+                name: String(name ?? ''),
+                command: rest.join('\t'),
+            });
+        }
+        let current = byPid.get(process.ppid);
+        for (let hop = 0; hop < 4 && current && PASS_THROUGH.test(current.name); hop += 1) {
+            current = byPid.get(current.parent);
+        }
+        if (!current?.command)
+            return [];
+        return (current.command.match(/"[^"]*"|\S+/g) ?? []).map((token) => token.startsWith('"') && token.endsWith('"') ? token.slice(1, -1) : token);
+    }
+    catch {
+        return [];
+    }
+}
+function unixParentCommandLine() {
+    try {
+        return fs.readFileSync(`/proc/${process.ppid}/cmdline`, 'utf8').split(NUL);
+    }
+    catch {
+        return [];
+    }
+}
+function describeFromCommandLine(cmdline) {
+    try {
+        if (cmdline.length === 0)
+            throw new Error('no command line');
+        const brand = path
+            .basename(cmdline[0] ?? '')
+            .replace(/\.exe$/i, '')
+            .replace(/[-_](browser|stable|beta|dev|unstable|bin)$/i, '')
+            .replace(/[-_]+/g, ' ')
+            .replace(/\b[a-z]/g, (letter) => letter.toUpperCase())
+            .trim() || 'Chrome';
+        const profileArg = cmdline.find((part) => part.startsWith('--profile-directory='));
+        const userDataArg = cmdline.find((part) => part.startsWith('--user-data-dir='));
+        const profile = profileArg ? profileArg.slice('--profile-directory='.length) : 'Default';
+        const suffix = userDataArg
+            ? ` (${path.basename(userDataArg.slice('--user-data-dir='.length))})`
+            : '';
+        return { browser: brand, profile: `${profile}${suffix}` };
+    }
+    catch {
+        return { browser: 'Chrome', profile: 'Default' };
+    }
+}
+const parent = describeParentBrowser();
+function browserKey() {
+    const seed = extensionProfileId || `${parent.browser} ${parent.profile}`;
+    return crypto.createHash('sha256').update(seed).digest('hex').slice(0, 12);
+}
+function identity() {
+    return {
+        key: browserKey(),
+        browser: parent.browser,
+        profile: parent.profile !== 'Default' || !extensionProfileId
+            ? parent.profile
+            : `profile ${extensionProfileId.slice(0, 6)}`,
+        platform: extensionPlatform || process.platform,
+        extensionVersion,
+    };
+}
+function handleExtensionFrame(frame) {
+    if (frame?.t === 'hello') {
+        extensionVersion = String(frame.extensionVersion ?? '');
+        extensionProfileId = String(frame.profileId ?? '');
+        extensionPlatform = String(frame.platform ?? '');
+        writeToExtension({ t: 'hello', protocol: BROWSER_PROTOCOL_VERSION });
+        publishSessions();
+        for (const link of sessions.values())
+            sendHello(link);
+        return;
+    }
+    if (frame?.t === 'res' || frame?.t === 'event') {
+        const target = frame.session ? sessions.get(frame.session) : null;
+        const { session: _routed, ...rest } = frame;
+        if (target) {
+            writeToSession(target, rest);
+            return;
+        }
+        if (frame.t === 'event') {
+            for (const link of sessions.values())
+                writeToSession(link, rest);
+        }
+    }
+}
+function writeToSession(link, frame) {
+    try {
+        link.socket.write(`${JSON.stringify(frame)}\n`);
+    }
+    catch {
+    }
+}
+function sendHello(link) {
+    writeToSession(link, { t: 'hello', protocol: BROWSER_PROTOCOL_VERSION, browser: identity() });
+}
+function publishSessions() {
+    writeToExtension({
+        t: 'sessions',
+        sessions: [...sessions.values()].map((link) => ({
+            session: link.key,
+            label: link.record.label,
+            cwd: link.record.cwd,
+        })),
+    });
+}
+function connectToSession(record, socketPath) {
+    if (sessions.has(record.session))
+        return;
+    const socket = net.createConnection(socketPath);
+    socket.setNoDelay(true);
+    const link = { key: record.session, socket, record };
+    socket.on('connect', () => {
+        sessions.set(record.session, link);
+        sendHello(link);
+        publishSessions();
+        log(`attached to session ${record.session} (${record.cwd})`);
+    });
+    let buffer = '';
+    socket.on('data', (chunk) => {
+        buffer += chunk.toString('utf8');
+        let newline = buffer.indexOf('\n');
+        while (newline !== -1) {
+            const line = buffer.slice(0, newline);
+            buffer = buffer.slice(newline + 1);
+            newline = buffer.indexOf('\n');
+            if (!line.trim())
+                continue;
+            let frame;
+            try {
+                frame = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            writeToExtension({ ...frame, session: record.session });
+        }
+    });
+    const drop = () => {
+        if (sessions.get(record.session) === link) {
+            sessions.delete(record.session);
+            publishSessions();
+        }
+        socket.destroy();
+    };
+    socket.on('close', drop);
+    socket.on('error', () => {
+        drop();
+    });
+}
+function scanForSessions() {
+    let entries;
+    try {
+        entries = fs.readdirSync(runtimeDir);
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const sessionKey = sessionKeyFromRecordFile(entry);
+        if (!sessionKey)
+            continue;
+        const recordPath = path.join(runtimeDir, entry);
+        let record;
+        try {
+            record = JSON.parse(fs.readFileSync(recordPath, 'utf8'));
+        }
+        catch {
+            continue;
+        }
+        if (record.protocol !== BROWSER_PROTOCOL_VERSION)
+            continue;
+        try {
+            process.kill(record.pid, 0);
+        }
+        catch (error) {
+            if (error?.code !== 'EPERM') {
+                try {
+                    fs.unlinkSync(recordPath);
+                    if (socketIsFile())
+                        fs.unlinkSync(sessionSocketPath(runtimeDir, sessionKey));
+                }
+                catch {
+                }
+                continue;
+            }
+        }
+        connectToSession(record, sessionSocketPath(runtimeDir, sessionKey));
+    }
+}
+setInterval(scanForSessions, SCAN_INTERVAL_MS);
+scanForSessions();
+log(`started for ${parent.browser} / ${parent.profile}`);