@web-auto/webauto 0.1.1 → 0.1.2

package/tests/unit/utils/browser-service.test.mjs

@@ -1,153 +0,0 @@
-import { describe, it, 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';
-
-// Mock fetch for testing
-const originalFetch = global.fetch;
-
-describe('browser-service utilities', () => {
-  beforeEach(() => {
-    // Mock fetch
-    global.fetch = async (url, options) => {
-      if (url.includes('/health')) {
-        return { ok: true, status: 200 };
-      }
-      if (url.includes('/command')) {
-        const body = JSON.parse(options.body);
-        if (body.action === 'getStatus') {
-          return {
-            ok: true,
-            json: async () => ({ sessions: [] }),
-          };
-        }
-        return {
-          ok: true,
-          json: async () => ({ ok: true }),
-        };
-      }
-      return { ok: true, json: async () => ({}) };
-    };
-  });
-
-  afterEach(() => {
-    global.fetch = originalFetch;
-  });
-
-  describe('module exports', () => {
-    it('should export required functions', async () => {
-      const bs = await import('../../../src/utils/browser-service.mjs');
-      assert.strictEqual(typeof bs.callAPI, 'function');
-      assert.strictEqual(typeof bs.getSessionByProfile, 'function');
-      assert.strictEqual(typeof bs.checkBrowserService, 'function');
-      assert.strictEqual(typeof bs.detectCamoufoxPath, 'function');
-      assert.strictEqual(typeof bs.ensureCamoufox, 'function');
-      assert.strictEqual(typeof bs.ensureBrowserService, 'function');
-      assert.strictEqual(typeof bs.findRepoRootCandidate, 'function');
-    });
-  });
-
-  describe('checkBrowserService', () => {
-    it('should return true when service is healthy', async () => {
-      const { checkBrowserService } = await import('../../../src/utils/browser-service.mjs');
-      const result = await checkBrowserService();
-      assert.strictEqual(result, true);
-    });
-
-    it('should return false when service is not running', async () => {
-      global.fetch = async () => { throw new Error('Connection refused'); };
-      const { checkBrowserService } = await import('../../../src/utils/browser-service.mjs');
-      const result = await checkBrowserService();
-      assert.strictEqual(result, false);
-    });
-  });
-
-  describe('callAPI', () => {
-    it('should call fetch with correct parameters', async () => {
-      let calledUrl = null;
-      let calledOptions = null;
-      global.fetch = async (url, options) => {
-        calledUrl = url;
-        calledOptions = options;
-        return { ok: true, json: async () => ({ result: 'ok' }) };
-      };
-      const { callAPI } = await import('../../../src/utils/browser-service.mjs');
-      const result = await callAPI('/test-action', { foo: 'bar' });
-      assert.ok(calledUrl.includes('/command'));
-      assert.strictEqual(calledOptions.method, 'POST');
-      assert.strictEqual(result.result, 'ok');
-    });
-
-    it('should throw on HTTP error', async () => {
-      global.fetch = async () => ({
-        ok: false,
-        status: 500,
-        text: async () => 'Internal Server Error',
-      });
-      const { callAPI } = await import('../../../src/utils/browser-service.mjs');
-      await assert.rejects(
-        async () => callAPI('/error-action', {}),
-        /HTTP 500/
-      );
-    });
-
-    it('should throw on error response', async () => {
-      global.fetch = async () => ({
-        ok: false,
-        status: 400,
-        json: async () => ({ error: 'Bad request' }),
-      });
-      const { callAPI } = await import('../../../src/utils/browser-service.mjs');
-      await assert.rejects(
-        async () => callAPI('/error-action', {}),
-        /Bad request/
-      );
-    });
-  });
-
-  describe('getSessionByProfile', () => {
-    it('should return session when found', async () => {
-      global.fetch = async () => ({
-        ok: true,
-        json: async () => ({
-          sessions: [
-            { profileId: 'profile-a', sessionId: 'sid-a' },
-            { profileId: 'profile-b', sessionId: 'sid-b' },
-          ],
-        }),
-      });
-      const { getSessionByProfile } = await import('../../../src/utils/browser-service.mjs');
-      const session = await getSessionByProfile('profile-a');
-      assert.strictEqual(session.profileId, 'profile-a');
-    });
-
-    it('should return null when not found', async () => {
-      global.fetch = async () => ({
-        ok: true,
-        json: async () => ({ sessions: [] }),
-      });
-      const { getSessionByProfile } = await import('../../../src/utils/browser-service.mjs');
-      const session = await getSessionByProfile('nonexistent');
-      assert.strictEqual(session, null);
-    });
-  });
-
-  describe('detectCamoufoxPath', () => {
-    it('should return null when camoufox not installed', async () => {
-      const { detectCamoufoxPath } = await import('../../../src/utils/browser-service.mjs');
-      // This will likely return null in test environment
-      const result = detectCamoufoxPath();
-      // Just verify it returns something (null or string)
-      assert.ok(result === null || typeof result === 'string');
-    });
-  });
-
-  describe('findRepoRootCandidate', () => {
-    it('should return null or a valid path', async () => {
-      const { findRepoRootCandidate } = await import('../../../src/utils/browser-service.mjs');
-      const result = findRepoRootCandidate();
-      assert.ok(result === null || typeof result === 'string');
-    });
-  });
-});

package/tests/unit/utils/config.test.mjs

@@ -1,166 +0,0 @@
-import { describe, it } from 'node:test';
-import assert from 'node:assert';
-import fs from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
-
-// We need to test the actual config module which uses ~/.webauto
-// So we'll test the pure functions that don't require file system state
-
-describe('config utilities', () => {
-  describe('module exports', () => {
-    it('should export required functions', async () => {
-      const config = await import('../../../src/utils/config.mjs');
-      assert.strictEqual(typeof config.ensureDir, 'function');
-      assert.strictEqual(typeof config.readJson, 'function');
-      assert.strictEqual(typeof config.writeJson, 'function');
-      assert.strictEqual(typeof config.loadConfig, 'function');
-      assert.strictEqual(typeof config.saveConfig, 'function');
-      assert.strictEqual(typeof config.listProfiles, 'function');
-      assert.strictEqual(typeof config.isValidProfileId, 'function');
-      assert.strictEqual(typeof config.createProfile, 'function');
-      assert.strictEqual(typeof config.deleteProfile, 'function');
-      assert.strictEqual(typeof config.setDefaultProfile, 'function');
-      assert.strictEqual(typeof config.getDefaultProfile, 'function');
-    });
-  });
-
-  describe('isValidProfileId', () => {
-    it('should accept valid profile IDs', async () => {
-      const { isValidProfileId } = await import('../../../src/utils/config.mjs');
-      assert.strictEqual(isValidProfileId('profile123'), true);
-      assert.strictEqual(isValidProfileId('my_profile'), true);
-      assert.strictEqual(isValidProfileId('my-profile'), true);
-      assert.strictEqual(isValidProfileId('my.profile'), true);
-      assert.strictEqual(isValidProfileId('Profile_123.test'), true);
-    });
-
-    it('should reject invalid profile IDs', async () => {
-      const { isValidProfileId } = await import('../../../src/utils/config.mjs');
-      assert.strictEqual(isValidProfileId('profile/with/slash'), false);
-      assert.strictEqual(isValidProfileId('profile:with:colon'), false);
-      assert.strictEqual(isValidProfileId(''), false);
-      assert.strictEqual(isValidProfileId(null), false);
-      assert.strictEqual(isValidProfileId(undefined), false);
-      assert.strictEqual(isValidProfileId(123), false);
-      assert.strictEqual(isValidProfileId('profile with space'), false);
-    });
-  });
-
-  describe('ensureDir', () => {
-    it('should create nested directories', async () => {
-      const { ensureDir } = await import('../../../src/utils/config.mjs');
-      const testDir = path.join(os.tmpdir(), 'camo-test-ensureDir-' + Date.now(), 'nested', 'path');
-      ensureDir(testDir);
-      assert.strictEqual(fs.existsSync(testDir), true);
-      fs.rmSync(path.dirname(path.dirname(path.dirname(testDir))), { recursive: true, force: true });
-    });
-
-    it('should not throw for existing directories', async () => {
-      const { ensureDir } = await import('../../../src/utils/config.mjs');
-      const testDir = path.join(os.tmpdir(), 'camo-test-ensureDir2-' + Date.now());
-      fs.mkdirSync(testDir, { recursive: true });
-      assert.doesNotThrow(() => ensureDir(testDir));
-      fs.rmSync(testDir, { recursive: true, force: true });
-    });
-  });
-
-  describe('readJson/writeJson', () => {
-    it('should write and read JSON correctly', async () => {
-      const { writeJson, readJson } = await import('../../../src/utils/config.mjs');
-      const testFile = path.join(os.tmpdir(), 'camo-test-json-' + Date.now() + '.json');
-      const data = { foo: 'bar', num: 42, nested: { a: 1 } };
-      writeJson(testFile, data);
-      const read = readJson(testFile);
-      assert.deepStrictEqual(read, data);
-      fs.unlinkSync(testFile);
-    });
-
-    it('should return null for non-existent file', async () => {
-      const { readJson } = await import('../../../src/utils/config.mjs');
-      const result = readJson('/nonexistent/path/file.json');
-      assert.strictEqual(result, null);
-    });
-
-    it('should return null for invalid JSON', async () => {
-      const { readJson } = await import('../../../src/utils/config.mjs');
-      const testFile = path.join(os.tmpdir(), 'camo-test-invalid-' + Date.now() + '.json');
-      fs.writeFileSync(testFile, 'not valid json {');
-      const result = readJson(testFile);
-      assert.strictEqual(result, null);
-      fs.unlinkSync(testFile);
-    });
-  });
-
-  describe('listProfiles', () => {
-    it('should return an array', async () => {
-      const { listProfiles } = await import('../../../src/utils/config.mjs');
-      const profiles = listProfiles();
-      assert.ok(Array.isArray(profiles));
-    });
-  });
-
-  describe('loadConfig/saveConfig', () => {
-    it('should load config with defaults', async () => {
-      const { loadConfig } = await import('../../../src/utils/config.mjs');
-      const cfg = loadConfig();
-      assert.ok(cfg !== null);
-      assert.ok('defaultProfile' in cfg);
-      assert.ok('repoRoot' in cfg);
-    });
-  });
-
-  describe('createProfile/deleteProfile', () => {
-    it('should create and delete profile', async () => {
-      const { createProfile, deleteProfile, listProfiles } = await import('../../../src/utils/config.mjs');
-      const profileId = 'test-profile-' + Date.now();
-      
-      // Create
-      createProfile(profileId);
-      const profilesAfterCreate = listProfiles();
-      assert.ok(profilesAfterCreate.includes(profileId));
-      
-      // Delete
-      deleteProfile(profileId);
-      const profilesAfterDelete = listProfiles();
-      assert.ok(!profilesAfterDelete.includes(profileId));
-    });
-
-    it('should throw for invalid profile ID on create', async () => {
-      const { createProfile } = await import('../../../src/utils/config.mjs');
-      assert.throws(() => createProfile('invalid/id'), /Invalid profileId/);
-    });
-
-    it('should throw for non-existent profile on delete', async () => {
-      const { deleteProfile } = await import('../../../src/utils/config.mjs');
-      assert.throws(() => deleteProfile('non-existent-profile-' + Date.now()), /Profile not found/);
-    });
-  });
-
-  describe('setDefaultProfile/getDefaultProfile', () => {
-    it('should set and get default profile', async () => {
-      const { createProfile, setDefaultProfile, getDefaultProfile, deleteProfile } = await import('../../../src/utils/config.mjs');
-      const profileId = 'test-default-' + Date.now();
-      
-      createProfile(profileId);
-      setDefaultProfile(profileId);
-      const def = getDefaultProfile();
-      assert.strictEqual(def, profileId);
-      
-      // Can set to null
-      setDefaultProfile(null);
-      
-      deleteProfile(profileId);
-    });
-  });
-
-  describe('constants', () => {
-    it('should export required constants', async () => {
-      const config = await import('../../../src/utils/config.mjs');
-      assert.ok(config.CONFIG_DIR);
-      assert.ok(config.PROFILES_DIR);
-      assert.ok(config.CONFIG_FILE);
-      assert.ok(config.BROWSER_SERVICE_URL);
-    });
-  });
-});

package/tests/unit/utils/fingerprint.test.mjs

@@ -1,166 +0,0 @@
-import { describe, it } from 'node:test';
-import assert from 'node:assert';
-import {
-  GEOIP_REGIONS,
-  OS_OPTIONS,
-  hasGeoIP,
-  getGeoIPPath,
-  generateFingerprint,
-  listAvailableRegions,
-  listAvailableOS,
-} from '../../../src/utils/fingerprint.mjs';
-
-describe('fingerprint utilities', () => {
-  describe('GEOIP_REGIONS', () => {
-    it('should contain expected regions', () => {
-      assert.ok(GEOIP_REGIONS['us']);
-      assert.ok(GEOIP_REGIONS['uk']);
-      assert.ok(GEOIP_REGIONS['jp']);
-      assert.strictEqual(GEOIP_REGIONS['us'].country, 'United States');
-    });
-
-    it('should have required fields for each region', () => {
-      for (const [key, config] of Object.entries(GEOIP_REGIONS)) {
-        assert.ok(config.country, `${key} should have country`);
-        assert.ok(config.timezone, `${key} should have timezone`);
-        assert.ok(config.locale, `${key} should have locale`);
-        assert.ok(config.city, `${key} should have city`);
-      }
-    });
-  });
-
-  describe('OS_OPTIONS', () => {
-    it('should contain expected OS options', () => {
-      assert.ok(OS_OPTIONS['mac']);
-      assert.ok(OS_OPTIONS['windows']);
-      assert.ok(OS_OPTIONS['linux']);
-      assert.strictEqual(OS_OPTIONS['mac'].platform, 'darwin');
-    });
-
-    it('should have required fields for each OS', () => {
-      for (const [key, config] of Object.entries(OS_OPTIONS)) {
-        assert.ok(config.platform, `${key} should have platform`);
-        assert.ok(config.os, `${key} should have os`);
-        assert.ok(config.osVersion, `${key} should have osVersion`);
-        assert.ok(config.cpuCores, `${key} should have cpuCores`);
-        assert.ok(config.memory, `${key} should have memory`);
-      }
-    });
-  });
-
-  describe('hasGeoIP', () => {
-    it('should return boolean', () => {
-      const result = hasGeoIP();
-      assert.strictEqual(typeof result, 'boolean');
-    });
-  });
-
-  describe('getGeoIPPath', () => {
-    it('should return a string path', () => {
-      const path = getGeoIPPath();
-      assert.strictEqual(typeof path, 'string');
-      assert.ok(path.includes('geoip'));
-    });
-  });
-
-  describe('generateFingerprint', () => {
-    it('should generate fingerprint with default options', () => {
-      const fp = generateFingerprint();
-      assert.ok(fp.os);
-      assert.ok(fp.platform);
-      assert.ok(fp.screen);
-      assert.ok(fp.webgl);
-      assert.ok(fp.userAgent);
-      assert.ok(fp.timezone);
-    });
-
-    it('should use specified OS', () => {
-      const fp = generateFingerprint({ os: 'windows' });
-      assert.strictEqual(fp.platform, 'win32');
-      assert.strictEqual(fp.os, 'Windows');
-    });
-
-    it('should use specified region', () => {
-      const fp = generateFingerprint({ region: 'jp' });
-      assert.strictEqual(fp.country, 'Japan');
-      assert.strictEqual(fp.timezone, 'Asia/Tokyo');
-      assert.strictEqual(fp.locale, 'ja-JP');
-    });
-
-    it('should have valid screen dimensions', () => {
-      const fp = generateFingerprint();
-      assert.ok(fp.screen.width > 0);
-      assert.ok(fp.screen.height > 0);
-    });
-
-    it('should have webgl vendor and renderer', () => {
-      const fp = generateFingerprint();
-      assert.ok(fp.webgl.vendor);
-      assert.ok(fp.webgl.renderer);
-    });
-
-    it('should generate valid user agent for mac', () => {
-      const fp = generateFingerprint({ os: 'mac' });
-      assert.ok(fp.userAgent.includes('Macintosh'));
-      assert.ok(fp.userAgent.includes('Chrome'));
-    });
-
-    it('should generate valid user agent for windows', () => {
-      const fp = generateFingerprint({ os: 'windows' });
-      assert.ok(fp.userAgent.includes('Windows'));
-      assert.ok(fp.userAgent.includes('Chrome'));
-    });
-
-    it('should generate valid user agent for linux', () => {
-      const fp = generateFingerprint({ os: 'linux' });
-      assert.ok(fp.userAgent.includes('Linux'));
-      assert.ok(fp.userAgent.includes('Chrome'));
-    });
-
-    it('should fallback to defaults for invalid os', () => {
-      const fp = generateFingerprint({ os: 'invalid' });
-      assert.ok(fp.os); // Should still have valid OS
-    });
-
-    it('should fallback to defaults for invalid region', () => {
-      const fp = generateFingerprint({ region: 'invalid' });
-      assert.ok(fp.country); // Should still have valid country
-    });
-  });
-
-  describe('listAvailableRegions', () => {
-    it('should return array of regions', () => {
-      const regions = listAvailableRegions();
-      assert.ok(Array.isArray(regions));
-      assert.ok(regions.length > 0);
-    });
-
-    it('should have required fields in each region', () => {
-      const regions = listAvailableRegions();
-      for (const r of regions) {
-        assert.ok(r.key);
-        assert.ok(r.country);
-        assert.ok(r.city);
-        assert.ok(r.timezone);
-      }
-    });
-  });
-
-  describe('listAvailableOS', () => {
-    it('should return array of OS options', () => {
-      const osList = listAvailableOS();
-      assert.ok(Array.isArray(osList));
-      assert.ok(osList.length > 0);
-    });
-
-    it('should have required fields in each OS', () => {
-      const osList = listAvailableOS();
-      for (const o of osList) {
-        assert.ok(o.key);
-        assert.ok(o.platform);
-        assert.ok(o.os);
-        assert.ok(o.osVersion);
-      }
-    });
-  });
-});

package/tsconfig.json

@@ -1,31 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "lib": ["ES2022", "DOM", "DOM.Iterable"],
-    "allowJs": true,
-    "skipLibCheck": true,
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports": true,
-    "strict": false,
-    "forceConsistentCasingInFileNames": false,
-    "moduleResolution": "nodenext",
-    "resolveJsonModule": true,
-    "isolatedModules": false,
-    "noEmit": false,
-    "declaration": false,
-    "sourceMap": true,
-    "outDir": "./dist",
-    "baseUrl": ".",
-    "noImplicitAny": true,
-    "strictNullChecks": false,
-    "downlevelIteration": true
-  },
-  "include": [
-    "apps/webauto/server.ts"
-  ],
-  "exclude": [
-    "node_modules",
-    "dist"
-  ]
-}

package/tsconfig.services.json

@@ -1,26 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "outDir": "./dist",
-    "noEmit": false,
-    "allowJs": true,
-    "allowImportingTsExtensions": false,
-    "rootDir": "."
-  },
-  "include": [
-    "services/unified-api/**/*.ts",
-    "services/shared/**/*.ts",
-    "services/**/*.d.ts",
-    "services/shared/**/*.d.ts",
-    "modules/container-registry/**/*.ts",
-    "modules/camo-backend/**/*.ts",
-    "modules/workflow/**/*.ts",
-    "modules/xiaohongshu/app/**/*.ts",
-    "apps/webauto/server.ts",
-    "services/controller/**/*.ts"
-  ],
-  "exclude": [
-    "node_modules",
-    "dist"
-  ]
-}