fraim-framework 2.0.26 → 2.0.30

package/dist/tests/test-node-compatibility.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_child_process_1 = require("node:child_process");
+const test_utils_1 = require("./test-utils");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+async function testInitOnNodeVersion(version) {
+    console.log(`   🧪 Testing Node v${version}...`);
+    // Create a temp directory for each version test
+    const tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), `fraim-node-${version}-`));
+    try {
+        const platform = process.platform;
+        const npx = platform === 'win32' ? 'npx.cmd' : 'npx';
+        const binPath = path_1.default.resolve(__dirname, '../bin/fraim.js');
+        // Run: npx -y -p node@<version> node bin/fraim.js init
+        // We use -y to skip prompt, and -p node@version to ensure that specific node binary is used
+        const execNode = (args) => {
+            return new Promise((resolve) => {
+                const ps = (0, node_child_process_1.spawn)(npx, ['-y', '-p', `node@${version}`, 'node', `"${binPath}"`, ...args], {
+                    cwd: tempDir,
+                    env: { ...process.env, TEST_MODE: 'true' },
+                    shell: true
+                });
+                let stdout = '';
+                let stderr = '';
+                ps.stdout.on('data', d => stdout += d.toString());
+                ps.stderr.on('data', d => stderr += d.toString());
+                ps.on('close', (code) => resolve({ stdout, stderr, code }));
+            });
+        };
+        console.log(`      Running "fraim init" on Node ${version}...`);
+        const result = await execNode(['init']);
+        if (result.code !== 0) {
+            console.error(`      ❌ Failed on Node ${version}`);
+            console.error(`      Error: ${result.stderr}`);
+            return false;
+        }
+        const configPath = path_1.default.join(tempDir, '.fraim', 'config.json');
+        if (fs_1.default.existsSync(configPath)) {
+            console.log(`      ✅ Success on Node ${version}`);
+            return true;
+        }
+        else {
+            console.error(`      ❌ Config not found on Node ${version}`);
+            return false;
+        }
+    }
+    catch (e) {
+        console.error(`      ❌ Test Logic Error on Node ${version}:`, e.message);
+        return false;
+    }
+    finally {
+        try {
+            fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+        }
+        catch (e) { }
+    }
+}
+const nodeVersions = ['16', '18', '20', '22'];
+const testCases = nodeVersions.map(v => ({
+    name: `Node v${v} Compatibility`,
+    version: v,
+    tags: ['node', 'compatibility']
+}));
+(0, test_utils_1.runTests)(testCases, async (t) => await testInitOnNodeVersion(t.version), 'Node Compatibility Matrix')
+    .then(() => process.exit(0))
+    .catch(() => process.exit(1));

package/dist/tests/test-npm-install.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_child_process_1 = require("node:child_process");
+const test_utils_1 = require("./test-utils");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+async function testCleanNpmInstall(version) {
+    console.log(`   🧪 Testing NPM Install on Node v${version}...`);
+    // Create a temp directory for the install test
+    const tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), `fraim-npm-${version}-`));
+    try {
+        const platform = process.platform;
+        const npx = platform === 'win32' ? 'npx.cmd' : 'npx';
+        // Copy package.json to temp dir
+        const packageJsonPath = path_1.default.resolve(__dirname, '../package.json');
+        fs_1.default.copyFileSync(packageJsonPath, path_1.default.join(tempDir, 'package.json'));
+        // Run: npx -p node@<version> npm install --package-lock-only
+        // This uses the npm bundled with that specific Node version
+        const execNpm = () => {
+            return new Promise((resolve) => {
+                const ps = (0, node_child_process_1.spawn)(npx, ['-y', '-p', `node@${version}`, 'npm', 'install', '--package-lock-only', '--quiet', '--no-audit'], {
+                    cwd: tempDir,
+                    env: { ...process.env },
+                    shell: true
+                });
+                let stdout = '';
+                let stderr = '';
+                ps.stdout.on('data', d => stdout += d.toString());
+                ps.stderr.on('data', d => stderr += d.toString());
+                ps.on('close', (code) => resolve({ stdout, stderr, code }));
+            });
+        };
+        console.log(`      Running "npm install" with Node ${version}...`);
+        const result = await execNpm();
+        if (result.code !== 0) {
+            console.error(`      ❌ NPM Install Failed on Node ${version}`);
+            console.error(`      Stderr: ${result.stderr}`);
+            return false;
+        }
+        console.log(`      ✅ NPM Resolution Success on Node ${version}`);
+        return true;
+    }
+    catch (e) {
+        console.error(`      ❌ Test Logic Error on Node ${version}:`, e.message);
+        return false;
+    }
+    finally {
+        try {
+            fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+        }
+        catch (e) { }
+    }
+}
+const nodeVersions = ['16', '18', '20', '22'];
+const testCases = nodeVersions.map(v => ({
+    name: `NPM Compatibility (Node v${v})`,
+    version: v,
+    tags: ['npm', 'compatibility']
+}));
+(0, test_utils_1.runTests)(testCases, async (t) => await testCleanNpmInstall(t.version), 'NPM Configuration Matrix')
+    .then(() => process.exit(0))
+    .catch(() => process.exit(1));

package/dist/tests/test-npm-resolution-diagnostic.js

@@ -0,0 +1,140 @@
+"use strict";
+/**
+ * Diagnostic test to understand npm's chalk resolution behavior
+ *
+ * This test will show us exactly what npm does when there's a version conflict
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_child_process_1 = require("node:child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+async function main() {
+    console.log('🔍 NPM Chalk Resolution Diagnostic\n');
+    const tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'npm-diagnostic-'));
+    console.log(`📂 Temp dir: ${tempDir}\n`);
+    try {
+        // 1. Pack fraim-framework
+        console.log('📦 Packing fraim-framework...');
+        const projectRoot = process.cwd();
+        const packResult = (0, node_child_process_1.execSync)('npm pack', {
+            cwd: projectRoot,
+            encoding: 'utf-8'
+        });
+        const tarballName = packResult.trim().split('\n').pop()?.trim();
+        if (!tarballName) {
+            console.log('❌ Failed to pack');
+            return;
+        }
+        const tarballPath = path_1.default.join(projectRoot, tarballName);
+        console.log(`✅ Created: ${tarballName}\n`);
+        // 2. Create test project with chalk v5
+        console.log('📝 Creating test project with chalk v5 dependency...');
+        const packageJson = {
+            name: 'diagnostic-test',
+            version: '1.0.0',
+            dependencies: {
+                'chalk': '^5.0.0',
+                'fraim-framework': `file:${tarballPath}`
+            }
+        };
+        fs_1.default.writeFileSync(path_1.default.join(tempDir, 'package.json'), JSON.stringify(packageJson, null, 2));
+        // 3. Install
+        console.log('📥 Running npm install...\n');
+        try {
+            const installOutput = (0, node_child_process_1.execSync)('npm install', {
+                cwd: tempDir,
+                encoding: 'utf-8',
+                stdio: 'pipe'
+            });
+            console.log('✅ Install completed\n');
+        }
+        catch (error) {
+            console.log('⚠️  Install had issues:\n', error.stdout || error.message);
+        }
+        // 4. Check what was installed
+        console.log('📋 Checking installed chalk versions...\n');
+        // Root chalk
+        const rootChalkPath = path_1.default.join(tempDir, 'node_modules', 'chalk', 'package.json');
+        if (fs_1.default.existsSync(rootChalkPath)) {
+            const pkg = JSON.parse(fs_1.default.readFileSync(rootChalkPath, 'utf-8'));
+            console.log(`  Root chalk: ${pkg.version}`);
+            console.log(`  Type: ${pkg.type || 'commonjs'}`);
+            console.log(`  Main: ${pkg.main || 'N/A'}`);
+            console.log(`  Exports: ${pkg.exports ? 'Yes' : 'No'}\n`);
+        }
+        else {
+            console.log('  ❌ No root chalk found\n');
+        }
+        // Fraim's chalk
+        const fraimChalkPath = path_1.default.join(tempDir, 'node_modules', 'fraim-framework', 'node_modules', 'chalk', 'package.json');
+        if (fs_1.default.existsSync(fraimChalkPath)) {
+            const pkg = JSON.parse(fs_1.default.readFileSync(fraimChalkPath, 'utf-8'));
+            console.log(`  fraim-framework's chalk: ${pkg.version}`);
+            console.log(`  Type: ${pkg.type || 'commonjs'}`);
+            console.log(`  Main: ${pkg.main || 'N/A'}\n`);
+        }
+        else {
+            console.log('  ℹ️  fraim-framework has no separate chalk (using root)\n');
+        }
+        // 5. Run npm ls to see the dependency tree
+        console.log('🌳 Dependency tree (npm ls chalk):\n');
+        try {
+            const lsOutput = (0, node_child_process_1.execSync)('npm ls chalk', {
+                cwd: tempDir,
+                encoding: 'utf-8'
+            });
+            console.log(lsOutput);
+        }
+        catch (error) {
+            console.log(error.stdout || error.message);
+        }
+        // 6. Check fraim-framework's package.json in node_modules
+        console.log('\n📋 fraim-framework\'s chalk dependency in node_modules:\n');
+        const fraimPkgPath = path_1.default.join(tempDir, 'node_modules', 'fraim-framework', 'package.json');
+        if (fs_1.default.existsSync(fraimPkgPath)) {
+            const fraimPkg = JSON.parse(fs_1.default.readFileSync(fraimPkgPath, 'utf-8'));
+            console.log(`  Chalk version in package.json: ${fraimPkg.dependencies?.chalk || 'N/A'}\n`);
+        }
+        // 7. Try to load fraim CLI
+        console.log('🚀 Testing fraim CLI load...\n');
+        const testScript = `
+try {
+    const fraimCli = require('./node_modules/fraim-framework/dist/src/cli/fraim.js');
+    console.log('✅ SUCCESS: fraim CLI loaded');
+} catch (error) {
+    console.log('❌ ERROR:', error.code || 'Unknown');
+    console.log('Message:', error.message.substring(0, 200));
+}
+`;
+        fs_1.default.writeFileSync(path_1.default.join(tempDir, 'test.js'), testScript);
+        try {
+            const testOutput = (0, node_child_process_1.execSync)('node test.js', {
+                cwd: tempDir,
+                encoding: 'utf-8'
+            });
+            console.log(testOutput);
+        }
+        catch (error) {
+            console.log(error.stdout || error.message);
+        }
+        // Cleanup
+        fs_1.default.unlinkSync(tarballPath);
+        console.log('\n✅ Diagnostic complete');
+    }
+    catch (error) {
+        console.error('\n❌ Diagnostic failed:', error);
+    }
+    finally {
+        try {
+            fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+        }
+        catch (e) {
+            console.log('\n⚠️  Could not clean up temp directory');
+        }
+    }
+}
+main();

package/dist/tests/test-session-rehydration.js

@@ -0,0 +1,145 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_child_process_1 = require("node:child_process");
+const axios_1 = __importDefault(require("axios"));
+const db_service_js_1 = require("../src/fraim/db-service.js");
+const test_utils_1 = require("./test-utils");
+const node_assert_1 = __importDefault(require("node:assert"));
+const tree_kill_1 = __importDefault(require("tree-kill"));
+const path_1 = __importDefault(require("path"));
+async function testRehydrationAndExemptions() {
+    console.log('   🚀 Testing Session Re-hydration and Initialization Exemptions...');
+    let fraimProcess;
+    let dbService;
+    const PORT = Math.floor(Math.random() * 1000) + 12000;
+    const TEST_API_KEY = 'test-rehydration-key';
+    const TEST_ADMIN_KEY = 'test-admin-key';
+    const BASE_URL = `http://localhost:${PORT}`;
+    const startServer = async () => {
+        console.log(`   Starting server on port ${PORT}...`);
+        const npxCommand = process.platform === 'win32' ? 'npx.cmd' : 'npx';
+        const serverScript = path_1.default.resolve(__dirname, '../src/fraim-mcp-server.ts');
+        const proc = (0, node_child_process_1.spawn)(npxCommand, ['tsx', `"${serverScript}"`], {
+            env: {
+                ...process.env,
+                FRAIM_MCP_PORT: PORT.toString(),
+                FRAIM_ADMIN_KEY: TEST_ADMIN_KEY,
+                FRAIM_SKIP_INDEX_ON_START: 'true'
+            },
+            stdio: 'inherit',
+            shell: true
+        });
+        let started = false;
+        for (let i = 0; i < 15; i++) {
+            try {
+                await axios_1.default.get(`${BASE_URL}/health`, { timeout: 500 });
+                started = true;
+                break;
+            }
+            catch (e) {
+                await new Promise(resolve => setTimeout(resolve, 1000));
+            }
+        }
+        if (!started)
+            throw new Error('Server failed to start');
+        return proc;
+    };
+    const stopServer = async (proc) => {
+        if (proc && proc.pid) {
+            await new Promise(resolve => (0, tree_kill_1.default)(proc.pid, 'SIGKILL', () => resolve()));
+        }
+    };
+    try {
+        // 1. Setup DB and Key
+        dbService = new db_service_js_1.FraimDbService();
+        await dbService.connect();
+        const db = dbService.db;
+        await db.collection('fraim_api_keys').deleteOne({ key: TEST_API_KEY });
+        await db.collection('fraim_telemetry_sessions').deleteMany({ userId: 'test-user-recalc' });
+        await db.collection('fraim_api_keys').insertOne({
+            key: TEST_API_KEY,
+            userId: 'test-user-recalc',
+            orgId: 'test-org',
+            isActive: true,
+            createdAt: new Date()
+        });
+        // 2. Start Server (Instance 1)
+        fraimProcess = await startServer();
+        // 3. Verify Initialization Exemptions
+        console.log('   Testing standard MCP exemptions (initialize, tools/list)...');
+        const initRes = await axios_1.default.post(`${BASE_URL}/mcp`, {
+            jsonrpc: '2.0', id: 1, method: 'initialize', params: {}
+        }, { headers: { 'x-api-key': TEST_API_KEY } });
+        node_assert_1.default.strictEqual(initRes.status, 200, 'initialize should be exempt');
+        const listRes = await axios_1.default.post(`${BASE_URL}/mcp`, {
+            jsonrpc: '2.0', id: 2, method: 'tools/list', params: {}
+        }, { headers: { 'x-api-key': TEST_API_KEY } });
+        node_assert_1.default.strictEqual(listRes.status, 200, 'tools/list should be exempt');
+        console.log('   Testing discovery tools exemptions (get_fraim_init)...');
+        const discoveryRes = await axios_1.default.post(`${BASE_URL}/mcp`, {
+            jsonrpc: '2.0', id: 3, method: 'tools/call',
+            params: { name: 'get_fraim_init', arguments: {} }
+        }, { headers: { 'x-api-key': TEST_API_KEY } });
+        node_assert_1.default.strictEqual(discoveryRes.status, 200, 'get_fraim_init should be exempt');
+        console.log('   ✅ Exemptions verified.');
+        // 4. Start Session
+        console.log('   Starting session...');
+        await axios_1.default.post(`${BASE_URL}/mcp`, {
+            jsonrpc: '2.0', id: 4, method: 'tools/call',
+            params: {
+                name: 'fraim_connect',
+                arguments: {
+                    machine: { hostname: 'repro-host' },
+                    repo: { url: 'http://github.com/repro' }
+                }
+            }
+        }, { headers: { 'x-api-key': TEST_API_KEY } });
+        // 5. Restart Server (Instance 2)
+        console.log('   ♻️ Swapping server instances (Simulating restart)...');
+        await stopServer(fraimProcess);
+        fraimProcess = await startServer();
+        // 6. Verify Re-hydration
+        console.log('   Checking if session re-hydrated from DB...');
+        const secureRes = await axios_1.default.post(`${BASE_URL}/mcp`, {
+            jsonrpc: '2.0', id: 5, method: 'tools/call',
+            params: { name: 'get_fraim_workflow', arguments: { workflow: 'test' } }
+        }, { headers: { 'x-api-key': TEST_API_KEY } });
+        node_assert_1.default.strictEqual(secureRes.status, 200, 'Request should be authorized via re-hydrated session');
+        console.log('   ✅ Re-hydration successful!');
+        return true;
+    }
+    catch (error) {
+        console.error('   ❌ Test failed:', error.message);
+        if (error.response?.data) {
+            console.error('   🔍 Server Error Detail:', JSON.stringify(error.response.data, null, 2));
+        }
+        return false;
+    }
+    finally {
+        if (dbService) {
+            const db = dbService.db;
+            await db.collection('fraim_api_keys').deleteOne({ key: TEST_API_KEY }).catch(() => { });
+            await db.collection('fraim_telemetry_sessions').deleteMany({ userId: 'test-user-recalc' }).catch(() => { });
+            await dbService.close();
+        }
+        if (fraimProcess)
+            await stopServer(fraimProcess);
+    }
+}
+const testCases = [
+    {
+        name: 'MCP Session Re-hydration and Initialization',
+        description: 'Verifies re-hydration from DB after restart and initialization exemptions',
+        testFunction: testRehydrationAndExemptions,
+        tags: ['session', 'rehydration']
+    }
+];
+(0, test_utils_1.runTests)(testCases, async (t) => t.testFunction(), 'Fraim Session System')
+    .then(() => process.exit(0))
+    .catch((err) => {
+    console.error('Test runner failed:', err);
+    process.exit(1);
+});

package/dist/tests/test-standalone.js

@@ -98,13 +98,7 @@ async function testServerStartsAndResponds() {
         });
         node_assert_1.default.strictEqual(mcpResponse.status, 200);
         node_assert_1.default.ok(mcpResponse.data.result.tools.length > 0);
-        // 7. Verify usage logging
-        console.log('   Verifying usage logging...');
-        await new Promise(resolve => setTimeout(resolve, 1500));
-        const log = await db.collection('fraim_usage_logs').findOne({ keyId: TEST_API_KEY });
-        node_assert_1.default.ok(log, 'Usage log should have been created');
-        node_assert_1.default.strictEqual(log.userId, 'test-user@ashley.ai');
-        // 8. Test Admin API - List Keys
+        // 7. Test Admin API - List Keys
         console.log('   Testing Admin API - List Keys...');
         const listKeysRes = await axios_1.default.get(`${BASE_URL}/admin/keys`, {
             headers: TEST_ADMIN_HEADER,
@@ -141,7 +135,7 @@ async function runFraimTest(testCase) {
 const testCases = [
     {
         name: 'Fraim Standalone Server Integration',
-        description: 'Tests server startup, public health check, authenticated MCP access, usage logging, and admin API',
+        description: 'Tests server startup, public health check, authenticated MCP access, and admin API',
         testFunction: testServerStartsAndResponds,
         tags: ['smoke', 'fraim']
     }

package/dist/tests/test-sync-version-update.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_child_process_1 = require("node:child_process");
+const test_utils_1 = require("./test-utils");
+const node_assert_1 = __importDefault(require("node:assert"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const version_utils_1 = require("../src/utils/version-utils");
+const types_1 = require("../src/fraim/types");
+async function testSyncUpdateVersion() {
+    console.log('   🚀 Testing "fraim sync" version update...');
+    // Create a temp directory for the test project
+    const tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'fraim-test-sync-'));
+    console.log(`   📂 Created temp dir: ${tempDir}`);
+    try {
+        const platform = process.platform;
+        const npx = platform === 'win32' ? 'npx.cmd' : 'npx';
+        const cliScript = path_1.default.resolve(__dirname, '../src/cli/fraim.ts');
+        // Setup .fraim/config.json with an OLD version
+        const fraimDir = path_1.default.join(tempDir, '.fraim');
+        fs_1.default.mkdirSync(fraimDir, { recursive: true });
+        const oldVersion = '0.0.0';
+        const initialConfig = {
+            ...types_1.DEFAULT_FRAIM_CONFIG,
+            version: oldVersion,
+            project: { name: 'test-project' },
+            git: { repoOwner: 'test', repoName: 'test' }
+        };
+        fs_1.default.writeFileSync(path_1.default.join(fraimDir, 'config.json'), JSON.stringify(initialConfig, null, 2));
+        // Create a fake registry so sync doesn't fail hard
+        const registryDir = path_1.default.join(tempDir, 'registry', 'workflows');
+        fs_1.default.mkdirSync(registryDir, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(registryDir, 'dummy.md'), '---\nintent: test\n---\n# Dummy');
+        // Helper to run CLI commands
+        const runFraim = (args) => {
+            return new Promise((resolve) => {
+                const ps = (0, node_child_process_1.spawn)(npx, ['tsx', `"${cliScript}"`, ...args], {
+                    cwd: tempDir,
+                    env: { ...process.env, TEST_MODE: 'true' },
+                    shell: true
+                });
+                let stdout = '';
+                let stderr = '';
+                ps.stdout.on('data', d => stdout += d.toString());
+                ps.stderr.on('data', d => stderr += d.toString());
+                ps.on('close', (code) => resolve({ stdout, stderr, code }));
+            });
+        };
+        // Run `fraim sync`
+        console.log('   Running "fraim sync"...');
+        const res = await runFraim(['sync']);
+        if (res.code !== 0) {
+            console.error('   ❌ Sync failed:', res.stderr);
+            return false;
+        }
+        // Verify config.json has the NEW/Current version
+        const updatedConfig = JSON.parse(fs_1.default.readFileSync(path_1.default.join(fraimDir, 'config.json'), 'utf-8'));
+        const currentPackageVersion = (0, version_utils_1.getFraimVersion)();
+        console.log(`   ℹ️  Old Version: ${oldVersion}`);
+        console.log(`   ℹ️  New Version in Config: ${updatedConfig.version}`);
+        console.log(`   ℹ️  Current Package Version: ${currentPackageVersion}`);
+        node_assert_1.default.strictEqual(updatedConfig.version, currentPackageVersion, 'Config version should match package version after sync');
+        node_assert_1.default.notStrictEqual(updatedConfig.version, oldVersion, 'Config version should have been updated from 0.0.0');
+        console.log('   ✅ Validated: Version was updated correctly.');
+        return true;
+    }
+    catch (error) {
+        console.error('   ❌ Test failed:', error);
+        return false;
+    }
+    finally {
+        try {
+            fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+        }
+        catch (e) { }
+    }
+}
+async function runTest(testCase) {
+    return await testCase.testFunction();
+}
+const testCases = [
+    {
+        name: 'Sync Version Update',
+        description: 'Verifies that fraim sync updates the version in config.json',
+        testFunction: testSyncUpdateVersion,
+        tags: ['cli', 'sync']
+    },
+];
+(0, test_utils_1.runTests)(testCases, runTest, 'Fraim Sync Update Tests');