relay-ide 0.1.0

package/dist/test/branch-linker.test.js

@@ -0,0 +1,236 @@
+import { test, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import express from 'express';
+import { createBranchLinkerRouter, invalidateBranchLinkerCache, } from '../server/branch-linker.js';
+import { saveConfig, DEFAULTS } from '../server/config.js';
+let tmpDir;
+let configPath;
+let server;
+let baseUrl;
+const WORKSPACE_PATH_A = '/fake/workspace/repo-a';
+const WORKSPACE_PATH_B = '/fake/workspace/repo-b';
+/**
+ * Creates a mock execAsync that returns configured branch lists per cwd.
+ * - `git branch -a` → returns newline-joined branch names or throws
+ */
+function makeMockExec(opts) {
+    return async (cmd, args, options) => {
+        const command = cmd;
+        const argv = args;
+        const cwd = options.cwd ?? '';
+        if (command === 'git' && argv[0] === 'branch') {
+            if (opts.errorByPath?.[cwd])
+                throw opts.errorByPath[cwd];
+            const branches = opts.branchesByPath?.[cwd] ?? [];
+            return { stdout: branches.join('\n') + '\n', stderr: '' };
+        }
+        throw new Error(`Unexpected exec call: ${command} ${argv.join(' ')}`);
+    };
+}
+function startServer(execAsyncFn, getActiveBranchNames) {
+    return new Promise((resolve) => {
+        const app = express();
+        app.use(express.json());
+        const deps = {
+            configPath,
+            execAsync: execAsyncFn,
+            ...(getActiveBranchNames ? { getActiveBranchNames } : {}),
+        };
+        app.use('/branch-linker', createBranchLinkerRouter(deps));
+        server = app.listen(0, '127.0.0.1', () => {
+            const addr = server.address();
+            if (typeof addr === 'object' && addr) {
+                baseUrl = `http://127.0.0.1:${addr.port}`;
+            }
+            resolve();
+        });
+    });
+}
+function stopServer() {
+    return new Promise((resolve) => {
+        if (server)
+            server.close(() => resolve());
+        else
+            resolve();
+    });
+}
+async function getLinks() {
+    const res = await fetch(`${baseUrl}/branch-linker/links`);
+    return res.json();
+}
+before(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'branch-linker-test-'));
+    configPath = path.join(tmpDir, 'config.json');
+    // Clear any module-level cache before test suite runs
+    invalidateBranchLinkerCache();
+});
+after(async () => {
+    await stopServer();
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+test('extracts Jira ticket IDs from branch names', async () => {
+    await stopServer();
+    invalidateBranchLinkerCache();
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        repos: [WORKSPACE_PATH_A],
+    });
+    const exec = makeMockExec({
+        branchesByPath: {
+            [WORKSPACE_PATH_A]: ['dy/fix/ACME-123-auth', 'main'],
+        },
+    });
+    await startServer(exec);
+    const data = await getLinks();
+    assert.ok('ACME-123' in data, 'Should extract ACME-123 from branch name');
+    const links = data['ACME-123'];
+    assert.equal(links.length, 1);
+    assert.equal(links[0].branchName, 'dy/fix/ACME-123-auth');
+    assert.equal(links[0].repoPath, WORKSPACE_PATH_A);
+    assert.equal(links[0].repoName, 'repo-a');
+});
+test('extracts GH issue IDs from gh-N branches', async () => {
+    await stopServer();
+    invalidateBranchLinkerCache();
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        repos: [WORKSPACE_PATH_A],
+    });
+    const exec = makeMockExec({
+        branchesByPath: {
+            // Use a branch that only the GH regex matches (no embedded uppercase-only letters)
+            // to get a single clean GH-42 link. The Jira regex (/[A-Z]{2,}-\d+/gi) would also
+            // match 'gh-42' since the flag is case-insensitive, so we use a prefix that isolates
+            // the GH regex match by starting with 'gh-' at the very start of the branch name.
+            [WORKSPACE_PATH_A]: ['gh-42-login-fix'],
+        },
+    });
+    await startServer(exec);
+    const data = await getLinks();
+    assert.ok('GH-42' in data, 'Should extract GH-42 from branch name');
+    const links = data['GH-42'];
+    // Only the GH regex matches this branch — the Jira regex explicitly excludes 'GH'
+    // to avoid double-matching. Verify all links point to the correct branch and repo.
+    assert.ok(links.length >= 1, 'Should have at least one GH-42 link');
+    assert.ok(links.every((l) => l.branchName === 'gh-42-login-fix'), 'All links should reference the correct branch');
+    assert.ok(links.every((l) => l.repoPath === WORKSPACE_PATH_A), 'All links should reference the correct repo');
+});
+test('same ticket in two repos yields array of 2 BranchLinks', async () => {
+    await stopServer();
+    invalidateBranchLinkerCache();
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        repos: [WORKSPACE_PATH_A, WORKSPACE_PATH_B],
+    });
+    const exec = makeMockExec({
+        branchesByPath: {
+            [WORKSPACE_PATH_A]: ['feature/PROJ-99-payment'],
+            [WORKSPACE_PATH_B]: ['bugfix/PROJ-99-payment-fix'],
+        },
+    });
+    await startServer(exec);
+    const data = await getLinks();
+    assert.ok('PROJ-99' in data, 'Should have PROJ-99 key');
+    const links = data['PROJ-99'];
+    assert.equal(links.length, 2, 'Should have 2 BranchLinks for the same ticket across 2 repos');
+    const repoPaths = links.map((l) => l.repoPath).sort();
+    assert.deepEqual(repoPaths, [WORKSPACE_PATH_A, WORKSPACE_PATH_B].sort());
+});
+test('ignores branches without ticket IDs', async () => {
+    await stopServer();
+    invalidateBranchLinkerCache();
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        repos: [WORKSPACE_PATH_A],
+    });
+    const exec = makeMockExec({
+        branchesByPath: {
+            [WORKSPACE_PATH_A]: [
+                'main',
+                'develop',
+                'chore/cleanup',
+                'feature/new-ui',
+            ],
+        },
+    });
+    await startServer(exec);
+    const data = await getLinks();
+    assert.equal(Object.keys(data).length, 0, 'Plain branches should produce no ticket links');
+});
+test('hasActiveSession true when branch is in active set', async () => {
+    await stopServer();
+    invalidateBranchLinkerCache();
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        repos: [WORKSPACE_PATH_A],
+    });
+    const activeBranch = 'feature/ACTIVE-1-work';
+    const exec = makeMockExec({
+        branchesByPath: {
+            [WORKSPACE_PATH_A]: [activeBranch, 'feature/INACTIVE-2-other'],
+        },
+    });
+    const getActiveBranchNames = () => {
+        return new Map([[WORKSPACE_PATH_A, new Set([activeBranch])]]);
+    };
+    await startServer(exec, getActiveBranchNames);
+    const data = await getLinks();
+    const activeLinks = data['ACTIVE-1'];
+    assert.ok(activeLinks, 'Should have ACTIVE-1 ticket');
+    assert.equal(activeLinks.length, 1);
+    assert.equal(activeLinks[0].hasActiveSession, true, 'Active branch should have hasActiveSession true');
+    const inactiveLinks = data['INACTIVE-2'];
+    assert.ok(inactiveLinks, 'Should have INACTIVE-2 ticket');
+    assert.equal(inactiveLinks[0].hasActiveSession, false, 'Inactive branch should have hasActiveSession false');
+});
+test('invalidateBranchLinkerCache forces fresh scan', async () => {
+    await stopServer();
+    invalidateBranchLinkerCache();
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        repos: [WORKSPACE_PATH_A],
+    });
+    let gitCallCount = 0;
+    const baseExec = makeMockExec({
+        branchesByPath: {
+            [WORKSPACE_PATH_A]: ['feature/SCAN-1-fresh'],
+        },
+    });
+    const countingExec = async (...args) => {
+        const [cmd] = args;
+        if (cmd === 'git')
+            gitCallCount++;
+        return baseExec(...args);
+    };
+    await startServer(countingExec);
+    // First request — populates module-level cache
+    const first = await getLinks();
+    assert.ok('SCAN-1' in first, 'Should have SCAN-1 after first request');
+    assert.equal(gitCallCount, 1, 'git should be called once on first request');
+    // Second request — served from cache
+    const second = await getLinks();
+    assert.ok('SCAN-1' in second);
+    assert.equal(gitCallCount, 1, 'git should not be called again within TTL');
+    // Invalidate cache
+    invalidateBranchLinkerCache();
+    // Third request — cache is cleared, should fetch fresh
+    const third = await getLinks();
+    assert.ok('SCAN-1' in third);
+    assert.equal(gitCallCount, 2, 'git should be called again after cache invalidation');
+});
+test('returns empty object when no workspaces', async () => {
+    await stopServer();
+    invalidateBranchLinkerCache();
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        repos: [],
+    });
+    // execAsync should never be called here
+    const exec = makeMockExec({});
+    await startServer(exec);
+    const data = await getLinks();
+    assert.equal(Object.keys(data).length, 0, 'Should return empty object when no workspaces configured');
+});

package/dist/test/branch-rename.test.js

@@ -0,0 +1,45 @@
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import { MOUNTAIN_NAMES } from '../server/types.js';
+import { branchToDisplayName } from '../server/git.js';
+describe('MOUNTAIN_NAMES', () => {
+    test('contains 30 mountain names', () => {
+        assert.equal(MOUNTAIN_NAMES.length, 30);
+    });
+    test('all names are lowercase kebab-case', () => {
+        for (const name of MOUNTAIN_NAMES) {
+            assert.match(name, /^[a-z][a-z0-9-]*$/, `Mountain name "${name}" is not kebab-case`);
+        }
+    });
+    test('no duplicate names', () => {
+        const unique = new Set(MOUNTAIN_NAMES);
+        assert.equal(unique.size, MOUNTAIN_NAMES.length);
+    });
+    test('cycling wraps around at array length', () => {
+        let idx = 28;
+        const name1 = MOUNTAIN_NAMES[idx % MOUNTAIN_NAMES.length];
+        idx++;
+        const name2 = MOUNTAIN_NAMES[idx % MOUNTAIN_NAMES.length];
+        idx++;
+        const name3 = MOUNTAIN_NAMES[idx % MOUNTAIN_NAMES.length];
+        assert.equal(name1, 'whitney');
+        assert.equal(name2, 'hood');
+        assert.equal(name3, 'everest'); // wraps back to start
+    });
+});
+describe('branchToDisplayName', () => {
+    test('converts kebab-case to sentence case', () => {
+        assert.equal(branchToDisplayName('fix-mobile-scroll-bug'), 'Fix mobile scroll bug');
+    });
+    test('strips common branch prefixes', () => {
+        assert.equal(branchToDisplayName('feature/add-auth'), 'Add auth');
+        assert.equal(branchToDisplayName('fix/api-timeout'), 'Api timeout');
+        assert.equal(branchToDisplayName('chore/update-deps'), 'Update deps');
+    });
+    test('handles simple names', () => {
+        assert.equal(branchToDisplayName('lhotse'), 'Lhotse');
+    });
+    test('handles underscores', () => {
+        assert.equal(branchToDisplayName('fix_the_thing'), 'Fix the thing');
+    });
+});

package/dist/test/branch-watcher.test.js

@@ -0,0 +1,115 @@
+import { describe, it, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { execFileSync } from 'node:child_process';
+import { BranchWatcher } from '../server/watcher.js';
+function makeTempGitRepo() {
+    // Resolve symlinks (macOS /var → /private/var) so paths match git output
+    const dir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'branch-watcher-test-')));
+    execFileSync('git', ['init', '-b', 'main'], { cwd: dir });
+    execFileSync('git', [
+        '-c',
+        'user.name=Test',
+        '-c',
+        'user.email=test@test.com',
+        'commit',
+        '--allow-empty',
+        '-m',
+        'init',
+    ], { cwd: dir });
+    return dir;
+}
+describe('BranchWatcher', () => {
+    const cleanups = [];
+    afterEach(() => {
+        for (const fn of cleanups) {
+            try {
+                fn();
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        cleanups.length = 0;
+    });
+    it('detects branch change via HEAD file write', async () => {
+        const repoDir = makeTempGitRepo();
+        const parentDir = path.dirname(repoDir);
+        cleanups.push(() => fs.rmSync(repoDir, { recursive: true, force: true }));
+        const events = [];
+        const watcher = new BranchWatcher((cwdPath, newBranch) => {
+            events.push({ cwdPath, newBranch });
+        });
+        cleanups.push(() => watcher.close());
+        watcher.rebuild([parentDir]);
+        // Let fs.watch initialize
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        // Create the branch first, then simulate checkout by writing HEAD directly
+        // (more deterministic than git checkout which uses lock+rename)
+        execFileSync('git', ['branch', 'feature-test'], { cwd: repoDir });
+        const headPath = path.join(repoDir, '.git', 'HEAD');
+        fs.writeFileSync(headPath, 'ref: refs/heads/feature-test\n');
+        // Wait for debounce (300ms) + processing
+        await new Promise((resolve) => setTimeout(resolve, 800));
+        assert.ok(events.length > 0, 'Expected at least one branch change event');
+        const lastEvent = events[events.length - 1];
+        assert.equal(lastEvent.cwdPath, repoDir);
+        assert.equal(lastEvent.newBranch, 'feature-test');
+    });
+    it('does not fire callback if branch did not change', async () => {
+        const repoDir = makeTempGitRepo();
+        const parentDir = path.dirname(repoDir);
+        cleanups.push(() => fs.rmSync(repoDir, { recursive: true, force: true }));
+        const events = [];
+        const watcher = new BranchWatcher((cwdPath, newBranch) => {
+            events.push({ cwdPath, newBranch });
+        });
+        cleanups.push(() => watcher.close());
+        watcher.rebuild([parentDir]);
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        // Touch the HEAD file without changing the branch content
+        const headPath = path.join(repoDir, '.git', 'HEAD');
+        const content = fs.readFileSync(headPath, 'utf-8');
+        fs.writeFileSync(headPath, content);
+        await new Promise((resolve) => setTimeout(resolve, 800));
+        assert.equal(events.length, 0, 'Should not fire callback when branch is unchanged');
+    });
+    it('detects second branch change after atomic rename (inode change)', async () => {
+        const repoDir = makeTempGitRepo();
+        const parentDir = path.dirname(repoDir);
+        cleanups.push(() => fs.rmSync(repoDir, { recursive: true, force: true }));
+        const events = [];
+        const watcher = new BranchWatcher((cwdPath, newBranch) => {
+            events.push({ cwdPath, newBranch });
+        });
+        cleanups.push(() => watcher.close());
+        watcher.rebuild([parentDir]);
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        const headPath = path.join(repoDir, '.git', 'HEAD');
+        // First change: simulate git's atomic checkout (write to .lock, rename over HEAD)
+        // This changes the inode, which would kill kqueue-based watchers
+        execFileSync('git', ['branch', 'branch-one'], { cwd: repoDir });
+        const lockPath = headPath + '.lock';
+        fs.writeFileSync(lockPath, 'ref: refs/heads/branch-one\n');
+        fs.renameSync(lockPath, headPath);
+        await new Promise((resolve) => setTimeout(resolve, 800));
+        assert.ok(events.length >= 1, 'Expected at least one event after first atomic rename');
+        assert.equal(events[events.length - 1].newBranch, 'branch-one');
+        // Second change: simulate another atomic checkout — this would fail without
+        // watcher recreation because the old watcher tracked the deleted inode
+        execFileSync('git', ['branch', 'branch-two'], { cwd: repoDir });
+        const lockPath2 = headPath + '.lock';
+        fs.writeFileSync(lockPath2, 'ref: refs/heads/branch-two\n');
+        fs.renameSync(lockPath2, headPath);
+        await new Promise((resolve) => setTimeout(resolve, 800));
+        const secondChange = events.find((e) => e.newBranch === 'branch-two');
+        assert.ok(secondChange, 'Expected branch-two event after second atomic rename (watcher must survive inode change)');
+    });
+    it('closes cleanly', () => {
+        const watcher = new BranchWatcher(() => { });
+        watcher.close();
+        // No error means success
+    });
+});

package/dist/test/browser-cli.test.js

@@ -0,0 +1,91 @@
+import { test, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { execFileSync } from 'node:child_process';
+let tmpDir;
+beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'browser-cli-test-'));
+    fs.writeFileSync(path.join(tmpDir, 'test.html'), '<h1>Test</h1>');
+});
+afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+test('browser command with no args prints usage and exits 1', () => {
+    try {
+        execFileSync('node', ['dist/bin/claude-remote-cli.js', 'browser'], {
+            encoding: 'utf-8',
+            env: { ...process.env, PATH: process.env.PATH },
+        });
+        assert.fail('Should have exited with code 1');
+    }
+    catch (err) {
+        const e = err;
+        assert.strictEqual(e.status, 1);
+        assert.ok((e.stderr ?? '').includes('Usage'));
+    }
+});
+test('browser --help shows usage and exits 0', () => {
+    try {
+        const output = execFileSync('node', ['dist/bin/claude-remote-cli.js', 'browser', '--help'], {
+            encoding: 'utf-8',
+            env: { ...process.env, PATH: process.env.PATH },
+        });
+        assert.ok(output.includes('Usage') || output.includes('browser'));
+    }
+    catch (err) {
+        const e = err;
+        // --help may print to stderr
+        const out = (e.stdout ?? '') + (e.stderr ?? '');
+        assert.ok(out.includes('Usage') || out.includes('browser'));
+    }
+});
+test('browser command fails gracefully when server is not running', () => {
+    try {
+        execFileSync('node', [
+            'dist/bin/claude-remote-cli.js',
+            'browser',
+            path.join(tmpDir, 'test.html'),
+        ], {
+            encoding: 'utf-8',
+            env: {
+                ...process.env,
+                CLAUDE_REMOTE_PORT: '19999',
+                CLAUDE_REMOTE_BROWSER_TOKEN: 'test-token',
+                PATH: process.env.PATH,
+            },
+        });
+        assert.fail('Should have exited with error');
+    }
+    catch (err) {
+        const e = err;
+        assert.ok(e.status !== 0);
+        assert.ok((e.stderr ?? '').includes('connect') ||
+            (e.stderr ?? '').includes('ECONNREFUSED') ||
+            (e.stderr ?? '').includes('Error'));
+    }
+});
+test('browser command fails when token not set', () => {
+    try {
+        execFileSync('node', [
+            'dist/bin/claude-remote-cli.js',
+            'browser',
+            path.join(tmpDir, 'test.html'),
+        ], {
+            encoding: 'utf-8',
+            env: {
+                ...process.env,
+                CLAUDE_REMOTE_PORT: '19999',
+                CLAUDE_REMOTE_BROWSER_TOKEN: '', // empty token
+                PATH: process.env.PATH,
+            },
+        });
+        assert.fail('Should have exited with error');
+    }
+    catch (err) {
+        const e = err;
+        assert.ok(e.status !== 0);
+        assert.ok((e.stderr ?? '').includes('CLAUDE_REMOTE_BROWSER_TOKEN'));
+    }
+});

package/dist/test/browser-content.test.js

@@ -0,0 +1,93 @@
+import { test, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { createBrowserToken, validateToken, resolveTokenPath, generateScopedToken, validateScopedToken, cleanExpiredTokens, getTokenForPath, _resetForTesting, } from '../server/browser-content.js';
+let tmpDir;
+beforeEach(() => {
+    _resetForTesting();
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'browser-content-test-'));
+    fs.writeFileSync(path.join(tmpDir, 'index.html'), '<h1>Hello</h1>');
+    fs.writeFileSync(path.join(tmpDir, 'styles.css'), 'body { color: red; }');
+    fs.mkdirSync(path.join(tmpDir, 'sub'));
+    fs.writeFileSync(path.join(tmpDir, 'sub', 'nested.js'), 'console.log("hi")');
+});
+afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+// Content token tests
+test('createBrowserToken returns a token string', () => {
+    const token = createBrowserToken(path.join(tmpDir, 'index.html'));
+    assert.ok(typeof token === 'string');
+    assert.ok(token.length > 0);
+});
+test('validateToken returns baseDir for valid token', () => {
+    const filePath = path.join(tmpDir, 'index.html');
+    const token = createBrowserToken(filePath);
+    const result = validateToken(token);
+    assert.ok(result);
+    assert.strictEqual(result.baseDir, tmpDir);
+});
+test('validateToken returns null for invalid token', () => {
+    assert.strictEqual(validateToken('nonexistent-token'), null);
+});
+test('resolveTokenPath serves file within baseDir', () => {
+    const filePath = path.join(tmpDir, 'index.html');
+    const token = createBrowserToken(filePath);
+    assert.strictEqual(resolveTokenPath(token, 'index.html'), filePath);
+});
+test('resolveTokenPath serves nested file', () => {
+    const filePath = path.join(tmpDir, 'index.html');
+    const token = createBrowserToken(filePath);
+    assert.strictEqual(resolveTokenPath(token, 'sub/nested.js'), path.join(tmpDir, 'sub', 'nested.js'));
+});
+test('resolveTokenPath rejects path traversal', () => {
+    const token = createBrowserToken(path.join(tmpDir, 'index.html'));
+    assert.strictEqual(resolveTokenPath(token, '../../../etc/passwd'), null);
+});
+test('resolveTokenPath rejects absolute path in relative', () => {
+    const token = createBrowserToken(path.join(tmpDir, 'index.html'));
+    assert.strictEqual(resolveTokenPath(token, '/etc/passwd'), null);
+});
+// Scoped auth token tests
+test('generateScopedToken returns a hex string', () => {
+    const token = generateScopedToken();
+    assert.ok(/^[a-f0-9]+$/.test(token));
+});
+test('validateScopedToken returns true for correct token', () => {
+    const token = generateScopedToken();
+    assert.strictEqual(validateScopedToken(token), true);
+});
+test('validateScopedToken returns false for wrong token', () => {
+    generateScopedToken();
+    assert.strictEqual(validateScopedToken('wrong-token'), false);
+});
+// Token expiry tests
+test('cleanExpiredTokens removes old tokens', () => {
+    const token = createBrowserToken(path.join(tmpDir, 'index.html'));
+    assert.ok(validateToken(token));
+    cleanExpiredTokens(0); // TTL of 0ms = everything expired
+    assert.strictEqual(validateToken(token), null);
+});
+test('cleanExpiredTokens keeps fresh tokens', () => {
+    const token = createBrowserToken(path.join(tmpDir, 'index.html'));
+    cleanExpiredTokens(24 * 60 * 60 * 1000);
+    assert.ok(validateToken(token));
+});
+// Idempotent token creation
+test('createBrowserToken for same path returns existing token', () => {
+    const filePath = path.join(tmpDir, 'index.html');
+    const token1 = createBrowserToken(filePath);
+    const token2 = createBrowserToken(filePath);
+    assert.strictEqual(token1, token2);
+});
+// getTokenForPath
+test('getTokenForPath returns token for known path', () => {
+    const filePath = path.join(tmpDir, 'index.html');
+    const token = createBrowserToken(filePath);
+    assert.strictEqual(getTokenForPath(filePath), token);
+});
+test('getTokenForPath returns null for unknown path', () => {
+    assert.strictEqual(getTokenForPath('/no/such/file'), null);
+});

package/dist/test/browser-tabs-ui.test.js

@@ -0,0 +1,39 @@
+import { test } from 'node:test';
+import assert from 'node:assert';
+// Test the pure logic of tab identity and deduplication.
+// We can't import .svelte.ts files in node:test (they need the Svelte compiler),
+// so we test the logic by duplicating the key algorithm here.
+function tabKey(filePath, tabType) {
+    return `${tabType}::${filePath}`;
+}
+test('tabKey differentiates same file with different types', () => {
+    const diffKey = tabKey('/tmp/index.html', 'diff');
+    const htmlKey = tabKey('/tmp/index.html', 'html');
+    assert.notStrictEqual(diffKey, htmlKey);
+});
+test('tabKey matches same file with same type', () => {
+    const key1 = tabKey('/tmp/index.html', 'html');
+    const key2 = tabKey('/tmp/index.html', 'html');
+    assert.strictEqual(key1, key2);
+});
+test('openHtmlTab logic creates correct tab shape', () => {
+    const filePath = '/tmp/gstack-sketch/design-board.html';
+    const tab = {
+        filePath,
+        fileName: filePath.split('/').pop() ?? filePath,
+        isChanged: false,
+        tabType: 'html',
+        token: 'abc123',
+    };
+    assert.strictEqual(tab.fileName, 'design-board.html');
+    assert.strictEqual(tab.isChanged, false);
+    assert.strictEqual(tab.tabType, 'html');
+    assert.strictEqual(tab.token, 'abc123');
+});
+test('refreshHtmlTab logic uses version counter', () => {
+    const baseUrl = '/browser-content/abc123/design-board.html';
+    const refreshVersion = 1;
+    const refreshed = `${baseUrl}?v=${refreshVersion}`;
+    assert.ok(refreshed.includes('?v='));
+    assert.ok(refreshed.startsWith(baseUrl));
+});