@tiens.nguyen/gu-cli 1.0.833 → 1.0.835

package/browser-extension/background.js

@@ -0,0 +1,261 @@
+// gu browser — the Chrome side of the agent's browser tool (task #363, GitHub #144).
+//
+// The extension connects to gu's local bridge (browser-bridge.mjs, ws://127.0.0.1:4127) and runs
+// the commands the agent sends. Input goes through chrome.debugger (the DevTools protocol), so a
+// click is a real mouse press and release at a point, and typing is real key input, the way a
+// person would do it, not el.click().
+//
+// gu only works in ITS OWN tabs: the ones it opened (kept in a tab group named "gu"), the popups
+// those open, and a tab the user shares from the popup ("Let gu use this tab", #150). The user's
+// other tabs are never read, captured or controlled. What each command does is in actions.js,
+// shared with gu's own Chrome window (browser-chrome.mjs).
+
+import { enableDomains, forgetTab, onCdpEvent, runAction } from "./actions.js";
+
+const DEFAULT_PORT = 4127;
+const VERSION = chrome.runtime.getManifest().version;
+
+let ws = null;
+let connecting = false; // set before the first await: startup fires connect() several times at once
+let pingTimer = null;
+const attached = new Set();
+
+// ── connection ──────────────────────────────────────────────────────────────────────────────
+async function bridgePort() {
+  try {
+    const { port } = await chrome.storage.local.get("port");
+    return Number(port) || DEFAULT_PORT;
+  } catch {
+    return DEFAULT_PORT;
+  }
+}
+
+async function connect() {
+  if (connecting || (ws && (ws.readyState === WebSocket.CONNECTING || ws.readyState === WebSocket.OPEN))) return;
+  connecting = true;
+  let sock;
+  try {
+    sock = new WebSocket(`ws://127.0.0.1:${await bridgePort()}/extension`);
+  } catch {
+    return;
+  } finally {
+    connecting = false;
+  }
+  ws = sock;
+  sock.onopen = async () => {
+    sock.send(JSON.stringify({ type: "hello", version: VERSION, installType: await installType() }));
+    setBadge(true);
+    clearInterval(pingTimer);
+    // An open socket that carries a message at least every 30 s keeps the service worker awake.
+    pingTimer = setInterval(() => sock.readyState === WebSocket.OPEN && sock.send('{"type":"ping"}'), 20000);
+  };
+  sock.onmessage = (ev) => onCommand(sock, ev.data);
+  sock.onclose = (ev) => {
+    if (ws !== sock) return; // an older socket the bridge replaced
+    ws = null;
+    clearInterval(pingTimer);
+    setBadge(false);
+    // 4001: another gu extension (the store copy next to a developer one) has the bridge.
+    // Retry slowly instead of every 3 s; the alarm keeps trying too (#148).
+    setTimeout(connect, ev.code === 4001 ? 30000 : 3000);
+  };
+  sock.onerror = () => {};
+}
+
+// "development" = loaded unpacked (Developer mode); "normal" = from the Chrome Web Store (#146).
+// getSelf needs no "management" permission.
+async function installType() {
+  try {
+    return (await chrome.management.getSelf()).installType;
+  } catch {
+    return "unknown";
+  }
+}
+
+function setBadge(on) {
+  chrome.action.setBadgeText({ text: on ? "on" : "" }).catch(() => {});
+  chrome.action.setBadgeBackgroundColor({ color: "#6d5bd0" }).catch(() => {});
+}
+
+// The service worker sleeps when nothing happens; the alarm wakes it to retry the bridge.
+chrome.alarms.create("gu-connect", { periodInMinutes: 0.5 });
+chrome.alarms.onAlarm.addListener(() => connect());
+chrome.runtime.onStartup.addListener(() => connect());
+chrome.runtime.onInstalled.addListener(() => connect());
+chrome.runtime.onMessage.addListener((msg, _sender, reply) => {
+  if (msg?.type === "status") {
+    reply({ connected: Boolean(ws && ws.readyState === WebSocket.OPEN), version: VERSION });
+  } else if (msg?.type === "reconnect") {
+    connect().then(() => reply({ ok: true }));
+    return true;
+  } else if (msg?.type === "tabState") {
+    state().then((s) => reply({ shared: s.tabs.includes(msg.tabId) }));
+    return true;
+  } else if (msg?.type === "share") {
+    // "Let gu use this tab" (#150): the user hands gu a tab of their own.
+    addToGroup(msg.tabId)
+      .then(() => saveState({ current: msg.tabId }))
+      .then(() => reply({ ok: true }), (e) => reply({ ok: false, error: String(e?.message || e) }));
+    return true;
+  } else if (msg?.type === "unshare") {
+    unshare(msg.tabId).then(() => reply({ ok: true }));
+    return true;
+  }
+  return false;
+});
+connect();
+
+async function onCommand(sock, data) {
+  let msg;
+  try {
+    msg = JSON.parse(data);
+  } catch {
+    return;
+  }
+  if (!msg || msg.id === undefined) return;
+  let reply;
+  try {
+    reply = { id: msg.id, ok: true, result: await run(msg) };
+  } catch (e) {
+    reply = { id: msg.id, ok: false, error: String(e?.message || e) };
+  }
+  if (sock.readyState === WebSocket.OPEN) sock.send(JSON.stringify(reply));
+}
+
+// ── gu's tabs ───────────────────────────────────────────────────────────────────────────────
+async function state() {
+  const s = await chrome.storage.session.get(["tabs", "current", "group"]);
+  return { tabs: s.tabs || [], current: s.current ?? null, group: s.group ?? null };
+}
+
+async function saveState(patch) {
+  await chrome.storage.session.set(patch);
+}
+
+async function liveTabs() {
+  const s = await state();
+  const live = [];
+  for (const id of s.tabs) {
+    try {
+      live.push(await chrome.tabs.get(id));
+    } catch {
+      /* closed */
+    }
+  }
+  if (live.length !== s.tabs.length) await saveState({ tabs: live.map((t) => t.id) });
+  return live;
+}
+
+async function addToGroup(tabId) {
+  const s = await state();
+  let group = s.group;
+  try {
+    group = await chrome.tabs.group(group != null ? { tabIds: [tabId], groupId: group } : { tabIds: [tabId] });
+  } catch {
+    group = await chrome.tabs.group({ tabIds: [tabId] }); // the old group was closed
+  }
+  await chrome.tabGroups.update(group, { title: "gu", color: "purple" }).catch(() => {});
+  const tabs = s.tabs.includes(tabId) ? s.tabs : [...s.tabs, tabId];
+  await saveState({ tabs, group });
+}
+
+// "Stop sharing": the tab leaves the group, gu lets go of it, and never touches it again.
+async function unshare(tabId) {
+  const s = await state();
+  await saveState({ tabs: s.tabs.filter((t) => t !== tabId), current: s.current === tabId ? null : s.current });
+  await chrome.tabs.ungroup(tabId).catch(() => {});
+  if (attached.has(tabId)) await chrome.debugger.detach({ tabId }).catch(() => {});
+  attached.delete(tabId);
+  forgetTab(tabId);
+}
+
+// A page gu opened that opens another (target=_blank, window.open) — that one is gu's too.
+chrome.tabs.onCreated.addListener(async (tab) => {
+  const s = await state();
+  if (tab.openerTabId != null && s.tabs.includes(tab.openerTabId)) {
+    await addToGroup(tab.id).catch(() => {});
+    await saveState({ current: tab.id });
+  }
+});
+
+// ── DevTools protocol ───────────────────────────────────────────────────────────────────────
+function cdp(tabId, method, params = {}) {
+  return chrome.debugger.sendCommand({ tabId }, method, params);
+}
+
+chrome.debugger.onDetach.addListener((src) => attached.delete(src.tabId));
+chrome.debugger.onEvent.addListener((src, method, params) => onCdpEvent(src.tabId, method, params, cdp));
+chrome.tabs.onRemoved.addListener((tabId) => {
+  attached.delete(tabId);
+  forgetTab(tabId);
+});
+
+// The host actions.js runs on: chrome.tabs + chrome.debugger, in the user's own Chrome.
+const host = {
+  cdp,
+  async attach(tabId) {
+    if (attached.has(tabId)) return;
+    try {
+      await chrome.debugger.attach({ tabId }, "1.3");
+    } catch (e) {
+      if (!/already attached/i.test(String(e?.message))) {
+        throw new Error(`cannot control this tab (${e?.message || e}) — Chrome pages (chrome://, the Web Store) cannot be automated`);
+      }
+    }
+    attached.add(tabId);
+    await enableDomains(cdp, tabId);
+  },
+  async open(url, newTab) {
+    const tabs = await liveTabs();
+    const s = await state();
+    let tab = newTab ? null : tabs.find((t) => t.id === s.current) || tabs[tabs.length - 1];
+    if (tab) tab = await chrome.tabs.update(tab.id, { url, active: true });
+    else {
+      tab = await chrome.tabs.create({ url, active: true });
+      await addToGroup(tab.id);
+    }
+    await saveState({ current: tab.id });
+    await chrome.windows.update(tab.windowId, { focused: true }).catch(() => {});
+    return tab.id;
+  },
+  async tabs() {
+    const s = await state();
+    return (await liveTabs()).map((t) => ({ id: t.id, title: t.title, url: t.url, current: t.id === s.current }));
+  },
+  async switchTo(tabId) {
+    const id = Number(tabId);
+    if (!(await liveTabs()).some((t) => t.id === id)) return false;
+    await chrome.tabs.update(id, { active: true });
+    await saveState({ current: id });
+    return true;
+  },
+  async current() {
+    const tabs = await liveTabs();
+    if (!tabs.length) throw new Error('gu has no tab open yet — use action "open" with a url first');
+    const s = await state();
+    return (tabs.find((t) => t.id === s.current) || tabs[tabs.length - 1]).id;
+  },
+  async info(tabId) {
+    const t = await chrome.tabs.get(tabId).catch(() => null);
+    return t ? { url: t.url, title: t.title, status: t.status } : null;
+  },
+  async activate(tabId) {
+    await chrome.tabs.update(tabId, { active: true });
+  },
+  async close(tabId) {
+    await chrome.tabs.remove(tabId);
+  },
+};
+
+async function run(cmd) {
+  const a = String(cmd.action || "").toLowerCase();
+  if (a === "status") return { version: VERSION, installType: await installType() };
+  if (a === "uninstall_self") {
+    // /browser cleanup (#147): a developer copy removes itself. Never the store copy — that one
+    // the user removes, or keeps.
+    if ((await installType()) !== "development") throw new Error("this is not a developer (unpacked) install — not removed");
+    setTimeout(() => chrome.management.uninstallSelf({ showConfirmDialog: false }).catch(() => {}), 200);
+    return { uninstalling: chrome.runtime.id };
+  }
+  return runAction(cmd, host);
+}

package/browser-extension/manifest.json

@@ -0,0 +1,37 @@
+{
+  "manifest_version": 3,
+  "name": "gu browser",
+  "version": "1.0.1",
+  "description": "Lets the gu coding agent open, see and operate web pages in its own tabs (tab group \"gu\") with a real mouse and keyboard.",
+  "minimum_chrome_version": "116",
+  "icons": {
+    "16": "icons/icon16.png",
+    "32": "icons/icon32.png",
+    "48": "icons/icon48.png",
+    "128": "icons/icon128.png"
+  },
+  "permissions": [
+    "debugger",
+    "tabs",
+    "tabGroups",
+    "alarms",
+    "storage"
+  ],
+  "host_permissions": [
+    "<all_urls>"
+  ],
+  "background": {
+    "service_worker": "background.js",
+    "type": "module"
+  },
+  "action": {
+    "default_title": "gu browser",
+    "default_popup": "popup.html",
+    "default_icon": {
+      "16": "icons/icon16.png",
+      "32": "icons/icon32.png",
+      "48": "icons/icon48.png",
+      "128": "icons/icon128.png"
+    }
+  }
+}

package/browser-extension/popup.html

@@ -0,0 +1,26 @@
+<!doctype html>
+<html>
+<head>
+<meta charset="utf-8">
+<style>
+  body { font: 13px -apple-system, system-ui, sans-serif; margin: 0; padding: 14px 16px; width: 260px; color: #1d1b26; background: #fff; }
+  h1 { font-size: 14px; margin: 0 0 8px; }
+  .dot { display: inline-block; width: 8px; height: 8px; border-radius: 50%; background: #b9b6c4; margin-right: 6px; }
+  .on .dot { background: #2f9e62; }
+  p { margin: 8px 0 0; color: #5d5a6b; line-height: 1.4; }
+  button { margin-top: 10px; font: inherit; padding: 4px 10px; }
+  @media (prefers-color-scheme: dark) { body { background: #1d1b26; color: #eceaf3; } p { color: #a9a6b8; } }
+</style>
+</head>
+<body>
+  <h1>gu browser</h1>
+  <div id="status"><span class="dot"></span><span id="label">checking…</span></div>
+  <p id="help"></p>
+  <div id="tab" style="margin-top:12px;display:none">
+    <div id="tabLabel" style="color:inherit"></div>
+    <button id="share">Let gu use this tab</button>
+  </div>
+  <button id="retry">Connect now</button>
+  <script src="popup.js"></script>
+</body>
+</html>

package/browser-extension/popup.js

@@ -0,0 +1,45 @@
+// Shows whether the extension is connected to gu's local bridge, and retries on request.
+const label = document.getElementById("label");
+const help = document.getElementById("help");
+
+function show(s) {
+  const on = Boolean(s && s.connected);
+  document.getElementById("status").className = on ? "on" : "";
+  label.textContent = on ? `connected to gu (v${s.version})` : "not connected";
+  help.textContent = on
+    ? "gu's agent can open and use pages in the \"gu\" tab group. Your other tabs are never touched."
+    : "gu connects when its agent needs the browser. In the gu terminal, /browser shows the status.";
+}
+
+function check() {
+  chrome.runtime.sendMessage({ type: "status" }, show);
+}
+
+document.getElementById("retry").onclick = () => {
+  label.textContent = "connecting…";
+  chrome.runtime.sendMessage({ type: "reconnect" }, () => setTimeout(check, 600));
+};
+check();
+
+// "Let gu use this tab" (#150): hand gu one of your own tabs — it joins the "gu" group and the
+// agent can use it; "Stop sharing" takes it back. Chrome's own pages cannot be shared.
+const tabBox = document.getElementById("tab");
+const tabLabel = document.getElementById("tabLabel");
+const shareBtn = document.getElementById("share");
+
+async function showTab() {
+  const [tab] = await chrome.tabs.query({ active: true, currentWindow: true });
+  if (!tab || !/^(https?|file):/i.test(tab.url || "")) return;
+  const { shared } = await chrome.runtime.sendMessage({ type: "tabState", tabId: tab.id });
+  tabBox.style.display = "block";
+  tabLabel.textContent = shared ? "gu can use this tab." : "This tab is yours — gu cannot see it.";
+  shareBtn.textContent = shared ? "Stop sharing this tab" : "Let gu use this tab";
+  shareBtn.onclick = async () => {
+    shareBtn.disabled = true;
+    const r = await chrome.runtime.sendMessage({ type: shared ? "unshare" : "share", tabId: tab.id });
+    shareBtn.disabled = false;
+    if (r && r.ok === false) tabLabel.textContent = r.error;
+    else showTab();
+  };
+}
+showTab();

package/client-expert-api.mjs

@@ -20,6 +20,7 @@
 import { createRequire } from "node:module";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { spawnSurviving, pidOnPort } from "./platform-tools.mjs";
+import { procCommand, procStart, sameProcess } from "./proc-identity.mjs";
 import { DEFAULT_API_BASE as HOSTED_API_BASE } from "./device-login.mjs";
 import { spawn } from "node:child_process";
 import { writeFile, mkdir, readFile, access } from "node:fs/promises";
@@ -113,6 +114,46 @@ export function localMongoUri({ env = process.env, home = homedir() } = {}) {
 
 const GONEXT_DIR = join(homedir(), ".gonext");
 export const API_PID_FILE = join(GONEXT_DIR, "local-api.pid");
+
+/**
+ * THE PID FILE CARRIES THE PROCESS'S START TIME (#373, GitHub #154): "<pid>\n<start epoch s>\n".
+ * The file outlives the API (a crash, a reboot), and its id may belong to another program by the
+ * time `gu api stop`, restart, upgrade or reset reads it. The start time, read from ps when the
+ * file is written, is what tells them apart. Older files hold only the pid.
+ */
+export async function writeApiPid(pid, { path = API_PID_FILE } = {}) {
+  if (!pid) return;
+  const t = procStart(pid);
+  await writeFile(path, `${pid}\n${Number.isFinite(t) ? t : ""}\n`).catch(() => {});
+}
+
+/** { pid, started } from the pid file; pid null when there is none. */
+export async function readApiPid({ path = API_PID_FILE } = {}) {
+  const [a, b] = String(await readFile(path, "utf8").catch(() => "")).split(/\s+/);
+  const pid = Number(a);
+  const started = b ? Number(b) : NaN;
+  return { pid: Number.isInteger(pid) && pid > 0 ? pid : null, started: Number.isFinite(started) ? started : null };
+}
+
+/**
+ * The pid to stop — only while it is still the local API. With a start time: the same process
+ * started then. An older file without one: the process must look like the API (node … index.js).
+ * { pid } to signal, or { pid: null, why } — never a guess.
+ */
+export async function apiPidToStop({ path = API_PID_FILE, platform = process.platform, startOf = procStart, commandOf = procCommand } = {}) {
+  const { pid, started } = await readApiPid({ path });
+  if (!pid) return { pid: null, why: "no local API pid on record" };
+  if (platform === "win32") return { pid };
+  if (started != null) {
+    const same = sameProcess(pid, started, { before: 2, after: 2, startOf });
+    if (same === "same") return { pid };
+    if (same === "gone") return { pid: null, why: "not running" };
+    if (same === "other") return { pid: null, why: `pid ${pid} is now another program, not the local API — left alone` };
+  }
+  const cmd = commandOf(pid, { platform });
+  if (!cmd) return { pid: null, why: "not running" };
+  return /\bnode\b.*\bindex\.js\b/.test(cmd) ? { pid } : { pid: null, why: `pid ${pid} is now another program, not the local API — left alone` };
+}
 export const API_LOG_FILE = join(GONEXT_DIR, "local-api.log");
 
 /** The API authenticates a worker by sha256 of the key — same function it uses server-side. */
@@ -528,14 +569,14 @@ export async function startLocalApi({
   // serves — which is the better question anyway: what matters is who is answering, not who
   // we spawned. Recorded after the server is up, by the caller's waitForApi.
   const pid = res.pid ?? null;
-  if (pid) await writeFile(API_PID_FILE, String(pid) + "\n").catch(() => {});
+  await writeApiPid(pid);
   return { pid, how: res.how, port };
 }
 
 /** Record whoever is serving the port, so `api stop` has something to stop. */
 export async function recordApiPid(port = LOCAL_API_PORT) {
   const pid = await pidOnPort(port);
-  if (pid) await writeFile(API_PID_FILE, String(pid) + "\n").catch(() => {});
+  await writeApiPid(pid);
   return pid;
 }