clay-server 4.7.1-beta.5 → 4.8.0-beta.2

package/lib/shared-browser-worker.js

@@ -0,0 +1,160 @@
+// Isolated browser process. Its OS identity matches the owning Driver session.
+var chromium = require("playwright").chromium;
+var policy = require("./shared-browser-policy");
+var browser = null;
+var context = null;
+var page = null;
+var closing = false;
+var viewing = false;
+var epoch = 0;
+var queue = Promise.resolve();
+var pending = 0;
+var timer = null;
+var activeActivity = null;
+var pointerSequence = 0;
+var viewport = { width: 1280, height: 800 };
+function emit(message) {
+  if (!closing && process.stdout.writableLength < 3 * 1024 * 1024) process.stdout.write(JSON.stringify(message) + "\n");
+}
+function state() {
+  return { url: page ? policy.visibleUrl(page.url()) : "", width: viewport.width, height: viewport.height };
+}
+async function screenshot() {
+  return (await page.screenshot({ type: "jpeg", quality: 70, caret: "initial", timeout: 5000 })).toString("base64");
+}
+async function capture() {
+  if (closing) return;
+  try {
+    if (viewing && page && !page.isClosed()) {
+      var current = page;
+      var data = await screenshot();
+      if (current === page) emit(Object.assign({ type: "frame", data: data }, state()));
+    }
+  } catch (e) {}
+  if (!closing) timer = setTimeout(capture, 250);
+}
+async function start() {
+  var channels = ["chrome", "msedge", null];
+  for (var i = 0; i < channels.length; i++) {
+    try { browser = await chromium.launch({ channel: channels[i] || undefined, headless: true, chromiumSandbox: true, timeout: 15000 }); break; }
+    catch (e) { if (closing) return; }
+  }
+  if (!browser) throw new Error("Install Chrome or run npx playwright install chromium on the Clay host. Linux also needs browser libraries and sandbox support.");
+  if (closing) { await browser.close(); return; }
+  var cdp = await browser.newBrowserCDPSession();
+  var version = await cdp.send("Browser.getVersion");
+  await cdp.detach();
+  context = await browser.newContext({ viewport: viewport, acceptDownloads: false, userAgent: version.userAgent.replace("HeadlessChrome/", "Chrome/") });
+  await context.addInitScript(require("./vendor-login-browser-passkeys").disableLoginPasskeys);
+  await context.route("**/*", function (route) {
+    var protocol = new URL(route.request().url()).protocol;
+    return ["http:", "https:"].includes(protocol) ? route.continue() : route.abort();
+  });
+  context.on("page", function (opened) {
+    page = opened;
+    opened.setDefaultTimeout(10000);
+    opened.on("dialog", function (dialog) { dialog.dismiss().catch(function () {}); });
+    opened.on("download", function (download) { download.cancel().catch(function () {}); });
+    opened.on("framenavigated", function (frame) { if (frame === opened.mainFrame() && page === opened) emit(Object.assign({ type: "state" }, state())); });
+    opened.on("close", function () { var pages = context.pages(); page = pages.length ? pages[pages.length - 1] : null; emit(Object.assign({ type: "state" }, state())); });
+  });
+  page = await context.newPage();
+  emit(Object.assign({ type: "ready" }, state()));
+  capture();
+}
+function reportActivity(phase) {
+  if (activeActivity) emit({ type: "activity", epoch: activeActivity.epoch, generation: activeActivity.generation,
+    activity: { id: activeActivity.id, text: activeActivity.text, phase: phase } });
+}
+function reportPointer(x, y, clicked) {
+  if (activeActivity) emit({ type: "pointer", epoch: activeActivity.epoch, generation: activeActivity.generation,
+    pointer: { x: x, y: y, width: viewport.width, height: viewport.height, clicked: !!clicked, sequence: ++pointerSequence } });
+}
+function activityText(message) {
+  var defaults = { inspect: "I'll take a look at the page to see what's there.", navigate: "I'll open this page so we can take a look.", back: "I'll go back to the previous page.", forward: "I'll move forward to the next page.", reload: "I'll refresh the page to see its latest state.", click: "I'll click this control and see what happens.", text: "I'll enter the text in this field.", select: "I'll choose this option in the form.", key: "I'll use the keyboard for this step.", wheel: "I'll scroll a little to see more of the page.", resize: "I'll change the screen size to check the layout." };
+  return message.activity.intent || defaults[message.action === "inspect" ? "inspect" : message.event.kind] || "I'll work through the next step in the browser.";
+}
+async function action(event) {
+  if (!page || page.isClosed()) page = await context.newPage();
+  event = policy.validateAction(event);
+  if (event.kind === "navigate") await page.goto(event.url, { waitUntil: "domcontentloaded", timeout: 20000 });
+  else if (event.kind === "back") await page.goBack({ waitUntil: "domcontentloaded", timeout: 20000 });
+  else if (event.kind === "forward") await page.goForward({ waitUntil: "domcontentloaded", timeout: 20000 });
+  else if (event.kind === "reload") await page.reload({ waitUntil: "domcontentloaded", timeout: 20000 });
+  else if (event.kind === "click" && event.selector) {
+    var target = page.locator(event.selector);
+    await target.click({ trial: true });
+    var box = await target.boundingBox();
+    if (box) {
+      var x = Math.max(0, Math.min(viewport.width - 1, box.x + box.width / 2));
+      var y = Math.max(0, Math.min(viewport.height - 1, box.y + box.height / 2));
+      await page.mouse.move(x, y);
+      reportPointer(x, y, true);
+      await target.click({ position: { x: x - box.x, y: y - box.y } });
+    } else await target.click();
+  }
+  else if (["move", "down", "up", "click"].includes(event.kind)) {
+    await page.mouse.move(Math.max(0, Math.min(viewport.width - 1, event.x)), Math.max(0, Math.min(viewport.height - 1, event.y)));
+    reportPointer(Math.max(0, Math.min(viewport.width - 1, event.x)), Math.max(0, Math.min(viewport.height - 1, event.y)), event.kind === "click" || event.kind === "down");
+    if (event.kind === "down") await page.mouse.down();
+    if (event.kind === "up") await page.mouse.up();
+    if (event.kind === "click") await page.mouse.click(event.x, event.y);
+  } else if (event.kind === "text") {
+    if (event.selector) await page.locator(event.selector).fill(event.text);
+    else await page.keyboard.insertText(event.text);
+  } else if (event.kind === "select") await page.locator(event.selector).selectOption(event.text);
+  else if (event.kind === "key") await page.keyboard.press(event.key);
+  else if (event.kind === "wheel") await page.mouse.wheel(0, Math.max(-2000, Math.min(2000, event.deltaY)));
+  else if (event.kind === "resize") {
+    viewport = { width: Math.round(event.width), height: Math.round(event.height) };
+    await page.setViewportSize(viewport);
+  }
+  return state();
+}
+async function command(message) {
+  if (message.epoch !== epoch) throw new Error("Browser control changed; this action was cancelled");
+  activeActivity = message.activity ? { id: message.id, epoch: message.epoch, generation: message.activity.generation, text: activityText(message) } : null;
+  if (message.event && ["navigate", "back", "forward", "reload", "resize"].includes(message.event.kind) && activeActivity) {
+    emit({ type: "pointer", epoch: message.epoch, generation: activeActivity.generation, pointer: null });
+  }
+  reportActivity("running");
+  if (message.action === "inspect") {
+    if (!page || page.isClosed()) throw new Error("Open a page first");
+    return Object.assign(state(), { snapshot: (await page.locator("body").ariaSnapshot()).slice(0, 24000), image: await screenshot() });
+  }
+  return action(message.event);
+}
+async function close() {
+  if (closing) return;
+  closing = true;
+  clearTimeout(timer);
+  if (browser) await browser.close().catch(function () {});
+  process.exit(0);
+}
+var lines = require("readline").createInterface({ input: process.stdin });
+lines.on("line", function (line) {
+  if (line.length > 30000 || closing) return;
+  var msg;
+  try { msg = JSON.parse(line); } catch (e) { return; }
+  if (msg.type === "start") {
+    if (!browser) queue = queue.then(start).catch(function (e) { emit({ type: "error", error: e.message }); });
+  } else if (msg.type === "viewing") viewing = !!msg.value;
+  else if (msg.type === "control") {
+    epoch = msg.epoch;
+    queue = queue.then(async function () {
+      if (page) await page.mouse.up().catch(function () {});
+      emit({ type: "result", id: msg.id, value: { epoch: msg.epoch } });
+    });
+  } else if (msg.type === "command") {
+    if (pending >= 80) { emit({ type: "result", id: msg.id, error: "Browser is busy; retry shortly" }); return; }
+    pending++;
+    queue = queue.then(function () { return command(msg); }).then(function (value) {
+      reportActivity("complete"); activeActivity = null;
+      emit({ type: "result", id: msg.id, value: value });
+      emit(Object.assign({ type: "state" }, state()));
+    }, function (e) { reportActivity("failed"); activeActivity = null; emit({ type: "result", id: msg.id, error: e.message }); }).finally(function () { pending--; });
+  }
+});
+lines.on("close", close);
+process.on("SIGTERM", close);
+process.on("SIGINT", close);

package/lib/terminal.js

@@ -25,6 +25,10 @@ function createTerminal(cwd, cols, rows, osUserInfo, opts) {
 
   // Build a minimal, isolated environment (no daemon env leakage)
   var termEnv = buildUserEnv(osUserInfo);
+  if (opts && opts.loginBrowserEnv) {
+    termEnv.BROWSER = opts.loginBrowserEnv.BROWSER;
+    termEnv.CLAY_LOGIN_URL_FILE = opts.loginBrowserEnv.CLAY_LOGIN_URL_FILE;
+  }
   var spawnOpts = {
     name: "xterm-256color",
     cols: cols || 80,

package/lib/vendor-login-browser-flow.js

@@ -0,0 +1,46 @@
+var createLoginBrowser = require("./vendor-login-browser").createLoginBrowser;
+
+function attachBrowserLogin(ctx) {
+  function allowed(ws, flow) {
+    var userId = ws && ws._clayUser ? String(ws._clayUser.id) : null;
+    return userId === flow.ownerId && ctx.hasTerminalPermission(ws);
+  }
+  function prepare(ws, flow, identity) {
+    if (ctx.osUsers && !identity.osUserInfo) throw new Error("OS user identity is unavailable");
+    flow.ownerId = ws && ws._clayUser ? String(ws._clayUser.id) : null;
+    flow.browser = (ctx.createLoginBrowser || createLoginBrowser)({
+      ws: ws, vendor: flow.vendor, osUserInfo: identity.osUserInfo,
+      sendTo: ctx.sendTo,
+      canAccess: function (peer) { return allowed(peer, flow); },
+    });
+    flow.expiryTimer = setTimeout(function () { ctx.cancel(flow.key); }, 15 * 60 * 1000);
+    flow.expiryTimer.unref();
+  }
+  function handle(ws, msg, flows) {
+    var flow = flows[ctx.flowKey(ws, String(msg.vendor || "claude"))];
+    if (msg.type === "vendor_login_cancel" && msg.browserId && (!flow || !flow.browser)) return true;
+    if (typeof msg.type === "string" && msg.type.indexOf("term_") === 0) {
+      var vendors = Object.keys(flows);
+      for (var i = 0; i < vendors.length; i++) {
+        var candidate = flows[vendors[i]];
+        if (candidate.terminalId === msg.id && !allowed(ws, candidate)) return true;
+      }
+    }
+    if (msg.type === "vendor_login_browser_attach" || msg.type === "vendor_login_browser_input") {
+      if (!flow || !flow.browser || flow.browser.id !== msg.browserId || !allowed(ws, flow)) return true;
+      if (msg.type === "vendor_login_browser_attach") flow.browser.attach(ws);
+      else flow.browser.input(ws, msg.event);
+      return true;
+    }
+    if (flow && flow.browser && (msg.type === "vendor_login_start" || msg.type === "vendor_login_cancel")) {
+      if (!allowed(ws, flow) || (msg.type === "vendor_login_cancel" && msg.browserId !== flow.browser.id)) {
+        ctx.sendTo(ws, { type: "vendor_login_error", vendor: msg.vendor, error: "This sign-in belongs to another request. Reopen sign-in to continue." });
+        return true;
+      }
+    }
+    return false;
+  }
+  return { prepare: prepare, handle: handle };
+}
+
+module.exports = { attachBrowserLogin: attachBrowserLogin };

package/lib/vendor-login-browser-passkeys.js

@@ -0,0 +1,27 @@
+// Runs before page scripts in each remote sign-in page, frame, and popup.
+function disableLoginPasskeys() {
+  var credentials = window.CredentialsContainer && window.CredentialsContainer.prototype;
+  if (credentials) {
+    ["get", "create"].forEach(function (method) {
+      var original = credentials[method];
+      if (typeof original !== "function") return;
+      Object.defineProperty(credentials, method, {
+        configurable: true,
+        writable: true,
+        value: function (options) {
+          if (options && "publicKey" in Object(options)) {
+            return Promise.reject(new DOMException(
+              "Passkeys are unavailable in this remote sign-in browser. Choose another sign-in method.",
+              "NotSupportedError"
+            ));
+          }
+          return original.apply(this, arguments);
+        },
+      });
+    });
+  }
+  // Feature detection should choose password/email instead of host-native authenticator UI.
+  Object.defineProperty(window, "PublicKeyCredential", { configurable: true, writable: true, value: undefined });
+}
+
+module.exports = { disableLoginPasskeys: disableLoginPasskeys };

package/lib/vendor-login-browser-worker.js

@@ -0,0 +1,149 @@
+// Runs as the same OS identity as the login CLI. Only the human supplies input.
+var readline = require("readline");
+var spawn = require("child_process").spawn;
+var chromium = require("playwright").chromium;
+var browser = null;
+var page = null;
+var installing = null;
+var viewing = true;
+var closing = false;
+var captureTimer = null;
+var inputQueue = Promise.resolve();
+var queued = 0;
+var viewport = { width: 1000, height: 720 };
+
+function emit(message) {
+  if (!closing && process.stdout.writableLength < 1024 * 1024) process.stdout.write(JSON.stringify(message) + "\n");
+}
+
+function status(text, phase) { emit({ type: "status", text: text, phase: phase || "loading" }); }
+
+async function launch() {
+  var channels = ["chrome", "msedge", null];
+  for (var i = 0; i < channels.length; i++) {
+    try {
+      return await chromium.launch({ channel: channels[i] || undefined, headless: true, chromiumSandbox: true, timeout: 20000 });
+    } catch (e) {
+      if (closing) throw e;
+    }
+  }
+  status("Preparing the sign-in browser. The first download may take a few minutes…");
+  await new Promise(function (resolve, reject) {
+    installing = spawn(process.execPath, [require("path").join(require.resolve("playwright/package.json"), "../cli.js"), "install", "chromium"], { stdio: "ignore", env: process.env });
+    var timer = setTimeout(function () { installing.kill(); reject(new Error("Install timed out")); }, 180000);
+    installing.once("error", function (err) { clearTimeout(timer); reject(err); });
+    installing.once("exit", function (code) {
+      clearTimeout(timer);
+      installing = null;
+      if (code === 0) resolve(); else reject(new Error("Browser installation failed"));
+    });
+  });
+  if (closing) throw new Error("Closed");
+  return chromium.launch({ headless: true, chromiumSandbox: true, timeout: 20000 });
+}
+
+async function capture() {
+  if (closing) return;
+  try {
+    if (page && !page.isClosed() && viewing && process.stdout.writableLength < 262144) {
+      var current = page;
+      var data = await current.screenshot({ type: "jpeg", quality: 65, caret: "initial", timeout: 3000 });
+      if (current === page) emit({ type: "frame", data: data.toString("base64"), origin: new URL(current.url()).origin,
+        width: current.viewportSize().width, height: current.viewportSize().height });
+    }
+  } catch (e) {}
+  if (!closing) captureTimer = setTimeout(capture, 250);
+}
+
+async function start(url) {
+  browser = await launch();
+  if (closing) { await browser.close(); return; }
+  var session = await browser.newBrowserCDPSession();
+  var version;
+  try { version = await session.send("Browser.getVersion"); }
+  finally { await session.detach(); }
+  // Preserve the native version/platform and replace only the headless product token.
+  var userAgent = version.userAgent.replace("HeadlessChrome/", "Chrome/");
+  var context = await browser.newContext({ viewport: viewport, acceptDownloads: false, userAgent: userAgent });
+  await context.addInitScript(require("./vendor-login-browser-passkeys").disableLoginPasskeys);
+  var callback = new URL(new URL(url).searchParams.get("redirect_uri"));
+  await context.route("**/*", function (route) {
+    var target = new URL(route.request().url());
+    if (target.protocol === "https:" || (target.origin === callback.origin && target.pathname === callback.pathname)) return route.continue();
+    return route.abort();
+  });
+  context.on("page", function (opened) {
+    page = opened;
+    opened.setViewportSize(viewport).catch(function () {});
+    opened.on("download", function (download) { download.cancel().catch(function () {}); });
+    opened.on("close", function () {
+      var pages = context.pages();
+      page = pages.length ? pages[pages.length - 1] : null;
+    });
+  });
+  page = await context.newPage();
+  capture();
+  status("Opening sign-in page…");
+  await page.goto(url, { waitUntil: "domcontentloaded", timeout: 60000 });
+  status("Sign in to connect your account.", "ready");
+}
+
+async function input(event) {
+  if (!page || page.isClosed() || closing) return;
+  if (["move", "down", "up"].indexOf(event.kind) >= 0 && Number.isFinite(event.x) && Number.isFinite(event.y)) {
+    var pointerSize = page.viewportSize();
+    var x = Math.max(0, Math.min(pointerSize.width - 1, event.x));
+    var y = Math.max(0, Math.min(pointerSize.height - 1, event.y));
+    await page.mouse.move(x, y);
+    if (event.kind === "down") await page.mouse.down();
+    if (event.kind === "up") await page.mouse.up();
+  } else if (event.kind === "click" && Number.isFinite(event.x) && Number.isFinite(event.y)) {
+    var size = page.viewportSize();
+    await page.mouse.click(Math.max(0, Math.min(size.width - 1, event.x)), Math.max(0, Math.min(size.height - 1, event.y)));
+  } else if (event.kind === "wheel" && Number.isFinite(event.deltaY)) {
+    await page.mouse.wheel(0, Math.max(-1500, Math.min(1500, event.deltaY)));
+  } else if (event.kind === "text" && typeof event.text === "string" && event.text.length <= 4096) {
+    await page.keyboard.insertText(event.text);
+  } else if (event.kind === "key" && /^(Tab|Shift\+Tab|Enter|Backspace|Delete|Escape|ArrowLeft|ArrowRight|ArrowUp|ArrowDown|Home|End|ControlOrMeta\+A)$/.test(event.key)) {
+    await page.keyboard.press(event.key);
+  } else if (event.kind === "reload") {
+    await page.reload({ waitUntil: "domcontentloaded", timeout: 30000 });
+  } else if (event.kind === "resize" && Number.isFinite(event.width) && Number.isFinite(event.height)) {
+    viewport = { width: Math.round(Math.max(320, Math.min(1000, event.width))), height: Math.round(Math.max(360, Math.min(720, event.height))) };
+    await page.setViewportSize(viewport);
+  }
+}
+
+async function close() {
+  if (closing) return;
+  closing = true;
+  clearTimeout(captureTimer);
+  if (installing) installing.kill();
+  if (browser) await browser.close().catch(function () {});
+  process.exit(0);
+}
+
+var started = false;
+var lines = readline.createInterface({ input: process.stdin });
+lines.on("line", function (line) {
+  if (line.length > 20000 || closing) return;
+  var message;
+  try { message = JSON.parse(line); } catch (e) { return; }
+  if (message.type === "start" && !started) {
+    started = true;
+    start(message.url).catch(function () {
+      status("Unable to open the sign-in browser. The host may need browser libraries or sandbox support. Use terminal sign-in to continue.", "error");
+    });
+  } else if (message.type === "viewing") {
+    viewing = !!message.value;
+  } else if (message.type === "input" && message.event && queued < 100) {
+    if (message.event.kind === "move" && queued >= 10) return;
+    queued++;
+    inputQueue = inputQueue.then(function () { return input(message.event); }).catch(function () {
+      status("The page did not respond. Try reloading.", "error");
+    }).finally(function () { queued--; });
+  }
+});
+lines.on("close", close);
+process.on("SIGTERM", close);
+process.on("SIGINT", close);

package/lib/vendor-login-browser.js

@@ -0,0 +1,162 @@
+// Private, human-controlled browser transport for a single vendor login.
+var fs = require("fs");
+var os = require("os");
+var path = require("path");
+var crypto = require("crypto");
+var spawn = require("child_process").spawn;
+var buildUserEnv = require("./build-user-env").buildUserEnv;
+var wrapSpawnAsUser = require("./os-users").wrapSpawnAsUser;
+
+function loginUrl(value, vendor) {
+  try {
+    var url = new URL(value);
+    var hosts = vendor === "codex" ? ["auth.openai.com"] : ["claude.ai", "claude.com", "console.anthropic.com", "platform.claude.com"];
+    if (url.protocol !== "https:" || url.username || url.password || hosts.indexOf(url.hostname) < 0) return null;
+    if (!url.searchParams.get("state") || !url.searchParams.get("code_challenge")) return null;
+    var callback = new URL(url.searchParams.get("redirect_uri"));
+    if (callback.protocol !== "http:" || ["localhost", "127.0.0.1", "[::1]"].indexOf(callback.hostname) < 0) return null;
+    return url.href;
+  } catch (e) { return null; }
+}
+
+function createLoginBrowser(options) {
+  var id = crypto.randomUUID();
+  var dir = fs.mkdtempSync(path.join(os.tmpdir(), "clay-login-"));
+  fs.chmodSync(dir, 0o700);
+  var info = options.osUserInfo;
+  if (info) fs.chownSync(dir, info.uid, info.gid);
+  var urlFile = path.join(dir, "url");
+  var opener = path.resolve(__dirname, "../bin/login-browser-open.js");
+  var wrapper = path.join(dir, process.platform === "win32" ? "open.cmd" : "open");
+  var quote = function (value) { return "'" + value.replace(/'/g, "'\\''") + "'"; };
+  var script = process.platform === "win32"
+    ? '@"' + process.execPath + '" "' + opener + '" %*\r\n'
+    : "#!/bin/sh\nexec " + quote(process.execPath) + " " + quote(opener) + ' "$@"\n';
+  fs.writeFileSync(wrapper, script, { mode: 0o700 });
+  if (info) fs.chownSync(wrapper, info.uid, info.gid);
+  var child = null;
+  var peer = options.ws;
+  var closed = false;
+  var started = false;
+  var status = "Waiting for the sign-in page…";
+  var statusPhase = "loading";
+  var tail = "";
+  var pollBusy = false;
+  var waitTimer = setTimeout(function () {
+    if (!started && !closed) {
+      status = "Still waiting for the CLI sign-in page. Use terminal sign-in if it needs attention.";
+      send({ type: "vendor_login_browser_status", text: status, phase: statusPhase });
+    }
+  }, 30000);
+  waitTimer.unref();
+
+  function send(message) {
+    if (closed || !peer || peer.readyState !== 1 || !options.canAccess(peer)) return;
+    if (message.type === "vendor_login_browser_frame" && peer.bufferedAmount > 1024 * 1024) return;
+    options.sendTo(peer, Object.assign({ vendor: options.vendor, browserId: id }, message));
+  }
+  function write(message) {
+    if (child && child.stdin.writable && child.stdin.writableLength < 65536) child.stdin.write(JSON.stringify(message) + "\n");
+  }
+  function start(url) {
+    if (closed || started) return;
+    started = true;
+    clearTimeout(waitTimer);
+    status = "Opening a private sign-in browser…";
+    send({ type: "vendor_login_browser_status", text: status, phase: statusPhase });
+    var env = buildUserEnv(info);
+    if (process.platform === "win32" && !info) {
+      ["SystemRoot", "WINDIR", "TEMP", "TMP", "LOCALAPPDATA", "APPDATA", "USERPROFILE", "COMSPEC", "PATHEXT"].forEach(function (key) {
+        if (process.env[key]) env[key] = process.env[key];
+      });
+    }
+    var opts = { cwd: info ? info.home : os.homedir(), env: env, stdio: ["pipe", "pipe", "ignore"] };
+    if (info) { opts.uid = info.uid; opts.gid = info.gid; }
+    var spec = wrapSpawnAsUser(process.execPath, [path.join(__dirname, "vendor-login-browser-worker.js")], opts);
+    child = spawn(spec.command, spec.args, spec.options);
+    var buffer = "";
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", function (chunk) {
+      buffer += chunk;
+      if (buffer.length > 4 * 1024 * 1024) { child.kill(); return; }
+      var at;
+      while ((at = buffer.indexOf("\n")) >= 0) {
+        var line = buffer.slice(0, at);
+        buffer = buffer.slice(at + 1);
+        try {
+          var message = JSON.parse(line);
+          if (message.type === "status") {
+            status = message.text;
+            statusPhase = message.phase || "loading";
+            send({ type: "vendor_login_browser_status", text: status, phase: statusPhase });
+          } else if (message.type === "frame") {
+            send({ type: "vendor_login_browser_frame", data: message.data, origin: message.origin, width: message.width, height: message.height });
+            write({ type: "viewing", value: !!(peer && peer.readyState === 1 && options.canAccess(peer)) });
+          }
+        } catch (e) {}
+      }
+    });
+    child.on("error", function () {
+      statusPhase = "error";
+      status = "The sign-in browser could not start. Use terminal sign-in to continue.";
+      send({ type: "vendor_login_browser_status", text: status, phase: statusPhase });
+    });
+    child.on("exit", function () {
+      if (closed) return;
+      statusPhase = "error";
+      status = "The sign-in browser closed. You can retry or use terminal sign-in.";
+      send({ type: "vendor_login_browser_status", text: status, phase: statusPhase });
+    });
+    child.stdin.on("error", function () {});
+    write({ type: "start", url: url });
+  }
+  function acceptUrl(value) {
+    var url = loginUrl(value, options.vendor);
+    if (url) start(url);
+  }
+  var timer = setInterval(function () {
+    if (closed || started || pollBusy) return;
+    pollBusy = true;
+    fs.readFile(urlFile, "utf8", function (err, value) {
+      pollBusy = false;
+      if (!err && value.length <= 16384) acceptUrl(value);
+    });
+  }, 250);
+  timer.unref();
+  return {
+    id: id,
+    env: { BROWSER: wrapper, CLAY_LOGIN_URL_FILE: urlFile },
+    output: function (chunk) {
+      // Codex also prints the complete URL when the platform opener ignores BROWSER.
+      tail = (tail + chunk).slice(-32768);
+      var matches = tail.match(/https:\/\/[^\s\x1b<>"']+(?=[\s\x1b<>"'])/g) || [];
+      for (var i = 0; i < matches.length; i++) acceptUrl(matches[i]);
+    },
+    attach: function (ws) {
+      peer = ws;
+      send({ type: "vendor_login_browser_status", text: status, phase: statusPhase });
+      write({ type: "viewing", value: true });
+    },
+    input: function (ws, event) {
+      if (ws !== peer || !options.canAccess(ws) || !event || typeof event !== "object") return;
+      write({ type: "input", event: event });
+    },
+    close: function () {
+      if (closed) return;
+      closed = true;
+      clearInterval(timer);
+      clearTimeout(waitTimer);
+      if (child) {
+        child.stdin.end();
+        var killTimer = setTimeout(function () { child.kill("SIGKILL"); }, 5000);
+        killTimer.unref();
+        child.once("exit", function () { clearTimeout(killTimer); });
+      }
+      fs.rmSync(dir, { recursive: true, force: true });
+      tail = "";
+      peer = null;
+    },
+  };
+}
+
+module.exports = { createLoginBrowser: createLoginBrowser, loginUrl: loginUrl };

package/lib/ws-schema.js

@@ -219,7 +219,21 @@ var schema = {
   // Auth
   // -----------------------------------------------------------------------
   "auth_required":            { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "Authentication required (e.g. API key needed)" },
+  "shared_browser_state_request": { direction: "c2s", handler: "lib/project-shared-browser.js", description: "Session-owned shared browser state_request" },
+  "shared_browser_open": { direction: "c2s", handler: "lib/project-shared-browser.js", description: "Session-owned shared browser open" },
+  "shared_browser_view": { direction: "c2s", handler: "lib/project-shared-browser.js", description: "Session-owned shared browser view" },
+  "shared_browser_control": { direction: "c2s", handler: "lib/project-shared-browser.js", description: "Session-owned shared browser control" },
+  "shared_browser_close": { direction: "c2s", handler: "lib/project-shared-browser.js", description: "Close one exact browser tab" },
+  "shared_browser_end": { direction: "c2s", handler: "lib/project-shared-browser.js", description: "Session-owned shared browser end" },
+  "shared_browser_input": { direction: "c2s", handler: "lib/project-shared-browser.js", description: "Session-owned shared browser input" },
+  "shared_browser_state": { direction: "s2c", handler: "lib/public/modules/shared-browser.js", description: "Private shared browser state" },
+  "shared_browser_frame": { direction: "s2c", handler: "lib/public/modules/shared-browser.js", description: "Private shared browser frame" },
+  "shared_browser_error": { direction: "s2c", handler: "lib/public/modules/shared-browser.js", description: "Private shared browser error" },
   "vendor_login_start":       { direction: "c2s", handler: "lib/project-vendor-login.js", description: "Start (or re-attach to) the per-vendor login terminal" },
+  "vendor_login_browser_attach": { direction: "c2s", handler: "lib/vendor-login-browser-flow.js", description: "Attach the sign-in owner to their private browser" },
+  "vendor_login_browser_input": { direction: "c2s", handler: "lib/vendor-login-browser-flow.js", description: "Send human input to the private sign-in browser" },
+  "vendor_login_browser_frame": { direction: "s2c", handler: "lib/public/modules/vendor-login-browser.js", description: "Private sign-in viewport; never recorded in conversation history" },
+  "vendor_login_browser_status": { direction: "s2c", handler: "lib/public/modules/vendor-login-browser.js", description: "Private sign-in browser status" },
   "vendor_login_cancel":      { direction: "c2s", handler: "lib/project-vendor-login.js", description: "Dismiss the login flow and kill its terminal" },
   "vendor_login_state_request": { direction: "c2s", handler: "lib/project-vendor-login.js", description: "Ask for the project's active login flows" },
   "vendor_login_ready":       { direction: "s2c", handler: "lib/public/modules/vendor-login.js", description: "Login terminal is available; open/re-attach the modal to it" },

package/lib/yoke/skill-discovery.js

@@ -1,11 +1,12 @@
 // Cross-vendor skill discovery
 // ----------------------------
-// Skills remain in their vendor-owned directories. This module only builds a
-// merged view so every YOKE adapter can expose the same installed skills.
+// Ordinary skills stay in vendor-owned directories. Clay-specific skills use
+// private roots and are attached only to Clay-owned adapter queries.
 
 var fs = require("fs");
 var os = require("os");
 var path = require("path");
+var clayStorage = require("../clay-skill-storage");
 
 function defaultHomeDir() {
   try { return require("../config").REAL_HOME; } catch (e) { return os.homedir(); }
@@ -13,10 +14,12 @@ function defaultHomeDir() {
 
 function optionsForOsUser(userInfo, fsAsUser) {
   if (!userInfo || typeof userInfo.home !== "string" || !userInfo.home) return { disable: true };
+  var migrateAsUser = !fsAsUser || fsAsUser === require("../os-users").fsAsUser;
   fsAsUser = fsAsUser || require("../os-users").fsAsUser;
   return {
     homeDir: userInfo.home,
     scopedHome: true,
+    migrationIdentity: migrateAsUser ? userInfo : null,
     readDir: function (dir) { return fsAsUser("list", { dir: dir }, userInfo).map(function (entry) { return { name: entry.name, isDir: entry.isDir }; }); },
     readFile: function (file) { return fsAsUser("read", { file: file, readContent: true }, userInfo).content; },
     realpath: function (file) { return fsAsUser("realpath", { file: file }, userInfo).path; },
@@ -89,6 +92,7 @@ function getSkillRoots(cwd, opts) {
   var codexHome = env.CODEX_HOME ? path.resolve(homeDir, env.CODEX_HOME) : path.join(homeDir, ".codex");
   var claudeConfigDir = env.CLAUDE_CONFIG_DIR ? path.resolve(homeDir, env.CLAUDE_CONFIG_DIR) : path.join(homeDir, ".claude");
   var roots = [
+    { path: path.join(__dirname, "../bundled-skills"), source: "clay-builtin" },
     { path: path.join(homeDir, ".agents", "skills"), source: "agents-user" },
     { path: path.join(codexHome, "skills"), source: "codex-user" },
     { path: path.join(codexHome, "skills", ".system"), source: "codex-system-user" },
@@ -101,6 +105,8 @@ function getSkillRoots(cwd, opts) {
     roots.push({ path: path.join(cwd, ".codex", "skills", ".system"), source: "codex-system-project" });
     roots.push({ path: path.join(cwd, ".claude", "skills"), source: "claude-project" });
   }
+  roots.push({ path: clayStorage.privateRoot(homeDir), source: "clay-user" });
+  if (cwd) roots.push({ path: clayStorage.privateRoot(cwd), source: "clay-project" });
   return roots;
 }
 
@@ -108,6 +114,20 @@ function discoverSkills(cwd, opts) {
   if (opts && opts.disable) return [];
   var merged = {};
   var roots = getSkillRoots(cwd, opts);
+  var home = path.dirname(path.dirname(roots.find(function (root) { return root.source === "clay-user"; }).path));
+  var legacy = roots.filter(function (root) { return !/^clay-/.test(root.source); }).map(function (root) {
+    return { path: root.path, base: root.source === "project" || /-project$/.test(root.source) ? cwd : home };
+  });
+  // Run filesystem migration as the same OS owner used for skill discovery.
+  if (!opts || !opts.readDir || opts.migrationIdentity) {
+    try {
+      if (opts && opts.migrationIdentity) {
+        var identity = opts.migrationIdentity;
+        var job = require("../os-users").wrapSpawnAsUser(process.execPath, [require.resolve("../clay-skill-storage"), JSON.stringify(legacy)], { uid: identity.uid, gid: identity.gid, timeout: 10000 });
+        require("child_process").execFileSync(job.command, job.args, job.options);
+      } else clayStorage.migrate(legacy);
+    } catch (error) { console.error("[skills] Clay-only skill migration failed: " + error.message); }
+  }
   for (var i = 0; i < roots.length; i++) scanRoot(roots[i].path, roots[i].source, merged, opts);
   return Object.keys(merged).sort().map(function(name) { return merged[name]; });
 }