claude-code-session-manager 0.62.0 → 0.63.0

package/src/main/__tests__/browserAgentServer.test.cjs

@@ -1,235 +0,0 @@
-/**
- * browserAgentServer.test.cjs — unit tests for the loopback-only browser
- * agent HTTP API (PRD 535).
- *
- * Run: timeout 120 node --test src/main/__tests__/browserAgentServer.test.cjs
- */
-
-'use strict';
-
-const { test } = require('node:test');
-const assert = require('node:assert/strict');
-const http = require('node:http');
-const fs = require('node:fs');
-const path = require('node:path');
-const { createBrowserAgentServer, TOKEN_PATH, resolveTokenPath } = require('../browserAgentServer.cjs');
-
-function request(port, { method = 'GET', path: reqPath, token, body }) {
-  return new Promise((resolve, reject) => {
-    const headers = {};
-    if (token !== undefined) headers.Authorization = `Bearer ${token}`;
-    let payload;
-    if (body !== undefined) {
-      payload = JSON.stringify(body);
-      headers['Content-Type'] = 'application/json';
-      headers['Content-Length'] = Buffer.byteLength(payload);
-    }
-    const req = http.request({ hostname: '127.0.0.1', port, method, path: reqPath, headers }, (res) => {
-      const chunks = [];
-      res.on('data', (c) => chunks.push(c));
-      res.on('end', () => {
-        const text = Buffer.concat(chunks).toString('utf8');
-        let json = null;
-        try { json = JSON.parse(text); } catch { /* leave null for non-JSON bodies */ }
-        resolve({ status: res.statusCode, json, text });
-      });
-    });
-    req.on('error', reject);
-    if (payload) req.write(payload);
-    req.end();
-  });
-}
-
-function makeFakeRemote() {
-  const actions = [];
-  return {
-    actions,
-    async listTabs() {
-      return [{ viewId: 'v1', url: 'https://example.com', title: 'Example', active: true }];
-    },
-    async screenshot({ viewId }) {
-      if (!viewId && viewId !== undefined) return { ok: false, error: 'unknown viewId' };
-      return { ok: true, viewId: viewId || 'v1', dataUrl: 'data:image/png;base64,AAA', scale: 1 };
-    },
-    async action(params) {
-      actions.push(params);
-      if (params.action === 'boom') return { ok: false, error: 'unsupported action: boom' };
-      return { ok: true };
-    },
-    async dom({ viewId }) {
-      return { ok: true, viewId: viewId || 'v1', text: 'hello', elements: [] };
-    },
-  };
-}
-
-test('rejects requests without a bearer token', async () => {
-  const remote = makeFakeRemote();
-  const server = createBrowserAgentServer(remote);
-  const { port } = await server.start();
-  try {
-    const res = await request(port, { path: '/agent/browser/tabs' });
-    assert.equal(res.status, 401);
-    assert.equal(res.json.ok, false);
-  } finally {
-    await server.stop();
-  }
-});
-
-test('rejects requests with a wrong token', async () => {
-  const remote = makeFakeRemote();
-  const server = createBrowserAgentServer(remote);
-  const { port } = await server.start();
-  try {
-    const res = await request(port, { path: '/agent/browser/tabs', token: 'wrong-token' });
-    assert.equal(res.status, 401);
-  } finally {
-    await server.stop();
-  }
-});
-
-test('GET /agent/browser/tabs lists open tabs', async () => {
-  const remote = makeFakeRemote();
-  const server = createBrowserAgentServer(remote);
-  const { port, token } = await server.start();
-  try {
-    const res = await request(port, { path: '/agent/browser/tabs', token });
-    assert.equal(res.status, 200);
-    assert.equal(res.json.ok, true);
-    assert.equal(res.json.tabs.length, 1);
-    assert.equal(res.json.tabs[0].active, true);
-  } finally {
-    await server.stop();
-  }
-});
-
-test('POST /agent/browser/screenshot returns a resized image payload', async () => {
-  const remote = makeFakeRemote();
-  const server = createBrowserAgentServer(remote);
-  const { port, token } = await server.start();
-  try {
-    const res = await request(port, { method: 'POST', path: '/agent/browser/screenshot', token, body: {} });
-    assert.equal(res.status, 200);
-    assert.equal(res.json.ok, true);
-    assert.ok(res.json.dataUrl.startsWith('data:image/png'));
-  } finally {
-    await server.stop();
-  }
-});
-
-test('POST /agent/browser/action dispatches a single action', async () => {
-  const remote = makeFakeRemote();
-  const server = createBrowserAgentServer(remote);
-  const { port, token } = await server.start();
-  try {
-    const res = await request(port, {
-      method: 'POST',
-      path: '/agent/browser/action',
-      token,
-      body: { action: 'left_click', coordinate: [10, 20] },
-    });
-    assert.equal(res.status, 200);
-    assert.equal(res.json.ok, true);
-    assert.equal(remote.actions.length, 1);
-    assert.deepEqual(remote.actions[0].coordinate, [10, 20]);
-  } finally {
-    await server.stop();
-  }
-});
-
-test('POST /agent/browser/action without an action field is a 400', async () => {
-  const remote = makeFakeRemote();
-  const server = createBrowserAgentServer(remote);
-  const { port, token } = await server.start();
-  try {
-    const res = await request(port, { method: 'POST', path: '/agent/browser/action', token, body: {} });
-    assert.equal(res.status, 400);
-    assert.equal(res.json.ok, false);
-  } finally {
-    await server.stop();
-  }
-});
-
-test('POST /agent/browser/action surfaces a remote failure as a 400', async () => {
-  const remote = makeFakeRemote();
-  const server = createBrowserAgentServer(remote);
-  const { port, token } = await server.start();
-  try {
-    const res = await request(port, { method: 'POST', path: '/agent/browser/action', token, body: { action: 'boom' } });
-    assert.equal(res.status, 400);
-    assert.equal(res.json.ok, false);
-  } finally {
-    await server.stop();
-  }
-});
-
-test('GET /agent/browser/dom returns a text snapshot', async () => {
-  const remote = makeFakeRemote();
-  const server = createBrowserAgentServer(remote);
-  const { port, token } = await server.start();
-  try {
-    const res = await request(port, { path: '/agent/browser/dom', token });
-    assert.equal(res.status, 200);
-    assert.equal(res.json.text, 'hello');
-  } finally {
-    await server.stop();
-  }
-});
-
-test('unknown route is a 404', async () => {
-  const remote = makeFakeRemote();
-  const server = createBrowserAgentServer(remote);
-  const { port, token } = await server.start();
-  try {
-    const res = await request(port, { path: '/agent/browser/nope', token });
-    assert.equal(res.status, 404);
-  } finally {
-    await server.stop();
-  }
-});
-
-test('SM_DEV=1 writes to a dev-suffixed path, never the production browser-agent-api.json', async () => {
-  const devPath = path.join(path.dirname(TOKEN_PATH), 'browser-agent-api.dev.json');
-  const prevMtime = fs.existsSync(TOKEN_PATH) ? fs.statSync(TOKEN_PATH).mtimeMs : null;
-  const prevEnv = process.env.SM_DEV;
-  const remote = makeFakeRemote();
-  let server;
-  try {
-    process.env.SM_DEV = '1';
-    server = createBrowserAgentServer(remote);
-    const { port, token } = await server.start();
-    assert.equal(resolveTokenPath(), devPath);
-    const parsed = JSON.parse(fs.readFileSync(devPath, 'utf8'));
-    assert.equal(parsed.port, port);
-    assert.equal(parsed.token, token);
-    if (prevMtime !== null) {
-      assert.equal(fs.statSync(TOKEN_PATH).mtimeMs, prevMtime);
-    } else {
-      assert.equal(fs.existsSync(TOKEN_PATH), false);
-    }
-  } finally {
-    if (server) await server.stop();
-    if (prevEnv === undefined) delete process.env.SM_DEV; else process.env.SM_DEV = prevEnv;
-    fs.rmSync(devPath, { force: true });
-  }
-});
-
-test('with neither SM_DEV nor SM_E2E set, writes to the original browser-agent-api.json path', async () => {
-  const prevDev = process.env.SM_DEV;
-  const prevE2e = process.env.SM_E2E;
-  const remote = makeFakeRemote();
-  let server;
-  try {
-    delete process.env.SM_DEV;
-    delete process.env.SM_E2E;
-    assert.equal(resolveTokenPath(), TOKEN_PATH);
-    server = createBrowserAgentServer(remote);
-    const { port, token } = await server.start();
-    const parsed = JSON.parse(fs.readFileSync(TOKEN_PATH, 'utf8'));
-    assert.equal(parsed.port, port);
-    assert.equal(parsed.token, token);
-  } finally {
-    if (server) await server.stop();
-    if (prevDev === undefined) delete process.env.SM_DEV; else process.env.SM_DEV = prevDev;
-    if (prevE2e === undefined) delete process.env.SM_E2E; else process.env.SM_E2E = prevE2e;
-  }
-});

package/src/main/__tests__/browserView-destroyed-handler.test.cjs

@@ -1,85 +0,0 @@
-/**
- * browserView-destroyed-handler.test.cjs — regression test for the
- * webContents.id-after-destroy crash (see
- * session-manager-operations/feedback/processed/
- * 2026-07-30-rca-v0390-blank-screen-unstable-selector-185.md, item 4).
- *
- * The webContents `'destroyed'` handler used to read `view.webContents.id`
- * from inside its own callback, after `view.webContents` could already be
- * undefined — throwing "Cannot read properties of undefined (reading 'id')"
- * on every app quit with an open Browser view. The fix captures the id at
- * creation time, before the destroyed handler is registered.
- *
- * `electron` isn't installed as a runnable binary here, and browserView.cjs
- * pulls it in via a plain CJS `require` (not vite-node's ESM graph), so
- * `vi.mock('electron', ...)` doesn't intercept it. Instead we pre-seed
- * Node's own require cache for the resolved `electron` path with a fake
- * `WebContentsView`, the only export browserView.cjs actually uses.
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/browserView-destroyed-handler.test.cjs
- */
-
-'use strict';
-
-import { test, expect, beforeEach } from 'vitest';
-import { EventEmitter } from 'node:events';
-
-let nextWcId = 1;
-class FakeWebContents extends EventEmitter {
-  constructor() {
-    super();
-    this.id = nextWcId++;
-    this.session = { on() {} };
-  }
-  setZoomFactor() {}
-  setUserAgent() {}
-  setWindowOpenHandler() {}
-  isDestroyed() { return false; }
-}
-class FakeWebContentsView {
-  constructor() {
-    this.webContents = new FakeWebContents();
-  }
-}
-
-const electronPath = require.resolve('electron');
-require.cache[electronPath] = {
-  id: electronPath,
-  filename: electronPath,
-  loaded: true,
-  exports: { WebContentsView: FakeWebContentsView },
-};
-
-const { registerBrowserView, isBrowserViewContents, views } = require('../browserView.cjs');
-
-function makeFakeIpcMain() {
-  const handlers = new Map();
-  return {
-    handle: (channel, fn) => handlers.set(channel, fn),
-    on: (channel, fn) => handlers.set(channel, fn),
-    invoke: (channel, payload) => handlers.get(channel)(null, payload),
-  };
-}
-
-let ipcMain;
-beforeEach(() => {
-  ipcMain = makeFakeIpcMain();
-  registerBrowserView({ mainWindow: { isDestroyed: () => true }, ipcMain });
-});
-
-test('destroyed handler does not throw when view.webContents is already undefined', async () => {
-  const viewId = `t-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-  const result = await ipcMain.invoke('browser:create', { viewId, partition: 'sm-test' });
-  expect(result.ok).toBe(true);
-
-  const view = views.get(viewId);
-  const wc = view.webContents;
-  expect(isBrowserViewContents(wc.id)).toBe(true);
-
-  // Simulate the real crash precondition: webContents already gone by the
-  // time the 'destroyed' listener fires (e.g. on app quit).
-  view.webContents = undefined;
-
-  expect(() => wc.emit('destroyed')).not.toThrow();
-  expect(isBrowserViewContents(wc.id)).toBe(false);
-});

package/src/main/__tests__/browserView-oauth-popup.test.cjs

@@ -1,126 +0,0 @@
-/**
- * browserView-oauth-popup.test.cjs — regression test for Google (and other
- * identity-provider) OAuth login failing inside the Browser tab.
- *
- * Root cause: wc.setWindowOpenHandler() in browserView.cjs unconditionally
- * denied every window.open() popup, which kills Google's GIS/FedCM popup —
- * it needs a real window.opener to postMessage the credential back to. This
- * test asserts identity-provider popups get `{ action: 'allow', ... }` (a
- * real child window) while every other popup keeps the existing deny +
- * browser:open-tab-request behavior, and that a realistic Chrome
- * User-Agent (not Electron's default) is set on both the main view and the
- * popup's webContents.
- *
- * `electron` isn't installed as a runnable binary here, and browserView.cjs
- * pulls it in via a plain CJS `require` (not vite-node's ESM graph), so
- * `vi.mock('electron', ...)` doesn't intercept it. Instead we pre-seed
- * Node's own require cache for the resolved `electron` path with a fake
- * `WebContentsView`, the only export browserView.cjs actually uses — same
- * pattern as browserView-destroyed-handler.test.cjs.
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/browserView-oauth-popup.test.cjs
- */
-
-'use strict';
-
-import { test, expect, beforeEach } from 'vitest';
-import { EventEmitter } from 'node:events';
-
-let nextWcId = 1;
-class FakeWebContents extends EventEmitter {
-  constructor() {
-    super();
-    this.id = nextWcId++;
-    this.session = { on() {} };
-    this.userAgent = null;
-    this._windowOpenHandler = null;
-  }
-  setZoomFactor() {}
-  setUserAgent(ua) { this.userAgent = ua; }
-  setWindowOpenHandler(fn) { this._windowOpenHandler = fn; }
-  isDestroyed() { return false; }
-}
-class FakeWebContentsView {
-  constructor() {
-    this.webContents = new FakeWebContents();
-  }
-}
-class FakeBrowserWindow {
-  constructor() {
-    this.webContents = new FakeWebContents();
-  }
-}
-
-const electronPath = require.resolve('electron');
-require.cache[electronPath] = {
-  id: electronPath,
-  filename: electronPath,
-  loaded: true,
-  exports: { WebContentsView: FakeWebContentsView },
-};
-
-const { registerBrowserView, views, isBrowserViewContents } = require('../browserView.cjs');
-
-function makeFakeIpcMain() {
-  const handlers = new Map();
-  return {
-    handle: (channel, fn) => handlers.set(channel, fn),
-    on: (channel, fn) => handlers.set(channel, fn),
-    invoke: (channel, payload) => handlers.get(channel)(null, payload),
-  };
-}
-
-let ipcMain;
-beforeEach(() => {
-  ipcMain = makeFakeIpcMain();
-  registerBrowserView({ mainWindow: { isDestroyed: () => true }, ipcMain });
-});
-
-test('main view webContents gets a real Chrome user-agent, not the Electron default', async () => {
-  const viewId = `oauth-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-  await ipcMain.invoke('browser:create', { viewId, partition: 'sm-test' });
-  const view = views.get(viewId);
-  expect(view.webContents.userAgent).toBeTruthy();
-  expect(view.webContents.userAgent).not.toMatch(/Electron/);
-  expect(view.webContents.userAgent).toMatch(/Chrome\//);
-});
-
-test('setWindowOpenHandler allows identity-provider popups with a real child window and denies others', async () => {
-  const viewId = `oauth2-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-  await ipcMain.invoke('browser:create', { viewId, partition: 'sm-test' });
-  const view = views.get(viewId);
-  const handler = view.webContents._windowOpenHandler;
-  expect(typeof handler).toBe('function');
-
-  const allowed = handler({ url: 'https://accounts.google.com/o/oauth2/v2/auth?foo=bar' });
-  expect(allowed.action).toBe('allow');
-  expect(allowed.overrideBrowserWindowOptions.webPreferences).toEqual({
-    contextIsolation: true,
-    nodeIntegration: false,
-    sandbox: true,
-  });
-
-  const denied = handler({ url: 'https://example.com/some-popup' });
-  expect(denied).toEqual({ action: 'deny' });
-});
-
-test('identity-provider popup child window gets a Chrome UA and cleans up on destroy', async () => {
-  const viewId = `oauth3-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-  await ipcMain.invoke('browser:create', { viewId, partition: 'sm-test' });
-  const view = views.get(viewId);
-
-  const childWindow = new FakeBrowserWindow();
-  view.webContents.emit('did-create-window', childWindow);
-
-  expect(childWindow.webContents.userAgent).toBeTruthy();
-  expect(childWindow.webContents.userAgent).toMatch(/Chrome\//);
-
-  // The popup's webContents.id must be exempted from index.cjs's global
-  // will-navigate lock the same way the main Browser view is — otherwise
-  // the OAuth handshake this fix enables would immediately get nav-locked
-  // shut once the popup tries to navigate through consent/callback pages.
-  expect(isBrowserViewContents(childWindow.webContents.id)).toBe(true);
-
-  expect(() => childWindow.webContents.emit('destroyed')).not.toThrow();
-  expect(isBrowserViewContents(childWindow.webContents.id)).toBe(false);
-});

package/src/main/__tests__/web-remote-e2e-pinning.test.cjs

@@ -1,181 +0,0 @@
-'use strict';
-
-/**
- * web-remote-e2e-pinning.test.cjs — TOFU pinning for the web-remote E2E handshake.
- *
- * Once a browser's SPKI pubkey is manually SAS-confirmed for a paired device,
- * a later `e2e:hello` presenting the SAME pubkey for that device should
- * auto-authenticate (no `confirm-sas` needed); a DIFFERENT pubkey must still
- * fall through to the manual `pending_sas` flow.
- *
- * Runs against a tmp HOME (config.cjs / webRemote.cjs both resolve paths off
- * os.homedir()) and stubs the `electron` module in require.cache, mirroring
- * the tmp-HOME + require.cache-stub pattern used by exchanges.test.cjs.
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/web-remote-e2e-pinning.test.cjs
- */
-
-import { describe, it, expect, beforeAll, afterAll } from 'vitest'
-
-const fs = require('node:fs')
-const fsp = require('node:fs/promises')
-const path = require('node:path')
-const os = require('node:os')
-const crypto = require('node:crypto')
-
-/** Generate a P-256 keypair in the same encoding webRemote.cjs uses (SPKI/PKCS8, base64url). */
-function genP256KeyPairB64() {
-  const { privateKey, publicKey } = crypto.generateKeyPairSync('ec', {
-    namedCurve: 'P-256',
-    publicKeyEncoding: { type: 'spki', format: 'der' },
-    privateKeyEncoding: { type: 'pkcs8', format: 'der' },
-  })
-  return {
-    priv: privateKey.toString('base64url'),
-    pub: publicKey.toString('base64url'),
-  }
-}
-
-let tmpHome
-let origHome
-let webRemote
-let configPath
-let handlers // captured ipcMain.handle(name, fn) map
-
-function freshRequire(mod) {
-  delete require.cache[require.resolve(mod)]
-  return require(mod)
-}
-
-async function readConfig() {
-  const text = await fsp.readFile(configPath, 'utf8')
-  return JSON.parse(text)
-}
-
-async function writeConfig(cfg) {
-  await fsp.mkdir(path.dirname(configPath), { recursive: true })
-  await fsp.writeFile(configPath, JSON.stringify(cfg, null, 2) + '\n')
-}
-
-beforeAll(async () => {
-  tmpHome = await fsp.mkdtemp(path.join(os.tmpdir(), 'web-remote-e2e-pinning-'))
-  origHome = process.env.HOME
-  process.env.HOME = tmpHome
-
-  // Stub 'electron' before webRemote.cjs (and logs.cjs, transitively) require it —
-  // outside a real Electron process, require('electron') just resolves to a path
-  // string, so destructuring { ipcMain, app } off it would throw at module load.
-  handlers = new Map()
-  const electronPath = require.resolve('electron')
-  require.cache[electronPath] = {
-    id: electronPath,
-    filename: electronPath,
-    loaded: true,
-    exports: {
-      ipcMain: {
-        handle: (name, fn) => handlers.set(name, fn),
-        on: () => {},
-      },
-      app: {
-        getPath: () => tmpHome,
-        getVersion: () => '0.0.0-test',
-      },
-    },
-  }
-
-  // Clear anything already cached under the real HOME so paths re-resolve under tmpHome.
-  for (const mod of ['../webRemote.cjs', '../config.cjs', '../logs.cjs', './e2eStateMachine.cjs']) {
-    try { delete require.cache[require.resolve(mod)] } catch { /* not yet loaded */ }
-  }
-
-  webRemote = freshRequire('../webRemote.cjs')
-  configPath = path.join(tmpHome, '.claude', 'session-manager', 'web-remote.json')
-
-  webRemote.registerRemoteHandlers()
-})
-
-afterAll(async () => {
-  process.env.HOME = origHome
-  await fsp.rm(tmpHome, { recursive: true, force: true })
-})
-
-describe('web-remote E2E SAS pinning', () => {
-  const deviceKeys = genP256KeyPairB64() // desktop's own E2E keypair
-  const browserA = genP256KeyPairB64() // first browser's keypair
-  const browserB = genP256KeyPairB64() // a different browser's keypair
-  const deviceId = 'device-under-test'
-
-  function baseDeviceRow(overrides = {}) {
-    return {
-      deviceId,
-      deviceToken: 'tok-abc',
-      e2ePrivateKey: deviceKeys.priv,
-      e2ePublicKey: deviceKeys.pub,
-      deviceName: 'Test Device',
-      issuedAt: new Date(0).toISOString(),
-      lastConnectedAt: null,
-      verifiedPeerPubKey: null,
-      ...overrides,
-    }
-  }
-
-  it('1) first e2e:hello for a never-confirmed device lands in pending_sas', async () => {
-    await writeConfig({ remoteEnabled: true, remoteControlEnabled: false, devices: [baseDeviceRow()] })
-
-    const cfg = await readConfig()
-    const device = cfg.devices[0]
-    await webRemote._internal.handleMessage(
-      JSON.stringify({ type: 'e2e:hello', id: 'm1', payload: { pubKey: browserA.pub } }),
-      device
-    )
-
-    expect(webRemote._internal.getE2eState().state).toBe('pending_sas')
-  })
-
-  it('2) a manual confirm-sas persists the connected device\'s verifiedPeerPubKey', async () => {
-    const confirmSas = handlers.get('webRemote:confirm-sas')
-    expect(typeof confirmSas).toBe('function')
-
-    const result = await confirmSas()
-    expect(result.ok).toBe(true)
-    expect(webRemote._internal.getE2eState().state).toBe('authenticated')
-
-    const cfg = await readConfig()
-    const persisted = cfg.devices.find((d) => d.deviceId === deviceId)
-    expect(persisted.verifiedPeerPubKey).toBe(browserA.pub)
-  })
-
-  it('3) a second e2e:hello presenting the SAME browserPubKey auto-authenticates (no confirm-sas)', async () => {
-    // Simulate a fresh reconnect: new WS session resets E2E state, and the device
-    // row is reloaded from disk (as connect() would), now carrying the pinned key.
-    webRemote._internal.resetE2e()
-    expect(webRemote._internal.getE2eState().state).toBe('idle')
-
-    const cfg = await readConfig()
-    const device = cfg.devices.find((d) => d.deviceId === deviceId)
-    expect(device.verifiedPeerPubKey).toBe(browserA.pub)
-
-    await webRemote._internal.handleMessage(
-      JSON.stringify({ type: 'e2e:hello', id: 'm2', payload: { pubKey: browserA.pub } }),
-      device
-    )
-
-    expect(webRemote._internal.getE2eState().state).toBe('authenticated')
-  })
-
-  it('4) a e2e:hello presenting a DIFFERENT browserPubKey still lands in pending_sas', async () => {
-    webRemote._internal.resetE2e()
-    expect(webRemote._internal.getE2eState().state).toBe('idle')
-
-    const cfg = await readConfig()
-    const device = cfg.devices.find((d) => d.deviceId === deviceId)
-    expect(device.verifiedPeerPubKey).toBe(browserA.pub) // still pinned to A, not B
-
-    await webRemote._internal.handleMessage(
-      JSON.stringify({ type: 'e2e:hello', id: 'm3', payload: { pubKey: browserB.pub } }),
-      device
-    )
-
-    expect(webRemote._internal.getE2eState().state).toBe('pending_sas')
-  })
-})