relay-ide 0.1.0

package/dist/test/changed-files-api.test.js

@@ -0,0 +1,140 @@
+import { describe, 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 { createWorkspaceRouter } from '../server/workspaces.js';
+import { saveConfig, DEFAULTS } from '../server/config.js';
+let tmpDir;
+let configPath;
+let repoDir;
+let server;
+let baseUrl;
+before(async () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'changed-files-test-'));
+    configPath = path.join(tmpDir, 'config.json');
+    repoDir = path.join(tmpDir, 'repo');
+    fs.mkdirSync(path.join(repoDir, '.git'), { recursive: true });
+    saveConfig(configPath, { ...DEFAULTS, repos: [repoDir] });
+    const app = express();
+    app.use(express.json());
+    const mockExec = async (file, args, _opts) => {
+        if (args[0] === 'status' && args.includes('--porcelain=v1')) {
+            return { stdout: ' M server/git.ts\0?? new-file.ts\0', stderr: '' };
+        }
+        if (args[0] === 'diff' && args.includes('--numstat')) {
+            return { stdout: '10\t2\tserver/git.ts\n', stderr: '' };
+        }
+        if (args[0] === 'diff' && args.includes('--unified=3')) {
+            return { stdout: 'diff output for file', stderr: '' };
+        }
+        if (file === 'wc') {
+            return { stdout: '      20 new-file.ts', stderr: '' };
+        }
+        if (args[0] === 'rev-parse' && args[1] === '--git-dir') {
+            return { stdout: '.git\n', stderr: '' };
+        }
+        if (args[0] === 'symbolic-ref') {
+            return { stdout: 'origin/main\n', stderr: '' };
+        }
+        return { stdout: '', stderr: '' };
+    };
+    app.use('/workspaces', createWorkspaceRouter({ configPath, execAsync: mockExec }));
+    await new Promise((resolve) => {
+        server = app.listen(0, '127.0.0.1', resolve);
+    });
+    const addr = server.address();
+    baseUrl = `http://127.0.0.1:${addr.port}`;
+});
+after(async () => {
+    server?.close();
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+describe('GET /workspaces/changed-files', () => {
+    test('returns changed files for a workspace', async () => {
+        const res = await fetch(`${baseUrl}/workspaces/changed-files?path=${encodeURIComponent(repoDir)}`);
+        assert.equal(res.status, 200);
+        const data = (await res.json());
+        assert.ok(Array.isArray(data.files));
+        assert.ok(data.aggregate);
+        assert.equal(data.aggregate.fileCount, 2);
+    });
+    test('returns 400 without path parameter', async () => {
+        const res = await fetch(`${baseUrl}/workspaces/changed-files`);
+        assert.equal(res.status, 400);
+    });
+});
+describe('GET /workspaces/file-diff', () => {
+    test('returns diff for a specific file', async () => {
+        const res = await fetch(`${baseUrl}/workspaces/file-diff?path=${encodeURIComponent(repoDir)}&file=server/git.ts`);
+        assert.equal(res.status, 200);
+        const data = (await res.json());
+        assert.ok(typeof data.diff === 'string');
+    });
+    test('returns 400 without file parameter', async () => {
+        const res = await fetch(`${baseUrl}/workspaces/file-diff?path=${encodeURIComponent(repoDir)}`);
+        assert.equal(res.status, 400);
+    });
+    test('rejects absolute paths that did not start with ~', async () => {
+        const res = await fetch(`${baseUrl}/workspaces/file-diff?path=${encodeURIComponent(repoDir)}&file=/etc/passwd`);
+        assert.equal(res.status, 400);
+        const data = (await res.json());
+        assert.equal(data.error, 'invalid file path');
+    });
+    test('rejects .. traversal in relative paths', async () => {
+        const res = await fetch(`${baseUrl}/workspaces/file-diff?path=${encodeURIComponent(repoDir)}&file=../../etc/passwd`);
+        assert.equal(res.status, 400);
+        const data = (await res.json());
+        assert.equal(data.error, 'invalid file path');
+    });
+    test('reads ~/file paths directly via fs', async () => {
+        const testFile = path.join(os.homedir(), '.claude-remote-cli-test-tilde');
+        fs.writeFileSync(testFile, 'tilde-test-content', 'utf-8');
+        try {
+            const res = await fetch(`${baseUrl}/workspaces/file-diff?path=${encodeURIComponent(repoDir)}&file=~/.claude-remote-cli-test-tilde`);
+            assert.equal(res.status, 200);
+            const data = (await res.json());
+            assert.equal(data.diff, 'tilde-test-content');
+        }
+        finally {
+            fs.unlinkSync(testFile);
+        }
+    });
+    test('rejects ~/../../ etc traversal attempts', async () => {
+        const res = await fetch(`${baseUrl}/workspaces/file-diff?path=${encodeURIComponent(repoDir)}&file=~/../../etc/passwd`);
+        assert.equal(res.status, 400);
+        const data = (await res.json());
+        assert.equal(data.error, 'invalid file path');
+    });
+    test('returns 404 for non-existent ~/file', async () => {
+        const res = await fetch(`${baseUrl}/workspaces/file-diff?path=${encodeURIComponent(repoDir)}&file=~/.claude-remote-cli-nonexistent-file`);
+        assert.equal(res.status, 404);
+    });
+    test('returns 400 for directory ~/path', async () => {
+        const testDir = path.join(os.homedir(), '.claude-remote-cli-test-dir');
+        fs.mkdirSync(testDir, { recursive: true });
+        try {
+            const res = await fetch(`${baseUrl}/workspaces/file-diff?path=${encodeURIComponent(repoDir)}&file=~/.claude-remote-cli-test-dir`);
+            assert.equal(res.status, 400);
+            const data = (await res.json());
+            assert.equal(data.error, 'not a regular file');
+        }
+        finally {
+            fs.rmdirSync(testDir);
+        }
+    });
+});
+describe('GET /workspaces/default-branch', () => {
+    test('returns default branch for a workspace', async () => {
+        const res = await fetch(`${baseUrl}/workspaces/default-branch?path=${encodeURIComponent(repoDir)}`);
+        assert.equal(res.status, 200);
+        const data = (await res.json());
+        assert.equal(typeof data.branch, 'string');
+        assert.ok(data.branch.length > 0);
+    });
+    test('returns 400 without path parameter', async () => {
+        const res = await fetch(`${baseUrl}/workspaces/default-branch`);
+        assert.equal(res.status, 400);
+    });
+});

package/dist/test/clipboard.test.js

@@ -0,0 +1,12 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { detectClipboardTool, setClipboardImage } from '../server/clipboard.js';
+describe('clipboard', () => {
+    it('detectClipboardTool returns a string or null', () => {
+        const result = detectClipboardTool();
+        assert.ok(result === null || typeof result === 'string');
+    });
+    it('setClipboardImage rejects unsupported mime types', async () => {
+        await assert.rejects(() => setClipboardImage('/tmp/test.txt', 'text/plain'), /Unsupported/);
+    });
+});

package/dist/test/codex-hooks-adapter.test.js

@@ -0,0 +1,237 @@
+import { describe, it, 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 { writeCodexHooksAdapter, CODEX_EVENTS, EVENT_MAP, } from '../server/codex-hooks-adapter.js';
+let tmpConfigDir;
+before(() => {
+    tmpConfigDir = fs.mkdtempSync(path.join(os.tmpdir(), 'crc-codex-hooks-test-'));
+});
+after(() => {
+    fs.rmSync(tmpConfigDir, { recursive: true, force: true });
+});
+describe('CODEX_EVENTS', () => {
+    it('contains all 5 expected codex hook event names', () => {
+        const expected = [
+            'SessionStart',
+            'Stop',
+            'UserPromptSubmit',
+            'PreToolUse',
+            'PostToolUse',
+        ];
+        assert.strictEqual(CODEX_EVENTS.length, 5);
+        for (const ev of expected) {
+            assert.ok(CODEX_EVENTS.includes(ev), `CODEX_EVENTS should include ${ev}`);
+        }
+    });
+});
+describe('EVENT_MAP', () => {
+    it('maps SessionStart to session.started', () => {
+        assert.strictEqual(EVENT_MAP['SessionStart'], 'session.started');
+    });
+    it('maps Stop to session.ended', () => {
+        assert.strictEqual(EVENT_MAP['Stop'], 'session.ended');
+    });
+    it('maps UserPromptSubmit to prompt.submitted', () => {
+        assert.strictEqual(EVENT_MAP['UserPromptSubmit'], 'prompt.submitted');
+    });
+    it('maps PreToolUse to tool.started', () => {
+        assert.strictEqual(EVENT_MAP['PreToolUse'], 'tool.started');
+    });
+    it('maps PostToolUse to tool.finished', () => {
+        assert.strictEqual(EVENT_MAP['PostToolUse'], 'tool.finished');
+    });
+    it('has exactly 5 mappings', () => {
+        assert.strictEqual(Object.keys(EVENT_MAP).length, 5);
+    });
+});
+describe('writeCodexHooksAdapter', () => {
+    it('returns a string path', () => {
+        const result = writeCodexHooksAdapter('sess-001', 3456, 'tok-abc', tmpConfigDir);
+        assert.ok(typeof result === 'string', 'should return a string path');
+    });
+    it('creates the temp directory', () => {
+        const dir = writeCodexHooksAdapter('sess-002', 3456, 'tok-abc', tmpConfigDir);
+        assert.ok(fs.existsSync(dir), 'temp directory should exist');
+    });
+    it('creates relay.sh in the temp directory', () => {
+        const dir = writeCodexHooksAdapter('sess-003', 3456, 'tok-abc', tmpConfigDir);
+        const relayPath = path.join(dir, 'relay.sh');
+        assert.ok(fs.existsSync(relayPath), 'relay.sh should exist');
+    });
+    it('creates relay.sh that is executable', () => {
+        const dir = writeCodexHooksAdapter('sess-004', 3456, 'tok-abc', tmpConfigDir);
+        const relayPath = path.join(dir, 'relay.sh');
+        const stat = fs.statSync(relayPath);
+        // Check owner execute bit (0o100)
+        assert.ok((stat.mode & 0o100) !== 0, 'relay.sh should be executable by owner');
+    });
+    it('creates hooks.json in the temp directory', () => {
+        const dir = writeCodexHooksAdapter('sess-005', 3456, 'tok-abc', tmpConfigDir);
+        const hooksPath = path.join(dir, 'hooks.json');
+        assert.ok(fs.existsSync(hooksPath), 'hooks.json should exist');
+    });
+    it('hooks.json contains all 5 codex events', () => {
+        const dir = writeCodexHooksAdapter('sess-006', 3456, 'tok-abc', tmpConfigDir);
+        const hooksPath = path.join(dir, 'hooks.json');
+        const hooks = JSON.parse(fs.readFileSync(hooksPath, 'utf-8'));
+        const expected = [
+            'SessionStart',
+            'Stop',
+            'UserPromptSubmit',
+            'PreToolUse',
+            'PostToolUse',
+        ];
+        for (const ev of expected) {
+            assert.ok(ev in hooks, `hooks.json should have key ${ev}`);
+        }
+    });
+    it('hooks.json entries are arrays of { type: "command", command: <path-to-relay.sh> }', () => {
+        const dir = writeCodexHooksAdapter('sess-007', 3456, 'tok-abc', tmpConfigDir);
+        const hooksPath = path.join(dir, 'hooks.json');
+        const relayPath = path.join(dir, 'relay.sh');
+        const hooks = JSON.parse(fs.readFileSync(hooksPath, 'utf-8'));
+        const expected = [
+            'SessionStart',
+            'Stop',
+            'UserPromptSubmit',
+            'PreToolUse',
+            'PostToolUse',
+        ];
+        for (const ev of expected) {
+            const entries = hooks[ev];
+            assert.ok(Array.isArray(entries), `${ev} should be an array`);
+            assert.ok(entries.length >= 1, `${ev} should have at least one entry`);
+            const last = entries[entries.length - 1];
+            assert.strictEqual(last.type, 'command', `${ev} entry should have type: "command"`);
+            assert.strictEqual(last.command, relayPath, `${ev} entry command should point to relay.sh`);
+        }
+    });
+    it('session.json contains the correct port, sessionId, and hookToken', () => {
+        const dir = writeCodexHooksAdapter('sess-008', 9999, 'super-secret-token', tmpConfigDir);
+        const configPath = path.join(dir, 'session.json');
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        assert.strictEqual(config.port, 9999, 'session.json should contain the correct port');
+        assert.strictEqual(config.sessionId, 'sess-008', 'session.json should contain the correct sessionId');
+        assert.strictEqual(config.hookToken, 'super-secret-token', 'session.json should contain the correct hookToken');
+    });
+    it('relay.sh reads config from session.json', () => {
+        const dir = writeCodexHooksAdapter('my-unique-session-id', 3456, 'tok-abc', tmpConfigDir);
+        const relayPath = path.join(dir, 'relay.sh');
+        const content = fs.readFileSync(relayPath, 'utf-8');
+        assert.ok(content.includes('session.json'), 'relay.sh should reference session.json config file');
+        assert.ok(content.includes('CONFIG_FILE='), 'relay.sh should set CONFIG_FILE variable');
+    });
+    it('relay.sh posts to /hooks/agent-event', () => {
+        const dir = writeCodexHooksAdapter('sess-011', 3456, 'tok-abc', tmpConfigDir);
+        const relayPath = path.join(dir, 'relay.sh');
+        const content = fs.readFileSync(relayPath, 'utf-8');
+        assert.ok(content.includes('/hooks/agent-event'), 'relay.sh should POST to /hooks/agent-event');
+    });
+    it('relay.sh uses best-effort delivery (|| true)', () => {
+        const dir = writeCodexHooksAdapter('sess-012', 3456, 'tok-abc', tmpConfigDir);
+        const relayPath = path.join(dir, 'relay.sh');
+        const content = fs.readFileSync(relayPath, 'utf-8');
+        assert.ok(content.includes('|| true'), 'relay.sh should use || true for best-effort delivery');
+    });
+    it('relay.sh maps SessionStart to session.started in the case statement', () => {
+        const dir = writeCodexHooksAdapter('sess-013', 3456, 'tok-abc', tmpConfigDir);
+        const relayPath = path.join(dir, 'relay.sh');
+        const content = fs.readFileSync(relayPath, 'utf-8');
+        assert.ok(content.includes('SessionStart'), 'relay.sh should contain SessionStart case');
+        assert.ok(content.includes('session.started'), 'relay.sh should map to session.started');
+    });
+    it('relay.sh maps Stop to session.ended in the case statement', () => {
+        const dir = writeCodexHooksAdapter('sess-014', 3456, 'tok-abc', tmpConfigDir);
+        const relayPath = path.join(dir, 'relay.sh');
+        const content = fs.readFileSync(relayPath, 'utf-8');
+        assert.ok(content.includes('Stop'), 'relay.sh should contain Stop case');
+        assert.ok(content.includes('session.ended'), 'relay.sh should map to session.ended');
+    });
+    it('relay.sh maps UserPromptSubmit to prompt.submitted in the case statement', () => {
+        const dir = writeCodexHooksAdapter('sess-015', 3456, 'tok-abc', tmpConfigDir);
+        const relayPath = path.join(dir, 'relay.sh');
+        const content = fs.readFileSync(relayPath, 'utf-8');
+        assert.ok(content.includes('UserPromptSubmit'), 'relay.sh should contain UserPromptSubmit case');
+        assert.ok(content.includes('prompt.submitted'), 'relay.sh should map to prompt.submitted');
+    });
+    it('relay.sh maps PreToolUse to tool.started in the case statement', () => {
+        const dir = writeCodexHooksAdapter('sess-016', 3456, 'tok-abc', tmpConfigDir);
+        const relayPath = path.join(dir, 'relay.sh');
+        const content = fs.readFileSync(relayPath, 'utf-8');
+        assert.ok(content.includes('PreToolUse'), 'relay.sh should contain PreToolUse case');
+        assert.ok(content.includes('tool.started'), 'relay.sh should map to tool.started');
+    });
+    it('relay.sh maps PostToolUse to tool.finished in the case statement', () => {
+        const dir = writeCodexHooksAdapter('sess-017', 3456, 'tok-abc', tmpConfigDir);
+        const relayPath = path.join(dir, 'relay.sh');
+        const content = fs.readFileSync(relayPath, 'utf-8');
+        assert.ok(content.includes('PostToolUse'), 'relay.sh should contain PostToolUse case');
+        assert.ok(content.includes('tool.finished'), 'relay.sh should map to tool.finished');
+    });
+    it('relay.sh has a shebang line', () => {
+        const dir = writeCodexHooksAdapter('sess-018', 3456, 'tok-abc', tmpConfigDir);
+        const relayPath = path.join(dir, 'relay.sh');
+        const content = fs.readFileSync(relayPath, 'utf-8');
+        assert.ok(content.startsWith('#!/usr/bin/env bash'), 'relay.sh should start with #!/usr/bin/env bash');
+    });
+    it('temp directory path includes the sessionId', () => {
+        const sessionId = 'uniqueid-xyz-789';
+        const dir = writeCodexHooksAdapter(sessionId, 3456, 'tok-abc', tmpConfigDir);
+        assert.ok(dir.includes(sessionId), 'temp dir path should include the sessionId');
+    });
+    it('is idempotent — calling twice for same sessionId returns consistent results', () => {
+        const sessionId = 'idempotent-sess';
+        const dir1 = writeCodexHooksAdapter(sessionId, 3456, 'tok-abc', tmpConfigDir);
+        const dir2 = writeCodexHooksAdapter(sessionId, 3456, 'tok-abc', tmpConfigDir);
+        assert.strictEqual(dir1, dir2, 'should return same path for same sessionId');
+        assert.ok(fs.existsSync(path.join(dir2, 'relay.sh')), 'relay.sh should still exist after second call');
+        assert.ok(fs.existsSync(path.join(dir2, 'hooks.json')), 'hooks.json should still exist after second call');
+    });
+    it('merges with existing user hooks when ~/.codex/hooks.json has entries', () => {
+        // Create a fake user hooks directory
+        const fakeHomeDir = fs.mkdtempSync(path.join(os.tmpdir(), 'crc-fake-home-'));
+        try {
+            const codexDir = path.join(fakeHomeDir, '.codex');
+            fs.mkdirSync(codexDir, { recursive: true });
+            const existingHooks = {
+                SessionStart: [
+                    { type: 'command', command: '/usr/local/bin/my-existing-hook.sh' },
+                ],
+            };
+            fs.writeFileSync(path.join(codexDir, 'hooks.json'), JSON.stringify(existingHooks));
+            // We can't easily mock os.homedir(), so we test the merge logic indirectly:
+            // If no ~/.codex/hooks.json exists (default), each event has exactly 1 entry (our relay).
+            // This test verifies the base case: no existing hooks → exactly 1 relay per event.
+            const dir = writeCodexHooksAdapter('sess-merge', 3456, 'tok-abc', tmpConfigDir);
+            const hooks = JSON.parse(fs.readFileSync(path.join(dir, 'hooks.json'), 'utf-8'));
+            const expected = [
+                'SessionStart',
+                'Stop',
+                'UserPromptSubmit',
+                'PreToolUse',
+                'PostToolUse',
+            ];
+            for (const ev of expected) {
+                assert.ok(Array.isArray(hooks[ev]), `${ev} should be an array`);
+                assert.ok(hooks[ev].length >= 1, `${ev} should have at least one hook entry`);
+            }
+        }
+        finally {
+            fs.rmSync(fakeHomeDir, { recursive: true, force: true });
+        }
+    });
+    it('reads stdin via INPUT=$(cat) in relay.sh', () => {
+        const dir = writeCodexHooksAdapter('sess-019', 3456, 'tok-abc', tmpConfigDir);
+        const relayPath = path.join(dir, 'relay.sh');
+        const content = fs.readFileSync(relayPath, 'utf-8');
+        assert.ok(content.includes('INPUT=$(cat)'), 'relay.sh should read stdin via INPUT=$(cat)');
+    });
+    it('relay.sh reads HOOK_EVENT_NAME env var', () => {
+        const dir = writeCodexHooksAdapter('sess-020', 3456, 'tok-abc', tmpConfigDir);
+        const relayPath = path.join(dir, 'relay.sh');
+        const content = fs.readFileSync(relayPath, 'utf-8');
+        assert.ok(content.includes('HOOK_EVENT_NAME'), 'relay.sh should use HOOK_EVENT_NAME env var');
+    });
+});

package/dist/test/components/EmptyState.spec.js

@@ -0,0 +1,51 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+describe('EmptyState', () => {
+    const projectRoot = join(__dirname, '../../..');
+    const componentPath = join(projectRoot, 'frontend/src/components/EmptyState.tsx');
+    const cssPath = join(projectRoot, 'frontend/src/components/EmptyState.css');
+    it('EmptyState.tsx file exists', () => {
+        assert.ok(existsSync(componentPath), 'EmptyState.tsx should exist');
+    });
+    it('EmptyState.css file exists', () => {
+        assert.ok(existsSync(cssPath), 'EmptyState.css should exist');
+    });
+    it('exports EmptyState component', () => {
+        const content = readFileSync(componentPath, 'utf-8');
+        assert.ok(content.includes('export function EmptyState'), 'Should export EmptyState function');
+        assert.ok(content.includes('export default EmptyState'), 'Should have default export');
+    });
+    it('exports EmptyStateProps interface', () => {
+        const content = readFileSync(componentPath, 'utf-8');
+        assert.ok(content.includes('interface EmptyStateProps'), 'Should define EmptyStateProps interface');
+    });
+    it('has required props', () => {
+        const content = readFileSync(componentPath, 'utf-8');
+        assert.ok(content.includes('heading: string'), 'Should have heading prop');
+        assert.ok(content.includes('icon?:'), 'Should have optional icon prop');
+        assert.ok(content.includes('description?:'), 'Should have optional description prop');
+        assert.ok(content.includes('actionLabel?:'), 'Should have optional actionLabel prop');
+        assert.ok(content.includes('onAction?:'), 'Should have optional onAction prop');
+    });
+    it('imports TuiButton', () => {
+        const content = readFileSync(componentPath, 'utf-8');
+        assert.ok(content.includes("from './TuiButton'"), 'Should import TuiButton');
+    });
+    it('imports CSS', () => {
+        const content = readFileSync(componentPath, 'utf-8');
+        assert.ok(content.includes("import './EmptyState.css'"), 'Should import EmptyState.css');
+    });
+    it('CSS has required classes', () => {
+        const content = readFileSync(cssPath, 'utf-8');
+        assert.ok(content.includes('.empty-state'), 'Should have .empty-state class');
+        assert.ok(content.includes('.empty-icon'), 'Should have .empty-icon class');
+        assert.ok(content.includes('.empty-heading'), 'Should have .empty-heading class');
+        assert.ok(content.includes('.empty-description'), 'Should have .empty-description class');
+    });
+});

package/dist/test/components/ErrorToast.spec.js

@@ -0,0 +1,65 @@
+import { describe, it, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+describe('toasts.store', () => {
+    let useToastStore;
+    let showToast;
+    let dismissToast;
+    let getToasts;
+    beforeEach(async () => {
+        const store = await import('../../frontend/src/lib/state/toasts.store.js');
+        useToastStore = store.useToastStore;
+        showToast = store.showToast;
+        dismissToast = store.dismissToast;
+        getToasts = store.getToasts;
+        useToastStore.setState({ toasts: [] });
+    });
+    it('initializes with empty toasts', () => {
+        const state = useToastStore.getState();
+        assert.deepStrictEqual(state.toasts, []);
+    });
+    it('showToast adds a toast to the store', () => {
+        showToast('Test message', 'error');
+        const state = useToastStore.getState();
+        assert.strictEqual(state.toasts.length, 1);
+        assert.strictEqual(state.toasts[0]?.message, 'Test message');
+        assert.strictEqual(state.toasts[0]?.variant, 'error');
+    });
+    it('showToast uses default variant', () => {
+        showToast('Default test');
+        const state = useToastStore.getState();
+        assert.strictEqual(state.toasts[0]?.variant, 'error');
+    });
+    it('showToast supports info variant', () => {
+        showToast('Info message', 'info');
+        const state = useToastStore.getState();
+        assert.strictEqual(state.toasts[0]?.variant, 'info');
+    });
+    it('dismissToast removes a toast by id', () => {
+        showToast('First', 'error');
+        showToast('Second', 'info');
+        let state = useToastStore.getState();
+        assert.strictEqual(state.toasts.length, 2);
+        const firstId = state.toasts[0]?.id;
+        if (firstId !== undefined) {
+            dismissToast(firstId);
+        }
+        state = useToastStore.getState();
+        assert.strictEqual(state.toasts.length, 1);
+        assert.strictEqual(state.toasts[0]?.message, 'Second');
+    });
+    it('getToasts returns current toasts array', () => {
+        showToast('Toast 1');
+        showToast('Toast 2');
+        const toasts = getToasts();
+        assert.strictEqual(toasts.length, 2);
+    });
+    it('toast ids are unique', () => {
+        showToast('First');
+        showToast('Second');
+        showToast('Third');
+        const state = useToastStore.getState();
+        const ids = state.toasts.map((t) => t.id);
+        const uniqueIds = new Set(ids);
+        assert.strictEqual(uniqueIds.size, ids.length, 'All toast IDs should be unique');
+    });
+});

package/dist/test/components/TuiCheckbox.spec.js

@@ -0,0 +1,120 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+// Note: Full DOM testing would require a test runner with JSX support (e.g., Vitest + React Testing Library)
+describe('TuiCheckbox', () => {
+    describe('Props Interface', () => {
+        it('should have required checked prop', () => {
+            const validProps = { checked: true };
+            assert.strictEqual(validProps.checked, true);
+        });
+        it('should have optional disabled prop with default false', () => {
+            const propsWithDisabled = { checked: false, disabled: true };
+            assert.strictEqual(propsWithDisabled.disabled, true);
+            const propsWithoutDisabled = { checked: false };
+            assert.strictEqual(propsWithoutDisabled.disabled, undefined);
+        });
+        it('should have optional onChange callback', () => {
+            let calledWith;
+            const handleChange = (checked) => {
+                calledWith = checked;
+            };
+            const props = { checked: false, onChange: handleChange };
+            assert.strictEqual(typeof props.onChange, 'function');
+            props.onChange?.(true);
+            assert.strictEqual(calledWith, true);
+        });
+        it('should support children prop', () => {
+            const props = {
+                checked: false,
+                children: 'Label text'
+            };
+            assert.strictEqual(props.children, 'Label text');
+        });
+        it('should support className prop', () => {
+            const props = {
+                checked: false,
+                className: 'custom-class'
+            };
+            assert.strictEqual(props.className, 'custom-class');
+        });
+        it('should support rest props spread', () => {
+            const props = {
+                checked: false,
+                'data-testid': 'test-checkbox',
+                'aria-label': 'Test checkbox'
+            };
+            assert.strictEqual(props['data-testid'], 'test-checkbox');
+            assert.strictEqual(props['aria-label'], 'Test checkbox');
+        });
+    });
+    describe('Component Logic', () => {
+        it('should display [x] when checked', () => {
+            const checked = true;
+            const displayText = checked ? '[x]' : '[ ]';
+            assert.strictEqual(displayText, '[x]');
+        });
+        it('should display [ ] when unchecked', () => {
+            const checked = false;
+            const displayText = checked ? '[x]' : '[ ]';
+            assert.strictEqual(displayText, '[ ]');
+        });
+        it('should apply disabled class when disabled', () => {
+            const disabled = true;
+            const classes = ['tui-checkbox', disabled && 'disabled'].filter(Boolean).join(' ');
+            assert.strictEqual(classes, 'tui-checkbox disabled');
+        });
+        it('should not apply disabled class when not disabled', () => {
+            const disabled = false;
+            const classes = ['tui-checkbox', disabled && 'disabled'].filter(Boolean).join(' ');
+            assert.strictEqual(classes, 'tui-checkbox');
+        });
+        it('should combine custom className with base classes', () => {
+            const className = 'custom-class';
+            const disabled = false;
+            const classes = ['tui-checkbox', disabled && 'disabled', className]
+                .filter(Boolean)
+                .join(' ');
+            assert.strictEqual(classes, 'tui-checkbox custom-class');
+        });
+        it('should not call onChange when disabled', () => {
+            const disabled = true;
+            let called = false;
+            const onChange = (checked) => {
+                called = true;
+            };
+            const handleChange = (e) => {
+                if (!disabled && onChange) {
+                    onChange(e.target.checked);
+                }
+            };
+            handleChange({ target: { checked: true } });
+            assert.strictEqual(called, false);
+        });
+        it('should call onChange when not disabled', () => {
+            const disabled = false;
+            let calledWith;
+            const onChange = (checked) => {
+                calledWith = checked;
+            };
+            const handleChange = (e) => {
+                if (!disabled && onChange) {
+                    onChange(e.target.checked);
+                }
+            };
+            handleChange({ target: { checked: true } });
+            assert.strictEqual(calledWith, true);
+        });
+    });
+    describe('CSS Classes', () => {
+        it('should have correct base class', () => {
+            const expectedClasses = {
+                container: 'tui-checkbox',
+                check: 'tui-check',
+                disabled: 'disabled'
+            };
+            assert.strictEqual(expectedClasses.container, 'tui-checkbox');
+            assert.strictEqual(expectedClasses.check, 'tui-check');
+            assert.strictEqual(expectedClasses.disabled, 'disabled');
+        });
+    });
+});