wtagent 0.1.0-alpha.0 → 0.1.0-alpha.1

package/README.md

@@ -1,21 +1,21 @@
 # WTAgent
 
-Turn ChatGPT Web into a local CLI agent.
+Turn GPT Web into a local CLI agent.
 
-把 ChatGPT 网页版变成一个本地 CLI Agent。
+把 GPT 网页聊天变成一个本地 CLI Agent。
 
 [中文](#中文) · [English](#english)
 
 ## 中文
 
-WTAgent 使用你自己的 ChatGPT Pro 网页会话，提供类似 Codex 的本地 CLI Agent 体验。
+WTAgent 把 GPT 网页聊天连接到本地工具，提供类似 Codex 的 CLI Agent 体验。当前首个适配器支持 ChatGPT Web。
 
-ChatGPT Web 负责思考，WTAgent 在本机：
+网页 GPT 负责思考，WTAgent 在本机：
 
 - 读取和修改本地文件
 - 调用本地 Shell，运行构建、测试和开发服务
 
-不需要 OpenAI API Key。WTAgent 使用独立的 Chrome Profile 保存 ChatGPT 登录状态。
+不需要 OpenAI API Key，也不要求 ChatGPT Pro。WTAgent 使用独立的 Chrome Profile 保存你的网页登录状态，并使用该账号在网页上实际可用的模型和额度；如果账号拥有 Pro，它会成为额外优势。
 
 ### 快速开始
 
@@ -40,18 +40,20 @@ wtagent "检查这个项目并修复测试"
 wtagent -C ./my-project "创建一个网站"
 ```
 
-之后直接在终端中继续对话。WTAgent 会把任务交给 ChatGPT Web，并在本地执行文件和 Shell 操作。
+之后直接在终端中继续对话。WTAgent 会把任务交给 GPT Web，并在本地执行文件和 Shell 操作。使用 `↑` / `↓` 浏览本次 CLI 会话的历史输入。
+
+按 `Ctrl+C` 或 `Ctrl+D` 可退出并关闭专用 Chrome。若上一次异常退出留下了 Chrome，WTAgent 会在验证其 CDP 身份后复用并接管它。
 
 ## English
 
-WTAgent turns your own ChatGPT Pro web session into a Codex-like local CLI agent.
+WTAgent connects GPT Web chat to local tools, providing a Codex-like CLI agent experience. The first adapter currently supports ChatGPT Web.
 
-ChatGPT Web handles reasoning. WTAgent runs locally to:
+GPT Web handles reasoning. WTAgent runs locally to:
 
 - Read and edit local files
 - Run shell commands, builds, tests, and development servers
 
-No OpenAI API key is required. WTAgent stores the ChatGPT session in a dedicated Chrome profile.
+No OpenAI API key or ChatGPT Pro subscription is required. WTAgent stores your web login in a dedicated Chrome profile and uses the models and quota actually available to that account. Pro is an optional bonus when the account has it.
 
 ### Quick start
 
@@ -76,7 +78,9 @@ wtagent "inspect this project and fix the tests"
 wtagent -C ./my-project "build a website"
 ```
 
-Continue chatting in the terminal. WTAgent sends tasks to ChatGPT Web and executes file and shell operations locally.
+Continue chatting in the terminal. WTAgent sends tasks to GPT Web and executes file and shell operations locally. Use `↑` / `↓` to browse input history from the current CLI session.
+
+Press `Ctrl+C` or `Ctrl+D` to exit and close the dedicated Chrome. If an abnormal exit leaves Chrome running, WTAgent verifies and adopts that CDP instance on the next start.
 
 ## License
 

package/docs/technical-design.md

@@ -1,4 +1,4 @@
-# WTAgent：ChatGPT Web 本地工具 Agent 技术方案
+# WTAgent：GPT Web 本地工具 Agent 技术方案
 
 ## 1. 结论
 
@@ -6,7 +6,7 @@
 
 - 用户在终端中选择项目目录并输入开发任务。
 - CLI 启动一个独立、可见、持久化 Profile 的 Chrome。
-- 用户首次在该 Chrome 中手动登录自己的 ChatGPT Pro。
+- 用户首次在该 Chrome 中手动登录自己的 ChatGPT Web 账号；Pro 不是前提，只是账号可用时的额外模型与额度。
 - ChatGPT Web 只负责推理；本地 Runtime 负责工具、权限、状态和恢复。
 - 双方通过普通聊天文本中的自定义 XML 交换工具调用和结果。
 - Runtime 循环执行“网页回复 → 解析工具 → 本地执行 → 回填结果”，直到任务完成。
@@ -626,8 +626,9 @@ sessionId + assistantMessageIdentity + normalizedToolCall
 
 ### 9.3 浏览器恢复
 
-- Chrome 仍在：重新连接 Page 并校验会话 URL。
+- Chrome 仍在：根据专用 Profile、PID、CDP 端口和健康检查验证身份，复用浏览器并创建新的 Page。
 - Chrome 崩溃：用相同 Profile 重启并打开会话 URL。
+- 同一 Profile 同时只允许一个 WTAgent CLI Session；启动和接管过程使用 Profile 级互斥锁。
 - 登录失效或出现验证：进入 `AUTH_REQUIRED`/`PAUSED`，让用户接管。
 - 会话页面丢失：从本地记录打开原会话；无法恢复时创建新的本地 Session 和新的网页对话，不向旧 rollout 继续追加。
 
@@ -686,8 +687,8 @@ Session 界面展示：
 
 用户可随时：
 
-- `Ctrl+C` 第一次请求安全暂停；
-- 再次 `Ctrl+C` 强制终止当前 run；
+- `Ctrl+C` 或 `Ctrl+D` 退出 CLI，并关闭专用 Chrome；
+- 若关闭未完成，保留经过验证的 CDP 状态，下一次启动复用后再次执行关闭；
 - 输入补充指令；
 - 打开浏览器人工接管；
 - 恢复自动化。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wtagent",
-  "version": "0.1.0-alpha.0",
+  "version": "0.1.0-alpha.1",
   "description": "Turn your own web AI session into a local tool-using agent.",
   "repository": {
     "type": "git",

package/src/browser/cdp-browser.js

@@ -2,6 +2,15 @@ import net from "node:net";
 import { spawn } from "node:child_process";
 import { chromium } from "playwright-core";
 import { killProcessTree } from "../tools/process-utils.js";
+import {
+  acquireCdpProfileLock,
+  discoverReusableCdpState,
+  fetchCdpVersion,
+  processMatchesCdpState,
+  removeCdpState,
+  saveCdpState,
+  waitForProcessExit,
+} from "./cdp-state.js";
 
 async function reservePort() {
   return await new Promise((resolve, reject) => {
@@ -22,6 +31,20 @@ async function reservePort() {
   });
 }
 
+async function settleWithin(promise, timeoutMs) {
+  let timer;
+  try {
+    await Promise.race([
+      Promise.resolve(promise).catch(() => null),
+      new Promise((resolve) => {
+        timer = setTimeout(resolve, timeoutMs);
+      }),
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
 async function waitForCdp({
   endpoint,
   child,
@@ -42,7 +65,7 @@ async function waitForCdp({
       if (response.ok) {
         const version = await response.json();
         if (version.webSocketDebuggerUrl) {
-          return;
+          return version;
         }
       }
     } catch (error) {
@@ -57,21 +80,6 @@ async function waitForCdp({
   );
 }
 
-async function waitForExit(child, timeoutMs) {
-  if (child.exitCode != null || child.signalCode != null) {
-    return true;
-  }
-
-  return await new Promise((resolve) => {
-    const timer = setTimeout(() => resolve(false), timeoutMs);
-    timer.unref?.();
-    child.once("close", () => {
-      clearTimeout(timer);
-      resolve(true);
-    });
-  });
-}
-
 // Sets the OS window state (e.g. "minimized" / "normal") of the window hosting
 // `page` via the CDP Browser domain. On macOS the Chromium launch flags for
 // minimizing (--start-minimized) and off-screen positioning are ignored or
@@ -101,41 +109,100 @@ export async function launchAndConnectCdpChrome({
   profileDir,
   url = "about:blank",
   minimized = false,
-}) {
-  const port = await reservePort();
-  const endpoint = `http://127.0.0.1:${port}`;
-  const child = spawn(
-    executablePath,
-    [
-      `--remote-debugging-port=${port}`,
-      "--remote-debugging-address=127.0.0.1",
-      `--user-data-dir=${profileDir}`,
-      "--profile-directory=Default",
-      "--no-first-run",
-      "--no-default-browser-check",
-      url,
-    ],
-    {
-      detached: process.platform !== "win32",
-      stdio: "ignore",
-      windowsHide: false,
-    },
-  );
+}, {
+  acquireProfileLock = acquireCdpProfileLock,
+  connectOverCDP = (endpoint) => chromium.connectOverCDP(endpoint),
+  discoverReusable = discoverReusableCdpState,
+  fetchVersion = fetchCdpVersion,
+  killTree = killProcessTree,
+  matchesState = processMatchesCdpState,
+  removeState = removeCdpState,
+  reserveCdpPort = reservePort,
+  saveState = saveCdpState,
+  spawnChrome = spawn,
+  waitForExit = waitForProcessExit,
+  waitForReady = waitForCdp,
+} = {}) {
+  const releaseProfileLock = await acquireProfileLock(profileDir);
+  let child = null;
+  let state = null;
+  let browser = null;
+  let closePromise = null;
+  let reused = false;
 
-  await new Promise((resolve, reject) => {
-    child.once("spawn", resolve);
-    child.once("error", reject);
-  });
+  async function findReusable() {
+    return await discoverReusable(profileDir, { fetchVersion });
+  }
 
   try {
-    await waitForCdp({ endpoint, child });
-    const browser = await chromium.connectOverCDP(endpoint);
+    state = await findReusable();
+    if (state) {
+      reused = true;
+    } else {
+      await removeState(profileDir);
+      const port = await reserveCdpPort();
+      const endpoint = `http://127.0.0.1:${port}`;
+      child = spawnChrome(
+        executablePath,
+        [
+          `--remote-debugging-port=${port}`,
+          "--remote-debugging-address=127.0.0.1",
+          `--user-data-dir=${profileDir}`,
+          "--profile-directory=Default",
+          "--no-first-run",
+          "--no-default-browser-check",
+          url,
+        ],
+        {
+          detached: process.platform !== "win32",
+          stdio: "ignore",
+          windowsHide: false,
+        },
+      );
+
+      await new Promise((resolve, reject) => {
+        child.once("spawn", resolve);
+        child.once("error", reject);
+      });
+
+      try {
+        const version = await waitForReady({ endpoint, child });
+        state = await saveState(profileDir, {
+          pid: child.pid,
+          port,
+          endpoint,
+          profileDir,
+          browser: version.Browser ?? null,
+          webSocketDebuggerUrl: version.webSocketDebuggerUrl,
+        });
+      } catch (error) {
+        // Chrome may forward the URL to an existing process using the same
+        // profile and then exit successfully. Re-scan after that handoff and
+        // adopt the verified live CDP instance instead of reporting a false
+        // launch failure.
+        if (child.exitCode === 0 && child.signalCode == null) {
+          state = await findReusable();
+          if (state) {
+            reused = true;
+          }
+        }
+        if (!state) {
+          throw error;
+        }
+      }
+    }
+
+    browser = await connectOverCDP(state.endpoint);
     const context = browser.contexts()[0];
     if (!context) {
       throw new Error("Chrome CDP connection did not expose a browser context.");
     }
 
-    const page = context.pages()[0] ?? await context.newPage();
+    // A reused browser may still contain the previous conversation. Keep it
+    // intact and create a fresh target for this CLI session.
+    const page = reused
+      ? await context.newPage()
+      : context.pages()[0] ?? await context.newPage();
     if (minimized) {
       await setWindowState(context, page, "minimized");
     }
@@ -144,27 +211,75 @@ export async function launchAndConnectCdpChrome({
       browser,
       context,
       child,
-      endpoint,
+      endpoint: state.endpoint,
+      page,
+      pid: state.pid,
+      reused,
       // Minimize / restore the visible window on demand. The runtime restores
       // the window when it needs the user (manual login, CAPTCHA) and
       // re-minimizes afterward. Uses the live current page each time so it
       // targets the window the user is actually looking at.
       async minimize() {
-        return await setWindowState(context, context.pages()[0] ?? page, "minimized");
+        return await setWindowState(context, page, "minimized");
       },
       async restore() {
-        return await setWindowState(context, context.pages()[0] ?? page, "normal");
+        return await setWindowState(context, page, "normal");
       },
       async close() {
-        await browser.close().catch(() => null);
-        if (!await waitForExit(child, 2_000)) {
-          await killProcessTree(child.pid);
-          await waitForExit(child, 2_000);
+        if (closePromise) {
+          return await closePromise;
         }
+        closePromise = (async () => {
+          let exited = false;
+          try {
+            // browser.close() on a connectOverCDP browser only disconnects the
+            // Playwright transport. Browser.close asks Chrome itself to exit.
+            const session = await browser.newBrowserCDPSession()
+              .catch(() => null);
+            if (session) {
+              await settleWithin(session.send("Browser.close"), 1_500);
+              await settleWithin(session.detach(), 500);
+            }
+            exited = await waitForExit(state.pid, 3_000);
+            await settleWithin(browser.close(), 1_500);
+
+            if (!exited) {
+              const childStillOwnsPid = child?.pid === state.pid
+                && child.exitCode == null
+                && child.signalCode == null;
+              const safeToKill = childStillOwnsPid
+                || await matchesState(state);
+              if (safeToKill) {
+                await killTree(state.pid);
+                exited = await waitForExit(state.pid, 3_000);
+              }
+            }
+
+            if (exited) {
+              await removeState(profileDir, state);
+              return;
+            }
+            throw new Error(
+              `Chrome pid=${state.pid} did not exit; its verified CDP state `
+              + "was kept so the next WTAgent run can reuse it.",
+            );
+          } finally {
+            await releaseProfileLock();
+          }
+        })();
+        return await closePromise;
       },
     };
   } catch (error) {
-    await killProcessTree(child.pid);
+    await browser?.close().catch(() => null);
+    if (
+      child
+      && child.exitCode == null
+      && child.signalCode == null
+    ) {
+      await killTree(child.pid);
+    }
+    await releaseProfileLock();
     throw error;
   }
 }

package/src/browser/cdp-state.js

@@ -0,0 +1,399 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+const CDP_STATE_FILE = ".wtagent-cdp.json";
+const PROFILE_LOCK_FILE = ".wtagent-session.lock";
+const STATE_VERSION = 1;
+const LOCK_INITIALIZATION_GRACE_MS = 5_000;
+
+function statePath(profileDir) {
+  return path.join(profileDir, CDP_STATE_FILE);
+}
+
+function lockPath(profileDir) {
+  return path.join(profileDir, PROFILE_LOCK_FILE);
+}
+
+async function readJson(filePath) {
+  try {
+    return JSON.parse(await fs.readFile(filePath, "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT" || error instanceof SyntaxError) {
+      return null;
+    }
+    throw error;
+  }
+}
+
+async function writeJsonAtomic(filePath, value) {
+  const temporary = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    await fs.writeFile(
+      temporary,
+      `${JSON.stringify(value, null, 2)}\n`,
+      { mode: 0o600 },
+    );
+    await fs.rename(temporary, filePath);
+  } finally {
+    await fs.rm(temporary, { force: true }).catch(() => {});
+  }
+}
+
+async function readInitializedLock(filePath) {
+  for (let attempt = 0; attempt < 10; attempt += 1) {
+    const value = await readJson(filePath);
+    if (
+      Number.isSafeInteger(Number(value?.pid))
+      && Number(value.pid) > 0
+      && typeof value.token === "string"
+      && value.token
+    ) {
+      return value;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 25));
+  }
+  return null;
+}
+
+export function isProcessAlive(pid) {
+  if (!Number.isSafeInteger(pid) || pid <= 0) {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+
+export async function waitForProcessExit(
+  pid,
+  timeoutMs,
+  { isAlive = isProcessAlive } = {},
+) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!isAlive(pid)) {
+      return true;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  return !isAlive(pid);
+}
+
+export async function fetchCdpVersion(endpoint, timeoutMs = 1_500) {
+  const response = await fetch(`${endpoint}/json/version`, {
+    signal: AbortSignal.timeout(timeoutMs),
+  });
+  if (!response.ok) {
+    throw new Error(`CDP health check returned HTTP ${response.status}.`);
+  }
+  const version = await response.json();
+  if (!version.webSocketDebuggerUrl) {
+    throw new Error("CDP health check did not return a WebSocket endpoint.");
+  }
+  return version;
+}
+
+function normalizeCandidate(candidate, profileDir) {
+  const pid = Number(candidate?.pid);
+  const port = Number(candidate?.port);
+  if (
+    !Number.isSafeInteger(pid)
+    || pid <= 0
+    || !Number.isSafeInteger(port)
+    || port <= 0
+    || port > 65_535
+  ) {
+    return null;
+  }
+  if (
+    candidate.profileDir
+    && path.resolve(candidate.profileDir) !== profileDir
+  ) {
+    return null;
+  }
+  return {
+    stateVersion: STATE_VERSION,
+    pid,
+    port,
+    endpoint: `http://127.0.0.1:${port}`,
+    profileDir,
+    startedAt: candidate.startedAt ?? null,
+  };
+}
+
+async function probeCandidate(candidate, profileDir, {
+  isAlive = isProcessAlive,
+  fetchVersion = fetchCdpVersion,
+} = {}) {
+  const normalized = normalizeCandidate(candidate, profileDir);
+  if (!normalized || !isAlive(normalized.pid)) {
+    return null;
+  }
+  try {
+    const version = await fetchVersion(normalized.endpoint);
+    if (
+      candidate.webSocketDebuggerUrl
+      && candidate.webSocketDebuggerUrl !== version.webSocketDebuggerUrl
+    ) {
+      return null;
+    }
+    return {
+      ...normalized,
+      browser: version.Browser ?? null,
+      webSocketDebuggerUrl: version.webSocketDebuggerUrl,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export async function readCdpState(profileDir) {
+  return await readJson(statePath(path.resolve(profileDir)));
+}
+
+export async function saveCdpState(profileDir, state) {
+  const resolvedProfile = path.resolve(profileDir);
+  const normalized = normalizeCandidate(state, resolvedProfile);
+  if (!normalized) {
+    throw new Error("Refusing to save invalid WTAgent CDP state.");
+  }
+  const value = {
+    ...normalized,
+    browser: state.browser ?? null,
+    webSocketDebuggerUrl: state.webSocketDebuggerUrl ?? null,
+    startedAt: state.startedAt ?? new Date().toISOString(),
+  };
+  await writeJsonAtomic(statePath(resolvedProfile), value);
+  return value;
+}
+
+export async function removeCdpState(profileDir, expected = null) {
+  const filePath = statePath(path.resolve(profileDir));
+  if (expected) {
+    const current = await readJson(filePath);
+    if (
+      current
+      && (
+        Number(current.pid) !== Number(expected.pid)
+        || Number(current.port) !== Number(expected.port)
+      )
+    ) {
+      return false;
+    }
+  }
+  await fs.rm(filePath, { force: true });
+  return true;
+}
+
+async function readProcessTable() {
+  if (process.platform === "win32") {
+    const { stdout } = await execFileAsync(
+      "powershell.exe",
+      [
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        "Get-CimInstance Win32_Process | Select-Object ProcessId,CommandLine | ConvertTo-Json -Compress",
+      ],
+      { maxBuffer: 10 * 1024 * 1024 },
+    );
+    const parsed = JSON.parse(stdout || "[]");
+    return (Array.isArray(parsed) ? parsed : [parsed]).map((entry) => ({
+      pid: Number(entry.ProcessId),
+      command: String(entry.CommandLine ?? ""),
+    }));
+  }
+
+  const { stdout } = await execFileAsync(
+    "ps",
+    ["-axo", "pid=,command="],
+    { maxBuffer: 10 * 1024 * 1024 },
+  );
+  return stdout.split("\n").flatMap((line) => {
+    const match = line.match(/^\s*(\d+)\s+(.+)$/);
+    return match
+      ? [{ pid: Number(match[1]), command: match[2] }]
+      : [];
+  });
+}
+
+function commandUsesProfile(command, profileDir) {
+  return (
+    command.includes(`--user-data-dir=${profileDir}`)
+    || command.includes(`--user-data-dir="${profileDir}"`)
+    || command.includes(`--user-data-dir='${profileDir}'`)
+  );
+}
+
+function candidateFromProcess(entry, profileDir) {
+  if (
+    !entry.command
+    || entry.command.includes("--type=")
+    || !commandUsesProfile(entry.command, profileDir)
+  ) {
+    return null;
+  }
+  const port = entry.command.match(/--remote-debugging-port=(\d+)/)?.[1];
+  return port
+    ? { pid: entry.pid, port: Number(port), profileDir }
+    : null;
+}
+
+async function singletonOwnerPid(profileDir) {
+  if (process.platform === "win32") {
+    return null;
+  }
+  try {
+    const target = await fs.readlink(path.join(profileDir, "SingletonLock"));
+    const pid = Number(target.match(/-(\d+)$/)?.[1]);
+    return Number.isSafeInteger(pid) && pid > 0 ? pid : null;
+  } catch {
+    return null;
+  }
+}
+
+export async function processMatchesCdpState(state) {
+  const profileDir = path.resolve(state.profileDir);
+  const port = Number(state.port);
+  try {
+    const processes = await readProcessTable();
+    return processes.some((entry) => {
+      const candidate = candidateFromProcess(entry, profileDir);
+      return (
+        candidate?.pid === Number(state.pid)
+        && candidate.port === port
+      );
+    });
+  } catch {
+    return false;
+  }
+}
+
+export async function discoverReusableCdpState(profileDir, {
+  isAlive = isProcessAlive,
+  fetchVersion = fetchCdpVersion,
+  listProcesses = readProcessTable,
+} = {}) {
+  const resolvedProfile = path.resolve(profileDir);
+  const saved = await readCdpState(resolvedProfile);
+  const savedHealthy = await probeCandidate(saved, resolvedProfile, {
+    isAlive,
+    fetchVersion,
+  });
+  if (savedHealthy) {
+    return await saveCdpState(resolvedProfile, savedHealthy);
+  }
+
+  let processes;
+  try {
+    processes = await listProcesses();
+  } catch {
+    return null;
+  }
+
+  const rawCandidates = processes
+    .map((entry) => candidateFromProcess(entry, resolvedProfile))
+    .filter(Boolean);
+  const uniqueCandidates = [...new Map(
+    rawCandidates.map((candidate) => [
+      `${candidate.pid}:${candidate.port}`,
+      candidate,
+    ]),
+  ).values()];
+  const healthy = (await Promise.all(
+    uniqueCandidates.map((candidate) =>
+      probeCandidate(candidate, resolvedProfile, {
+        isAlive,
+        fetchVersion,
+      })
+    ),
+  )).filter(Boolean);
+
+  if (healthy.length === 0) {
+    return null;
+  }
+  if (healthy.length === 1) {
+    return await saveCdpState(resolvedProfile, healthy[0]);
+  }
+
+  const ownerPid = await singletonOwnerPid(resolvedProfile);
+  const singleton = healthy.find((candidate) => candidate.pid === ownerPid);
+  if (singleton) {
+    return await saveCdpState(resolvedProfile, singleton);
+  }
+
+  throw new Error(
+    `Multiple live CDP Chrome instances use ${resolvedProfile}; `
+    + "close the extra instances before starting WTAgent.",
+  );
+}
+
+export async function acquireCdpProfileLock(profileDir, {
+  ownerPid = process.pid,
+  isAlive = isProcessAlive,
+} = {}) {
+  const resolvedProfile = path.resolve(profileDir);
+  const filePath = lockPath(resolvedProfile);
+  const token = randomUUID();
+
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    try {
+      const handle = await fs.open(filePath, "wx", 0o600);
+      try {
+        await handle.writeFile(
+          `${JSON.stringify({
+            pid: ownerPid,
+            token,
+            createdAt: new Date().toISOString(),
+          })}\n`,
+        );
+      } finally {
+        await handle.close();
+      }
+
+      let released = false;
+      return async () => {
+        if (released) {
+          return;
+        }
+        released = true;
+        const current = await readJson(filePath);
+        if (current?.token === token) {
+          await fs.rm(filePath, { force: true });
+        }
+      };
+    } catch (error) {
+      if (error.code !== "EEXIST") {
+        throw error;
+      }
+      const existing = await readInitializedLock(filePath);
+      if (existing && isAlive(Number(existing.pid))) {
+        throw new Error(
+          `Another WTAgent session (pid=${existing.pid}) is already using `
+          + `${resolvedProfile}.`,
+        );
+      }
+      if (!existing) {
+        const stat = await fs.stat(filePath).catch(() => null);
+        if (
+          stat
+          && Date.now() - stat.mtimeMs < LOCK_INITIALIZATION_GRACE_MS
+        ) {
+          throw new Error(
+            `The WTAgent profile lock at ${filePath} is still being initialized.`,
+          );
+        }
+      }
+      await fs.rm(filePath, { force: true });
+    }
+  }
+
+  throw new Error(`Could not acquire the WTAgent profile lock at ${filePath}.`);
+}

package/src/browser/chatgpt-web-adapter.js

@@ -78,7 +78,7 @@ export class ChatGPTWebAdapter {
       minimized: this.minimized,
     });
     this.context = this.cdpChrome.context;
-    this.page = this.context.pages()[0] ?? await this.context.newPage();
+    this.page = this.cdpChrome.page;
     this.page.setDefaultTimeout(15_000);
     this.page.setDefaultNavigationTimeout(60_000);
     await this.page.goto(this.baseUrl, { waitUntil: "domcontentloaded" });
@@ -456,9 +456,20 @@ export class ChatGPTWebAdapter {
         }
 
         const stopVisible = await this.#isStopButtonVisible();
+        // If the reply looks like protocol XML, never accept it until BOTH the
+        // opening and closing tags are present. During streaming the text can
+        // briefly go quiet (or the stop button flip off) after "<agent_response"
+        // is painted but before "</agent_response>" arrives; accepting there
+        // hands the parser a truncated envelope. Non-protocol chatter (no
+        // "<agent_response") is unaffected and still completes on the stable
+        // window below.
+        const looksLikeProtocol = lastText.includes("<agent_response");
+        const envelopeReady = !looksLikeProtocol
+          || hasCompleteAgentEnvelope(lastText);
         if (
           lastText.trim()
           && stableSince > 0
+          && envelopeReady
           && (
             (
               !stopVisible

package/src/cli/main.js

@@ -2,7 +2,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { Command } from "commander";
-import { confirm, input } from "@inquirer/prompts";
+import { confirm } from "@inquirer/prompts";
 import { ChatGPTWebAdapter } from "../browser/chatgpt-web-adapter.js";
 import { launchNativeLoginBrowser } from "../browser/native-login.js";
 import {
@@ -21,6 +21,12 @@ import { ProcessManager } from "../tools/process-manager.js";
 import { resolveLimits } from "../shared/limits.js";
 import { EXPORTERS } from "../session/session-export.js";
 import { extractAtMentions } from "./at-files.js";
+import {
+  classifyChatInput,
+  promptForText,
+  readChatMessage,
+  ShellChatInput,
+} from "./prompt-input.js";
 import { createRenderer } from "./render-events.js";
 
 function resolveRuntimePaths(options) {
@@ -55,10 +61,13 @@ async function runLogin(options) {
     });
 
     try {
-      await input({
+      const answer = await promptForText({
         message:
           "After the signed-in ChatGPT home is visible, press Enter here to save and verify",
       });
+      if (answer == null) {
+        return;
+      }
       console.log("Closing native Chrome and saving the dedicated profile...");
       await new Promise((resolve) => setTimeout(resolve, 1_000));
     } finally {
@@ -242,7 +251,9 @@ class ConversationRunner {
     this.closed = true;
     this.renderer.finish();
     await this.processManager.stopAll().catch(() => {});
-    await this.adapter.close().catch(() => {});
+    await this.adapter.close().catch((error) => {
+      console.error(`Warning: ${error.message}`);
+    });
   }
 }
 
@@ -252,6 +263,7 @@ async function executeSession({
   resume = false,
   instruction = null,
   files = [],
+  chatInput = null,
 }) {
   const paths = resolveRuntimePaths(options);
   await ensureDirectory(paths.sessionsDir);
@@ -259,7 +271,7 @@ async function executeSession({
 
   const onInterrupt = async () => {
     if (runner.interrupted) {
-      process.exit(130);
+      return;
     }
     runner.interrupted = true;
     runner.renderer.stopSpinner();
@@ -270,6 +282,11 @@ async function executeSession({
   process.on("SIGINT", onInterrupt);
 
   const interactive = !options.once && process.stdin.isTTY && process.stdout.isTTY;
+  const activeChatInput = chatInput
+    ?? (interactive ? new ShellChatInput() : null);
+  if (instruction) {
+    activeChatInput?.remember(instruction);
+  }
 
   try {
     runner.renderer.hint(`Session ID: ${session.sessionId}`);
@@ -303,7 +320,7 @@ async function executeSession({
         }
       }
 
-      const next = await promptForNextMessage(runner);
+      const next = await promptForNextMessage(runner, activeChatInput);
       if (next == null) {
         break;
       }
@@ -315,34 +332,37 @@ async function executeSession({
     return null;
   } finally {
     process.removeListener("SIGINT", onInterrupt);
+    activeChatInput?.close();
     await runner.close();
     console.log(`Session saved at: ${session.directory}`);
   }
 }
 
-// Reads the user's next message from the interactive prompt. Returns null when
-// the user wants to end the conversation (blank line, exit/quit, or EOF), or
+// Reads the user's next message from the interactive prompt. Empty input simply
+// re-prompts. Returns null for an explicit exit command, Ctrl+C, Ctrl+D, or EOF;
+// otherwise returns
 // { text, files } where files are resolved @file attachments.
-async function promptForNextMessage(runner) {
+async function promptForNextMessage(runner, chatInput) {
   for (;;) {
-    let answer;
-    try {
-      answer = await input({
+    const answer = chatInput
+      ? await chatInput.read()
+      : await promptForText({
         message: "you ›",
         theme: { prefix: "" },
       });
-    } catch {
+    if (answer == null) {
       // Ctrl+C / Ctrl+D inside the prompt ends the conversation cleanly.
       runner.renderer.println("");
       return null;
     }
-    const text = String(answer ?? "").trim();
-    if (!text) {
-      return null;
+    const classified = classifyChatInput(answer);
+    if (classified.kind === "empty") {
+      continue;
     }
-    if (["exit", "quit", ":q", "/exit", "/quit"].includes(text.toLowerCase())) {
+    if (classified.kind === "exit") {
       return null;
     }
+    const { text } = classified;
     const files = await resolveMessageAttachments(runner, text);
     return { text, files };
   }
@@ -370,6 +390,7 @@ async function runAgent(taskParts, options) {
   const projectRoot = path.resolve(options.project ?? process.cwd());
   await assertDirectory(projectRoot);
   const interactive = !options.once && process.stdin.isTTY && process.stdout.isTTY;
+  const chatInput = interactive ? new ShellChatInput() : null;
 
   // In interactive mode an initial task is optional: the user can just start
   // typing at the prompt. In one-shot mode a task is required.
@@ -378,13 +399,21 @@ async function runAgent(taskParts, options) {
     if (interactive) {
       printChatBanner(projectRoot, options.mode);
     }
-    task = (await input({
-      message: interactive ? "you ›" : "Task",
-      theme: interactive ? { prefix: "" } : undefined,
-      validate: (value) => value.trim() ? true : "Please type a message.",
-    })).trim();
+    const initialMessage = interactive
+      ? await readChatMessage(() => chatInput.read())
+      : await promptForText({
+        message: "Task",
+        validate: (value) => value.trim() ? true : "Please type a message.",
+      });
+    if (initialMessage == null) {
+      chatInput?.close();
+      console.log("");
+      return null;
+    }
+    task = initialMessage.trim();
   } else if (interactive) {
     printChatBanner(projectRoot, options.mode);
+    chatInput.remember(task);
   }
 
   const paths = resolveRuntimePaths(options);
@@ -413,7 +442,7 @@ async function runAgent(taskParts, options) {
     }
   }
 
-  return await executeSession({ session, options, files });
+  return await executeSession({ session, options, files, chatInput });
 }
 
 function printChatBanner(projectRoot, mode) {
@@ -421,8 +450,8 @@ function printChatBanner(projectRoot, mode) {
   const DIM = "\x1b[2m";
   const RESET = "\x1b[0m";
   console.log("");
-  console.log(`${CYAN}WTAgent${RESET} ${DIM}· ChatGPT ${mode ?? "Pro"} · ${projectRoot}${RESET}`);
-  console.log(`${DIM}Type a message and press Enter. Blank line, "exit", or Ctrl+C to quit.${RESET}`);
+  console.log(`${CYAN}WTAgent${RESET} ${DIM}· GPT Web · ${projectRoot}${RESET}`);
+  console.log(`${DIM}Enter sends · ↑/↓ history · "exit", Ctrl+C, or Ctrl+D quits${RESET}`);
   console.log("");
 }
 
@@ -546,7 +575,7 @@ async function runExport(sessionId, options) {
 const program = new Command()
   .name("wtagent")
   .description("Turn your web AI session into a local tool-using agent.")
-  .version("0.1.0-alpha.0")
+  .version("0.1.0-alpha.1")
   .option("--home <path>", "Application data directory")
   .option("--profile-dir <path>", "Dedicated Chrome profile directory")
   .option("--chrome-path <path>", "Chrome/Chromium executable")

package/src/cli/prompt-input.js

@@ -0,0 +1,152 @@
+import { input } from "@inquirer/prompts";
+import { createInterface } from "node:readline/promises";
+
+const CLEAN_EXIT_ERRORS = new Set([
+  "AbortPromptError",
+  "ExitPromptError",
+]);
+const EXIT_COMMANDS = new Set([
+  "exit",
+  "quit",
+  ":q",
+  "/exit",
+  "/quit",
+]);
+
+export function classifyChatInput(value) {
+  const text = String(value ?? "").trim();
+  if (!text) {
+    return { kind: "empty", text: "" };
+  }
+  if (EXIT_COMMANDS.has(text.toLowerCase())) {
+    return { kind: "exit", text };
+  }
+  return { kind: "message", text };
+}
+
+export async function readChatMessage(read) {
+  for (;;) {
+    const answer = await read();
+    if (answer == null) {
+      return null;
+    }
+    const classified = classifyChatInput(answer);
+    if (classified.kind === "empty") {
+      continue;
+    }
+    if (classified.kind === "exit") {
+      return null;
+    }
+    return classified.text;
+  }
+}
+
+export class ShellChatInput {
+  constructor({
+    inputStream = process.stdin,
+    outputStream = process.stdout,
+    historySize = 100,
+  } = {}) {
+    this.inputStream = inputStream;
+    this.outputStream = outputStream;
+    this.historySize = historySize;
+    this.history = [];
+  }
+
+  remember(value) {
+    const text = String(value ?? "").trim();
+    if (!text) {
+      return;
+    }
+    this.history = [
+      text,
+      ...this.history.filter((entry) => entry !== text),
+    ].slice(0, this.historySize);
+  }
+
+  async read(prompt = " you › ") {
+    if (this.inputStream.readableEnded) {
+      return null;
+    }
+
+    const readline = createInterface({
+      input: this.inputStream,
+      output: this.outputStream,
+      terminal: true,
+      historySize: this.historySize,
+      removeHistoryDuplicates: true,
+    });
+    readline.history = [...this.history];
+
+    const controller = new AbortController();
+    let closed = false;
+    const onClose = () => {
+      closed = true;
+      controller.abort();
+    };
+    const onInterrupt = () => readline.close();
+    readline.once("close", onClose);
+    readline.on("SIGINT", onInterrupt);
+
+    try {
+      const answer = await readline.question(prompt, {
+        signal: controller.signal,
+      });
+      this.history = readline.history.slice(0, this.historySize);
+      return answer;
+    } catch (error) {
+      if (closed || error?.name === "AbortError") {
+        return null;
+      }
+      throw error;
+    } finally {
+      readline.removeListener("close", onClose);
+      readline.removeListener("SIGINT", onInterrupt);
+      readline.close();
+    }
+  }
+
+  close() {
+    // Each readline instance is scoped to one question and is closed in read().
+    // This method keeps ownership explicit for callers and future extensions.
+  }
+}
+
+export async function promptForText(config, {
+  prompt = input,
+  inputStream = process.stdin,
+  outputStream = process.stdout,
+} = {}) {
+  if (inputStream.readableEnded) {
+    return null;
+  }
+
+  const controller = new AbortController();
+  let reachedEof = false;
+  const onEof = () => {
+    reachedEof = true;
+    controller.abort();
+  };
+
+  inputStream.once("end", onEof);
+  inputStream.once("close", onEof);
+
+  try {
+    return await prompt(config, {
+      input: inputStream,
+      output: outputStream,
+      signal: controller.signal,
+    });
+  } catch (error) {
+    if (
+      reachedEof
+      || CLEAN_EXIT_ERRORS.has(error?.name)
+    ) {
+      return null;
+    }
+    throw error;
+  } finally {
+    inputStream.removeListener("end", onEof);
+    inputStream.removeListener("close", onEof);
+  }
+}