@tengx5383/aitool-sync-cli 0.1.0

package/tests/integration/init-flow.test.ts

@@ -0,0 +1,69 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { createDefaultConfig, readConfig, writeConfig } from '../../src/config/config-file.js';
+import { getPreset, getAllPresets } from '../../src/presets/index.js';
+
+describe('init flow', () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'aitoolsync-test-'));
+    process.chdir(tmpDir);
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('creates a default config file', () => {
+    const config = createDefaultConfig();
+    writeConfig(config, tmpDir);
+
+    const configPath = path.join(tmpDir, '.aitoolsync.json');
+    expect(fs.existsSync(configPath)).toBe(true);
+
+    const loaded = readConfig(configPath);
+    expect(loaded).not.toBeNull();
+    expect(loaded!.version).toBe(1);
+    expect(loaded!.gistId).toBeNull();
+    expect(loaded!.syncPaths).toEqual([]);
+  });
+
+  it('reads and validates config file', () => {
+    const config = createDefaultConfig();
+    config.gistId = 'test-gist-123';
+    writeConfig(config, tmpDir);
+
+    const loaded = readConfig();
+    expect(loaded).not.toBeNull();
+    expect(loaded!.gistId).toBe('test-gist-123');
+  });
+
+  it('returns null for non-existent config', () => {
+    const loaded = readConfig();
+    expect(loaded).toBeNull();
+  });
+
+  it('has all presets defined', () => {
+    const presets = getAllPresets();
+    expect(presets.length).toBe(3);
+    expect(presets.map((p) => p.id)).toContain('claude-code');
+    expect(presets.map((p) => p.id)).toContain('hermes');
+    expect(presets.map((p) => p.id)).toContain('openclaw');
+  });
+
+  it('can get preset by ID', () => {
+    const preset = getPreset('claude-code');
+    expect(preset).not.toBeUndefined();
+    expect(preset!.name).toBe('Claude Code');
+    expect(preset!.defaultPaths.length).toBeGreaterThan(0);
+  });
+
+  it('includes default exclusions in new config', () => {
+    const config = createDefaultConfig();
+    expect(config.exclusions.some((e) => e.pattern === '**/node_modules/**')).toBe(true);
+    expect(config.exclusions.some((e) => e.pattern === '**/.git/**')).toBe(true);
+  });
+});

package/tests/integration/push-pull-flow.test.ts

@@ -0,0 +1,183 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { createDefaultConfig, writeConfig, readConfig } from '../../src/config/config-file.js';
+import { pushSync, pullSync } from '../../src/core/sync-engine.js';
+import { buildSyncPackage, parseSyncPackage } from '../../src/core/sync-package.js';
+import { createManifest, serializeManifest, parseManifest } from '../../src/core/manifest.js';
+import { MockGistClient } from '../../src/gist/mock-client.js';
+import type { AppConfig, Manifest, ManifestEntry } from '../../src/types/index.js';
+
+function createTestDir(base: string): string {
+  const dir = path.join(base, 'my-tools');
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, 'config.json'), JSON.stringify({ version: 1 }));
+  fs.writeFileSync(path.join(dir, 'secrets.env'), 'SECRET=abc');
+  return dir;
+}
+
+describe('push-pull flow', () => {
+  let tmpDir: string;
+  let mockClient: MockGistClient;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'aitoolsync-pushpull-'));
+    process.chdir(tmpDir);
+    mockClient = new MockGistClient();
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('pushSync creates a Gist and uploads package', async () => {
+    const testDir = createTestDir(tmpDir);
+    const config = createDefaultConfig();
+    config.syncPaths = [{ name: 'my-tools', path: testDir, enabled: true }];
+
+    // Create Gist first
+    const gist = await mockClient.createGist('aitoolsync', {
+      'aitoolsync-package.json': { content: '{}' },
+    });
+    config.gistId = gist.gistId;
+    writeConfig(config);
+
+    const result = await pushSync(config, mockClient, false);
+    expect(result.success).toBe(true);
+    expect(result.filesUploaded).toBeGreaterThan(0);
+
+    // Verify Gist contains the package
+    const fetched = await mockClient.getGist(gist.gistId);
+    const pkgFile = fetched.files.find((f) => f.filename === 'aitoolsync-package.json');
+    expect(pkgFile).toBeDefined();
+
+    const pkg = parseSyncPackage(pkgFile!.content);
+    expect(pkg).not.toBeNull();
+    expect(pkg!.files.length).toBeGreaterThan(0);
+    expect(pkg!.manifest.entries.length).toBeGreaterThan(0);
+  });
+
+  it('pushSync detects conflicts and fails without force', async () => {
+    const testDir = createTestDir(tmpDir);
+    const config = createDefaultConfig();
+    config.syncPaths = [{ name: 'my-tools', path: testDir, enabled: true }];
+
+    const gist = await mockClient.createGist('aitoolsync', {
+      'aitoolsync-package.json': { content: '{}' },
+    });
+    config.gistId = gist.gistId;
+
+    // Set lastKnownManifest to a different version (third checksum)
+    const baseManifest = createManifest([
+      { relativePath: 'config.json', checksum: 'base-hash', size: 100, modifiedAt: new Date().toISOString(), sourceName: 'my-tools', encrypted: false, encryptionPattern: null },
+    ]);
+    config.lastKnownManifest = serializeManifest(baseManifest);
+    writeConfig(config);
+
+    // Create a remote package with different content
+    const remoteManifest = createManifest([
+      { relativePath: 'config.json', checksum: 'different-hash', size: 100, modifiedAt: new Date().toISOString(), sourceName: 'my-tools', encrypted: false, encryptionPattern: null },
+    ]);
+    const remotePkg = await buildSyncPackage(remoteManifest, config);
+    await mockClient.updateGist(gist.gistId, {
+      'aitoolsync-package.json': { content: JSON.stringify(remotePkg) },
+    });
+
+    // Modify local file to be different from both
+    fs.writeFileSync(path.join(testDir, 'config.json'), JSON.stringify({ version: 2, changed: true }));
+
+    const result = await pushSync(config, mockClient, false);
+    expect(result.success).toBe(false);
+    expect(result.errors.some((e) => e.includes('Conflicts'))).toBe(true);
+  });
+
+  it('pushSync --force overrides conflicts', async () => {
+    const testDir = createTestDir(tmpDir);
+    const config = createDefaultConfig();
+    config.syncPaths = [{ name: 'my-tools', path: testDir, enabled: true }];
+
+    const gist = await mockClient.createGist('aitoolsync', {
+      'aitoolsync-package.json': { content: '{}' },
+    });
+    config.gistId = gist.gistId;
+
+    // Create remote with different content
+    const remoteManifest = createManifest([
+      { relativePath: 'config.json', checksum: 'remotehash', size: 100, modifiedAt: new Date().toISOString(), sourceName: 'my-tools', encrypted: false, encryptionPattern: null },
+    ]);
+    // Set lastKnownManifest to something else to create a three-way conflict
+    const baseManifest = createManifest([
+      { relativePath: 'config.json', checksum: 'basehash', size: 100, modifiedAt: new Date().toISOString(), sourceName: 'my-tools', encrypted: false, encryptionPattern: null },
+    ]);
+    config.lastKnownManifest = serializeManifest(baseManifest);
+    writeConfig(config);
+
+    // Write remote package
+    const remotePkg = await buildSyncPackage(remoteManifest, config);
+    await mockClient.updateGist(gist.gistId, {
+      'aitoolsync-package.json': { content: JSON.stringify(remotePkg) },
+    });
+
+    // Modify local
+    fs.writeFileSync(path.join(testDir, 'config.json'), JSON.stringify({ forced: true }));
+
+    const result = await pushSync(config, mockClient, true);
+    expect(result.success).toBe(true);
+    expect(result.action).toBe('force-push');
+  });
+
+  it('pullSync downloads files and writes them locally', async () => {
+    const testDir = createTestDir(tmpDir);
+    const config = createDefaultConfig();
+    config.syncPaths = [{ name: 'my-tools', path: testDir, enabled: true }];
+
+    const gist = await mockClient.createGist('aitoolsync', {
+      'aitoolsync-package.json': { content: '{}' },
+    });
+    config.gistId = gist.gistId;
+
+    // Push local first
+    const pushResult = await pushSync(config, mockClient, false);
+    expect(pushResult.success).toBe(true);
+
+    // Now modify local file
+    fs.writeFileSync(path.join(testDir, 'config.json'), JSON.stringify({ version: 999 }));
+
+    // Pull should overwrite with remote version
+    const result = await pullSync(config, mockClient, false);
+    expect(result.success).toBe(true);
+    expect(result.filesDownloaded).toBeGreaterThan(0);
+
+    // Verify file was restored from remote
+    const content = JSON.parse(fs.readFileSync(path.join(testDir, 'config.json'), 'utf-8'));
+    expect(content.version).toBe(1); // original version from push
+  });
+
+  it('sync package round-trips correctly', async () => {
+    const testDir = createTestDir(tmpDir);
+    const config = createDefaultConfig();
+    config.syncPaths = [{ name: 'my-tools', path: testDir, enabled: true }];
+
+    const manifest = createManifest([
+      { relativePath: 'config.json', checksum: 'abc', size: 100, modifiedAt: new Date().toISOString(), sourceName: 'my-tools', encrypted: false, encryptionPattern: null },
+      { relativePath: 'secrets.env', checksum: 'def', size: 200, modifiedAt: new Date().toISOString(), sourceName: 'my-tools', encrypted: false, encryptionPattern: null },
+    ]);
+
+    const pkg = await buildSyncPackage(manifest, config);
+    expect(pkg.version).toBe(1);
+    expect(pkg.files.length).toBe(2);
+
+    // Verify content is base64 encoded
+    const json = JSON.stringify(pkg);
+    const parsed = parseSyncPackage(json);
+    expect(parsed).not.toBeNull();
+    expect(parsed!.files.length).toBe(2);
+
+    // Decode and verify file content exists (not all files are JSON)
+    for (const file of parsed!.files) {
+      const decoded = Buffer.from(file.content, 'base64').toString('utf-8');
+      expect(decoded.length).toBeGreaterThan(0);
+    }
+  });
+});

package/tests/integration/status-flow.test.ts

@@ -0,0 +1,149 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { createDefaultConfig, writeConfig, readConfig } from '../../src/config/config-file.js';
+import { buildLocalManifest, computeDiff } from '../../src/core/sync-engine.js';
+import { createManifest, serializeManifest } from '../../src/core/manifest.js';
+import { diffManifests } from '../../src/utils/diff.js';
+import type { AppConfig, Manifest, ManifestEntry } from '../../src/types/index.js';
+
+function makeEntry(overrides: Partial<ManifestEntry> & { relativePath: string }): ManifestEntry {
+  return {
+    checksum: 'abc123',
+    size: 100,
+    modifiedAt: new Date().toISOString(),
+    sourceName: 'test',
+    encrypted: false,
+    encryptionPattern: null,
+    ...overrides,
+  };
+}
+
+describe('status flow', () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'aitoolsync-status-'));
+    process.chdir(tmpDir);
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('computes diff: no changes', () => {
+    const local = createManifest([
+      makeEntry({ relativePath: 'file1.txt', checksum: 'aaa' }),
+      makeEntry({ relativePath: 'file2.txt', checksum: 'bbb' }),
+    ]);
+    const remote = createManifest([
+      makeEntry({ relativePath: 'file1.txt', checksum: 'aaa' }),
+      makeEntry({ relativePath: 'file2.txt', checksum: 'bbb' }),
+    ]);
+
+    const diff = diffManifests(local, remote, null);
+    expect(diff.hasChanges).toBe(false);
+    expect(diff.hasConflicts).toBe(false);
+    expect(diff.added).toHaveLength(0);
+    expect(diff.removed).toHaveLength(0);
+    expect(diff.modified).toHaveLength(0);
+  });
+
+  it('detects added files', () => {
+    const local = createManifest([
+      makeEntry({ relativePath: 'old.txt', checksum: 'aaa' }),
+      makeEntry({ relativePath: 'new.txt', checksum: 'bbb' }),
+    ]);
+    const remote = createManifest([
+      makeEntry({ relativePath: 'old.txt', checksum: 'aaa' }),
+    ]);
+
+    const diff = diffManifests(local, remote, null);
+    expect(diff.hasChanges).toBe(true);
+    expect(diff.added).toHaveLength(1);
+    expect(diff.added[0].relativePath).toBe('new.txt');
+  });
+
+  it('detects removed files', () => {
+    const local = createManifest([
+      makeEntry({ relativePath: 'old.txt', checksum: 'aaa' }),
+    ]);
+    const remote = createManifest([
+      makeEntry({ relativePath: 'old.txt', checksum: 'aaa' }),
+      makeEntry({ relativePath: 'gone.txt', checksum: 'bbb' }),
+    ]);
+
+    const diff = diffManifests(local, remote, null);
+    expect(diff.removed).toHaveLength(1);
+    expect(diff.removed[0].relativePath).toBe('gone.txt');
+  });
+
+  it('detects modified files', () => {
+    const local = createManifest([
+      makeEntry({ relativePath: 'file.txt', checksum: 'newhash' }),
+    ]);
+    const remote = createManifest([
+      makeEntry({ relativePath: 'file.txt', checksum: 'oldhash' }),
+    ]);
+    const lastKnown = createManifest([
+      makeEntry({ relativePath: 'file.txt', checksum: 'oldhash' }),
+    ]);
+
+    // Only local changed (checksums differ; lastKnown matches remote)
+    const diff = diffManifests(local, remote, lastKnown);
+    expect(diff.modified).toHaveLength(1);
+    expect(diff.modified[0].relativePath).toBe('file.txt');
+    expect(diff.hasConflicts).toBe(false);
+  });
+
+  it('detects conflicts with three-way merge', () => {
+    const local = createManifest([
+      makeEntry({ relativePath: 'file.txt', checksum: 'localhash' }),
+    ]);
+    const remote = createManifest([
+      makeEntry({ relativePath: 'file.txt', checksum: 'remotehash' }),
+    ]);
+    const lastKnown = createManifest([
+      makeEntry({ relativePath: 'file.txt', checksum: 'basehash' }),
+    ]);
+
+    const diff = diffManifests(local, remote, lastKnown);
+    expect(diff.hasConflicts).toBe(true);
+    expect(diff.conflicts).toHaveLength(1);
+    expect(diff.conflicts[0].relativePath).toBe('file.txt');
+  });
+
+  it('collects files from a real directory', () => {
+    // Create a test directory structure
+    const testDir = path.join(tmpDir, 'test-config');
+    fs.mkdirSync(testDir, { recursive: true });
+    fs.writeFileSync(path.join(testDir, 'settings.json'), JSON.stringify({ key: 'value' }));
+    fs.writeFileSync(path.join(testDir, 'mcp.json'), JSON.stringify({ mcp: true }));
+
+    const config = createDefaultConfig();
+    config.syncPaths = [{ name: 'test', path: testDir, enabled: true }];
+
+    const manifest = buildLocalManifest(config);
+    expect(manifest.entries.length).toBe(2);
+    const paths = manifest.entries.map((e) => e.relativePath);
+    expect(paths).toContain('settings.json');
+    expect(paths).toContain('mcp.json');
+  });
+
+  it('excludes files matching exclusion rules', () => {
+    const testDir = path.join(tmpDir, 'excluded-config');
+    fs.mkdirSync(path.join(testDir, 'node_modules'), { recursive: true });
+    fs.mkdirSync(path.join(testDir, 'src'), { recursive: true });
+    fs.writeFileSync(path.join(testDir, 'src', 'main.ts'), 'code');
+    fs.writeFileSync(path.join(testDir, 'node_modules', 'package.json'), '{}');
+
+    const config = createDefaultConfig();
+    config.syncPaths = [{ name: 'excl', path: testDir, enabled: true }];
+
+    const manifest = buildLocalManifest(config);
+    const paths = manifest.entries.map((e) => e.relativePath);
+    expect(paths).toContain('src/main.ts');
+    expect(paths).not.toContain('node_modules/package.json');
+  });
+});

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist", "tests"]
+}

package/vitest.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['tests/**/*.test.ts'],
+    testTimeout: 10000,
+  },
+});