@mseep/anything-analyzer 3.6.50

package/tests/main/ai/prompt-builder.test.ts

@@ -0,0 +1,178 @@
+import { describe, it, expect } from "vitest";
+import { PromptBuilder } from "../../../src/main/ai/prompt-builder";
+import type { AssembledData } from "../../../src/shared/types";
+
+// Minimal fixture to satisfy PromptBuilder
+function createMinimalData(): AssembledData {
+  return {
+    requests: [
+      {
+        seq: 1,
+        method: "GET",
+        url: "https://example.com/api/test",
+        headers: { "content-type": "application/json" },
+        body: null,
+        status: 200,
+        responseHeaders: null,
+        responseBody: '{"ok":true}',
+        hooks: [],
+      },
+    ],
+    storageDiff: {
+      cookies: { added: {}, changed: {}, removed: [] },
+      localStorage: { added: {}, changed: {}, removed: [] },
+      sessionStorage: { added: {}, changed: {}, removed: [] },
+    },
+    estimatedTokens: 100,
+    sceneHints: [],
+    streamingRequests: [],
+    authChain: [],
+    cryptoScripts: [],
+  };
+}
+
+describe("PromptBuilder", () => {
+  const builder = new PromptBuilder();
+  const data = createMinimalData();
+  const minimalData = data;
+  const platform = "example.com";
+
+  describe("purpose=undefined (default)", () => {
+    it("should include default 8 analysis requirements", () => {
+      const { user } = builder.build(data, platform);
+      expect(user).toContain("场景识别");
+      expect(user).toContain("交互流程概述");
+      expect(user).toContain("API端点清单");
+      expect(user).toContain("鉴权机制分析");
+      expect(user).toContain("流式通信分析");
+      expect(user).toContain("存储使用分析");
+      expect(user).toContain("关键依赖关系");
+      expect(user).toContain("复现建议");
+    });
+  });
+
+  describe('purpose="auto"', () => {
+    it("should produce identical output to undefined", () => {
+      const defaultResult = builder.build(data, platform);
+      const autoResult = builder.build(data, platform, "auto");
+      expect(autoResult.system).toBe(defaultResult.system);
+      expect(autoResult.user).toBe(defaultResult.user);
+    });
+  });
+
+  describe('purpose="" (empty string)', () => {
+    it("should produce identical output to undefined", () => {
+      const defaultResult = builder.build(data, platform);
+      const emptyResult = builder.build(data, platform, "");
+      expect(emptyResult.system).toBe(defaultResult.system);
+      expect(emptyResult.user).toBe(defaultResult.user);
+    });
+  });
+
+  describe('purpose="reverse-api"', () => {
+    it("should replace analysis requirements with reverse-api specific ones", () => {
+      const { user } = builder.build(data, platform, "reverse-api");
+      expect(user).toContain("完整 API 端点清单");
+      expect(user).toContain("鉴权流程");
+      expect(user).toContain("请求依赖链");
+      expect(user).toContain("数据模型推断");
+      expect(user).toContain("复现代码");
+      // Should NOT contain default requirements
+      expect(user).not.toContain("场景识别：判断用户执行了什么操作");
+    });
+  });
+
+  describe('purpose="security-audit"', () => {
+    it("should replace analysis requirements with security-specific ones", () => {
+      const { user } = builder.build(data, platform, "security-audit");
+      expect(user).toContain("认证安全");
+      expect(user).toContain("敏感数据暴露");
+      expect(user).toContain("CSRF/XSS 风险");
+      expect(user).toContain("权限控制");
+      expect(user).toContain("安全建议");
+      expect(user).not.toContain("场景识别：判断用户执行了什么操作");
+    });
+  });
+
+  describe('purpose="performance"', () => {
+    it("should replace analysis requirements with performance-specific ones", () => {
+      const { user } = builder.build(data, platform, "performance");
+      expect(user).toContain("请求时序分析");
+      expect(user).toContain("冗余请求");
+      expect(user).toContain("资源优化");
+      expect(user).toContain("缓存策略");
+      expect(user).toContain("性能建议");
+      expect(user).not.toContain("场景识别：判断用户执行了什么操作");
+    });
+  });
+
+  describe("purpose=custom text", () => {
+    it("should prepend custom purpose and keep default requirements as baseline", () => {
+      const customText = "分析用户注册流程中的所有加密操作";
+      const { user } = builder.build(data, platform, customText);
+      expect(user).toContain(
+        "用户指定的分析重点：分析用户注册流程中的所有加密操作",
+      );
+      expect(user).toContain("在完成上述重点分析的同时，也请覆盖以下基础分析");
+      // Default requirements should still be present
+      expect(user).toContain("场景识别");
+    });
+
+    it("should not alter the system prompt for custom text", () => {
+      const defaultResult = builder.build(data, platform);
+      const customResult = builder.build(data, platform, "自定义分析");
+      expect(customResult.system).toBe(defaultResult.system);
+    });
+  });
+
+  it('should return CRYPTO_REVERSE_REQUIREMENTS for crypto-reverse purpose', () => {
+    const result = builder.build(minimalData, 'TestPlatform', 'crypto-reverse')
+    expect(result.user).toContain('加密算法识别')
+    expect(result.user).toContain('加密流程还原')
+    expect(result.user).toContain('密钥管理分析')
+    expect(result.user).toContain('Python')
+  })
+
+  it('should include crypto hooks section in prompt', () => {
+    const dataWithCryptoHooks: AssembledData = {
+      ...minimalData,
+      requests: [{
+        seq: 1, method: 'POST', url: 'https://example.com/api/login',
+        headers: {}, body: null, status: 200,
+        responseHeaders: null, responseBody: null,
+        hooks: [{
+          id: 1, session_id: 's1', timestamp: Date.now(),
+          hook_type: 'crypto_lib', function_name: 'CryptoJS.AES.encrypt',
+          arguments: '["data","key"]', result: '"U2FsdGVkX1..."',
+          call_stack: 'at encrypt (https://example.com/js/api.js:42:10)', related_request_id: null
+        }]
+      }],
+    }
+    const result = builder.build(dataWithCryptoHooks, 'TestPlatform')
+    expect(result.user).toContain('加密操作记录')
+    expect(result.user).toContain('CryptoJS.AES.encrypt')
+  })
+
+  it('should include crypto script snippets in prompt', () => {
+    const dataWithSnippets: AssembledData = {
+      ...minimalData,
+      cryptoScripts: [{
+        scriptUrl: 'https://example.com/js/crypto.js',
+        lineRange: [10, 40] as [number, number],
+        content: 'function encrypt(data) { return CryptoJS.AES.encrypt(data, key); }',
+        matchedPatterns: ['CryptoJS'],
+        tier: 1,
+      }],
+    }
+    const result = builder.build(dataWithSnippets, 'TestPlatform')
+    expect(result.user).toContain('相关加密代码片段')
+    expect(result.user).toContain('crypto.js')
+    expect(result.user).toContain('CryptoJS.AES.encrypt')
+  })
+
+  it('should show empty placeholders when no crypto data', () => {
+    const result = builder.build(minimalData, 'TestPlatform')
+    expect(result.user).toContain('(无加密操作记录)')
+    expect(result.user).toContain('(无相关加密代码)')
+  })
+});

package/tests/main/ai/scene-detector.test.ts

@@ -0,0 +1,212 @@
+import { describe, it, expect } from 'vitest'
+import { SceneDetector } from '../../../src/main/ai/scene-detector'
+import type { FilteredRequest } from '../../../src/shared/types'
+
+function makeRequest(overrides: Partial<FilteredRequest> = {}): FilteredRequest {
+  return {
+    seq: 1,
+    method: 'GET',
+    url: 'https://example.com/api/data',
+    headers: {},
+    body: null,
+    status: 200,
+    responseHeaders: null,
+    responseBody: null,
+    hooks: [],
+    ...overrides,
+  }
+}
+
+describe('SceneDetector', () => {
+  const detector = new SceneDetector()
+
+  // 辅助函数：创建 FilteredRequest
+  function createRequest(seq: number, method: string, url: string, body?: string, responseBody?: string, headers?: Record<string, string>, responseHeaders?: Record<string, string>): FilteredRequest {
+    return {
+      seq,
+      method,
+      url,
+      headers: headers || {},
+      body: body || null,
+      status: 200,
+      responseHeaders: responseHeaders || {},
+      responseBody: responseBody || null,
+      hooks: []
+    }
+  }
+
+  it('应检测 AI Chat 场景 - SSE 响应', () => {
+    const requests: FilteredRequest[] = [
+      createRequest(1, 'POST', 'https://api.openai.com/v1/chat/completions', '{"messages":[]}', 'data: {"delta":{"content":"hello"}}', {}, { 'content-type': 'text/event-stream' })
+    ]
+
+    const hints = detector.detect(requests)
+    const aiChatHint = hints.find(h => h.scene === 'ai-chat' && h.confidence === 'high')
+    expect(aiChatHint).toBeDefined()
+    expect(aiChatHint?.evidence).toContain('SSE')
+  })
+
+  it('应检测 AI Chat 场景 - API 路径特征', () => {
+    const requests: FilteredRequest[] = [
+      createRequest(1, 'POST', 'https://api.openai.com/v1/chat/completions', '{"messages":[]}', '{"choices":[]}')
+    ]
+
+    const hints = detector.detect(requests)
+    const aiChatHint = hints.find(h => h.scene === 'ai-chat' && h.confidence === 'high' && h.evidence.includes('API'))
+    expect(aiChatHint).toBeDefined()
+  })
+
+  it('应检测 AI Chat 场景 - 请求体特征（中等置信度）', () => {
+    const requests: FilteredRequest[] = [
+      createRequest(1, 'POST', 'https://api.example.com/chat', '{"messages":[{"role":"user","content":"hello"}],"model":"gpt-4","temperature":0.7}', '{"response":"..."}')
+    ]
+
+    const hints = detector.detect(requests)
+    const aiChatHint = hints.find(h => h.scene === 'ai-chat' && h.confidence === 'medium')
+    expect(aiChatHint).toBeDefined()
+    expect(aiChatHint?.evidence).toContain('AI 典型字段')
+  })
+
+  it('应检测 OAuth 场景', () => {
+    const requests: FilteredRequest[] = [
+      createRequest(1, 'GET', 'https://auth.example.com/oauth/authorize?redirect_uri=http://localhost:3000', '', '')
+    ]
+
+    const hints = detector.detect(requests)
+    const oauthHint = hints.find(h => h.scene === 'auth-oauth')
+    expect(oauthHint).toBeDefined()
+    expect(oauthHint?.confidence).toBe('high')
+  })
+
+  it('应检测 Token 鉴权场景 - 响应中的 access_token', () => {
+    const requests: FilteredRequest[] = [
+      createRequest(1, 'POST', 'https://api.example.com/login', '{"username":"user"}', '{"access_token":"abc123","token_type":"Bearer"}')
+    ]
+
+    const hints = detector.detect(requests)
+    const tokenHint = hints.find(h => h.scene === 'auth-token')
+    expect(tokenHint).toBeDefined()
+    expect(tokenHint?.confidence).toBe('high')
+  })
+
+  it('应检测 Token 鉴权场景 - Authorization Bearer Header', () => {
+    const requests: FilteredRequest[] = [
+      createRequest(1, 'GET', 'https://api.example.com/user', '', '', { 'Authorization': 'Bearer eyJhbGc...' }, {})
+    ]
+
+    const hints = detector.detect(requests)
+    const tokenHint = hints.find(h => h.scene === 'auth-token')
+    expect(tokenHint).toBeDefined()
+  })
+
+  it('应检测注册场景', () => {
+    const requests: FilteredRequest[] = [
+      createRequest(1, 'POST', 'https://api.example.com/register', '{"email":"user@example.com","password":"123456"}', '{"user_id":"123"}')
+    ]
+
+    const hints = detector.detect(requests)
+    const regHint = hints.find(h => h.scene === 'registration')
+    expect(regHint).toBeDefined()
+    expect(regHint?.confidence).toBe('high')
+  })
+
+  it('应检测登录场景', () => {
+    const requests: FilteredRequest[] = [
+      createRequest(1, 'POST', 'https://api.example.com/login', '{"username":"user","password":"123456"}', '{"token":"abc123"}')
+    ]
+
+    const hints = detector.detect(requests)
+    const loginHint = hints.find(h => h.scene === 'login')
+    expect(loginHint).toBeDefined()
+    expect(loginHint?.confidence).toBe('high')
+  })
+
+  it('应检测 WebSocket 场景', () => {
+    const requests: FilteredRequest[] = [
+      createRequest(1, 'GET', 'ws://api.example.com/socket', '', '', { 'Upgrade': 'websocket', 'Connection': 'Upgrade' }, {})
+    ]
+
+    const hints = detector.detect(requests)
+    const wsHint = hints.find(h => h.scene === 'websocket')
+    expect(wsHint).toBeDefined()
+    expect(wsHint?.confidence).toBe('high')
+  })
+
+  it('应检测 SSE 流场景', () => {
+    const requests: FilteredRequest[] = [
+      createRequest(1, 'GET', 'https://api.example.com/stream', '', 'data: {"event":"message"}', {}, { 'content-type': 'text/event-stream' })
+    ]
+
+    const hints = detector.detect(requests)
+    const sseHint = hints.find(h => h.scene === 'sse-stream')
+    expect(sseHint).toBeDefined()
+    expect(sseHint?.confidence).toBe('high')
+  })
+
+  it('应检测通用 JSON API 场景（低置信度）', () => {
+    const requests: FilteredRequest[] = [
+      createRequest(1, 'GET', 'https://api.example.com/data', '', '{"id":1,"name":"test"}', {}, { 'content-type': 'application/json' })
+    ]
+
+    const hints = detector.detect(requests)
+    const apiHint = hints.find(h => h.scene === 'api-general')
+    expect(apiHint).toBeDefined()
+    expect(apiHint?.confidence).toBe('low')
+  })
+
+  it('应处理空请求列表', () => {
+    const requests: FilteredRequest[] = []
+    const hints = detector.detect(requests)
+    expect(hints).toEqual([])
+  })
+
+  it('应支持多个场景同时检测', () => {
+    const requests: FilteredRequest[] = [
+      createRequest(1, 'POST', 'https://api.example.com/login', '{"username":"user","password":"123"}', '{"access_token":"abc123"}', {}, {}),
+      createRequest(2, 'POST', 'https://api.example.com/v1/chat/completions', '{"messages":[{"role":"user","content":"hello"}]}', 'data: {"choices":[]}', { 'Authorization': 'Bearer abc123' }, { 'content-type': 'text/event-stream' })
+    ]
+
+    const hints = detector.detect(requests)
+    expect(hints.some(h => h.scene === 'login')).toBe(true)
+    expect(hints.some(h => h.scene === 'ai-chat')).toBe(true)
+    expect(hints.some(h => h.scene === 'auth-token')).toBe(true)
+  })
+
+  it('should detect crypto-encryption scene from crypto hooks', () => {
+    const req = makeRequest({
+      hooks: [{
+        id: 1, session_id: 's1', timestamp: Date.now(),
+        hook_type: 'crypto', function_name: 'crypto.subtle.encrypt',
+        arguments: '[]', result: null, call_stack: null, related_request_id: null,
+      }],
+    })
+    const hints = detector.detect([req])
+    expect(hints.some(h => h.scene === 'crypto-encryption')).toBe(true)
+  })
+
+  it('should detect crypto-encryption scene from crypto_lib hooks', () => {
+    const req = makeRequest({
+      hooks: [{
+        id: 1, session_id: 's1', timestamp: Date.now(),
+        hook_type: 'crypto_lib', function_name: 'CryptoJS.AES.encrypt',
+        arguments: '[]', result: null, call_stack: null, related_request_id: null,
+      }],
+    })
+    const hints = detector.detect([req])
+    expect(hints.some(h => h.scene === 'crypto-encryption' && h.confidence === 'high')).toBe(true)
+  })
+
+  it('should detect crypto-encryption from signature headers', () => {
+    const req = makeRequest({
+      headers: { 'x-signature': 'abc123', 'content-type': 'application/json' },
+    })
+    const hints = detector.detect([req])
+    expect(hints.some(h => h.scene === 'crypto-encryption' && h.confidence === 'medium')).toBe(true)
+  })
+
+  it('should not detect crypto-encryption without crypto indicators', () => {
+    const req = makeRequest()
+    const hints = detector.detect([req])
+    expect(hints.some(h => h.scene === 'crypto-encryption')).toBe(false)
+  })
+})

package/tests/main/db/migrations.test.ts

@@ -0,0 +1,134 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import {
+  runMigrations,
+  migrateAddStreamingAndWebSocketFlags,
+} from "../../../src/main/db/migrations";
+import path from "path";
+import fs from "fs";
+import os from "os";
+import { createRequire } from "module";
+
+type BetterSqlite3Module = typeof import("better-sqlite3");
+type BetterSqlite3Database = import("better-sqlite3").Database;
+
+const require = createRequire(import.meta.url);
+
+let Database: BetterSqlite3Module | null = null;
+let sqliteLoadError: Error | null = null;
+
+try {
+  Database = require("better-sqlite3") as BetterSqlite3Module;
+  const probe = new Database(":memory:");
+  probe.close();
+} catch (error) {
+  sqliteLoadError = error as Error;
+  Database = null;
+}
+
+const describeDatabaseMigrations = sqliteLoadError ? describe.skip : describe;
+
+describeDatabaseMigrations("Database Migrations", () => {
+  let db: BetterSqlite3Database | null = null;
+  let dbPath: string;
+
+  beforeEach(() => {
+    // Create a temporary database file for testing
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "test-db-"));
+    dbPath = path.join(tmpDir, "test.db");
+    db = new Database!(dbPath);
+
+    // Run initial migrations to set up schema
+    runMigrations(db);
+  });
+
+  afterEach(() => {
+    // Clean up
+    db?.close();
+    if (fs.existsSync(dbPath)) {
+      fs.unlinkSync(dbPath);
+    }
+    const tmpDir = path.dirname(dbPath);
+    if (fs.existsSync(tmpDir)) {
+      fs.rmdirSync(tmpDir);
+    }
+  });
+
+  it("应该成功添加 is_streaming 和 is_websocket 列到 requests 表", () => {
+    // Check that columns exist after migration
+    const tableInfo = db!.prepare("PRAGMA table_info(requests)").all() as any[];
+    const columnNames = tableInfo.map((col: any) => col.name);
+
+    expect(columnNames).toContain("is_streaming");
+    expect(columnNames).toContain("is_websocket");
+  });
+
+  it("应该可以重复执行迁移而不抛出错误（幂等性）", () => {
+    // First execution (already done in beforeEach via runMigrations)
+    // Second execution should not throw
+    expect(() => {
+      migrateAddStreamingAndWebSocketFlags(db!);
+    }).not.toThrow();
+
+    // Third execution to ensure idempotency
+    expect(() => {
+      migrateAddStreamingAndWebSocketFlags(db!);
+    }).not.toThrow();
+
+    // Verify columns still exist and have correct defaults
+    const tableInfo = db!.prepare("PRAGMA table_info(requests)").all() as any[];
+    const isStreamingCol = tableInfo.find(
+      (col: any) => col.name === "is_streaming",
+    ) as any;
+    const isWebsocketCol = tableInfo.find(
+      (col: any) => col.name === "is_websocket",
+    ) as any;
+
+    expect(isStreamingCol).toBeDefined();
+    expect(isWebsocketCol).toBeDefined();
+    expect(isStreamingCol.dflt_value).toBe("0");
+    expect(isWebsocketCol.dflt_value).toBe("0");
+  });
+
+  it("应该保持向后兼容性 - 现有数据应该继续有效", () => {
+    // Insert a request without the new columns (simulating old data)
+    const sessionId = "session-1";
+    const requestId = "req-1";
+
+    // First, create a session
+    db!.prepare(
+      `
+      INSERT INTO sessions (id, name, created_at)
+      VALUES (?, ?, ?)
+    `,
+    ).run(sessionId, "Test Session", Date.now());
+
+    // Insert a request record
+    db!.prepare(
+      `
+      INSERT INTO requests
+      (id, session_id, sequence, timestamp, method, url)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `,
+    ).run(requestId, sessionId, 1, Date.now(), "GET", "https://example.com");
+
+    // Query the request back
+    const request = db!
+      .prepare("SELECT * FROM requests WHERE id = ?")
+      .get(requestId) as any;
+
+    // Verify the record exists and new columns have default values
+    expect(request).toBeDefined();
+    expect(request.id).toBe(requestId);
+    expect(request.is_streaming).toBe(0);
+    expect(request.is_websocket).toBe(0);
+  });
+
+});
+
+if (sqliteLoadError) {
+  describe("Database Migrations environment", () => {
+    it("应该在原生模块不可用时给出明确信号", () => {
+      expect(sqliteLoadError?.message).toBeTruthy();
+    });
+  });
+}

package/tests/main/release-workflow.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, it } from "vitest";
+import { readFileSync } from "fs";
+import path from "path";
+
+function readWorkspaceFile(relativePath: string): string {
+  return readFileSync(path.join(process.cwd(), relativePath), "utf8");
+}
+
+describe("macOS 发布工作流", () => {
+  it("应该使用 Node 24 运行时兼容的 Actions 主版本", () => {
+    const workflow = readWorkspaceFile(".github/workflows/build.yml");
+
+    expect(workflow).toContain("uses: actions/checkout@v6");
+    expect(workflow).toContain("uses: pnpm/action-setup@v6");
+    expect(workflow).toContain("uses: actions/setup-node@v6");
+    expect(workflow).toContain("uses: actions/upload-artifact@v7");
+    expect(workflow).toContain("uses: actions/download-artifact@v6");
+    expect(workflow).toContain("uses: softprops/action-gh-release@v3");
+  });
+
+  it("应该在同一个 macOS 构建中产出 x64 和 arm64 更新元数据", () => {
+    const workflow = readWorkspaceFile(".github/workflows/build.yml");
+
+    expect(workflow).toContain("platform: mac");
+    expect(workflow).toContain("npx electron-builder --mac --x64 --arm64 --publish never");
+    expect(workflow).toContain("grep -q 'arm64\\.zip' dist/latest-mac.yml");
+    expect(workflow).toContain("grep -q 'x64\\.zip' dist/latest-mac.yml");
+  });
+
+  it("应该仅在 macOS 代码签名 secrets 存在时注入并校验签名", () => {
+    const workflow = readWorkspaceFile(".github/workflows/build.yml");
+
+    expect(workflow).toContain("SIGNING_CSC_LINK: ${{ secrets.CSC_LINK }}");
+    expect(workflow).toContain('if [ -n "$SIGNING_CSC_LINK" ]; then');
+    expect(workflow).toContain('echo "CSC_LINK=$SIGNING_CSC_LINK" >> "$GITHUB_ENV"');
+    expect(workflow).toContain('echo "MAC_SIGNING_ENABLED=true" >> "$GITHUB_ENV"');
+    expect(workflow).toContain('echo "MAC_SIGNING_ENABLED=false" >> "$GITHUB_ENV"');
+    expect(workflow).toContain('if [ "$MAC_SIGNING_ENABLED" != "true" ]; then');
+    expect(workflow).toContain("codesign --verify --deep --strict --verbose=2");
+  });
+
+  it("应该为 macOS 构建启用 hardened runtime 和 entitlements", () => {
+    const builderConfig = readWorkspaceFile("electron-builder.yml");
+
+    expect(builderConfig).toContain("hardenedRuntime: true");
+    expect(builderConfig).toContain("gatekeeperAssess: false");
+    expect(builderConfig).toContain("type: distribution");
+    expect(builderConfig).toContain("entitlements: resources/entitlements.mac.plist");
+    expect(builderConfig).toContain("entitlementsInherit: resources/entitlements.mac.plist");
+  });
+
+  it("应该提供 Electron 所需的 macOS entitlements", () => {
+    const entitlements = readWorkspaceFile("resources/entitlements.mac.plist");
+
+    expect(entitlements).toContain("com.apple.security.cs.allow-jit");
+    expect(entitlements).toContain("com.apple.security.cs.allow-unsigned-executable-memory");
+    expect(entitlements).toContain("com.apple.security.cs.disable-library-validation");
+  });
+});

package/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "files": [],
+  "references": [
+    { "path": "./tsconfig.node.json" },
+    { "path": "./tsconfig.web.json" }
+  ]
+}

package/tsconfig.node.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "target": "ESNext",
+    "lib": ["ESNext"],
+    "outDir": "./out",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "paths": {
+      "@shared/*": ["./src/shared/*"]
+    }
+  },
+  "include": ["src/main/**/*", "src/preload/**/*", "src/shared/**/*"]
+}

package/tsconfig.web.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "target": "ESNext",
+    "lib": ["ESNext", "DOM", "DOM.Iterable"],
+    "jsx": "react-jsx",
+    "outDir": "./out",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "paths": {
+      "@shared/*": ["./src/shared/*"]
+    }
+  },
+  "include": ["src/renderer/**/*", "src/shared/**/*"]
+}

package/vitest.config.ts

@@ -0,0 +1,13 @@
+import { defineConfig } from 'vitest/config'
+import { resolve } from 'path'
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['tests/**/*.test.ts'],
+    alias: {
+      '@shared': resolve(__dirname, 'src/shared')
+    }
+  }
+})