@tenonhq/sincronia-core 0.0.72 → 0.0.74

package/dist/FileUtils.js

@@ -138,12 +138,20 @@ const getFileExtension = (filePath) => {
         return "";
     }
 };
-const getBuildExt = (table, recordName, field) => {
-    const manifest = ConfigManager.getManifest();
+const getBuildExt = (table, recordName, field, scope) => {
+    var manifest = ConfigManager.getManifest();
     if (!manifest) {
         throw new Error("Failed to retrieve manifest");
     }
-    const files = manifest.tables[table].records[recordName].files;
+    var resolvedManifest = manifest;
+    if (scope && ConfigManager.isMultiScopeManifest(manifest)) {
+        var scopeMan = ConfigManager.resolveManifestForScope(manifest, scope);
+        if (!scopeMan) {
+            throw new Error("Failed to find scope " + scope + " in manifest");
+        }
+        resolvedManifest = scopeMan;
+    }
+    const files = resolvedManifest.tables[table].records[recordName].files;
     const file = files.find((f) => f.name === field);
     if (!file) {
         throw new Error("Unable to find file");
@@ -163,11 +171,28 @@ const getFileContextFromPath = (filePath) => {
         .split(path_1.default.sep)
         .slice(-2);
     const targetField = getTargetFieldFromPath(filePath, tableName, ext);
-    const manifest = ConfigManager.getManifest();
+    var manifest = ConfigManager.getManifest();
     if (!manifest) {
         throw new Error("No manifest has been loaded!");
     }
-    const { tables, scope } = manifest;
+    var scope;
+    var tables;
+    if (ConfigManager.isMultiScopeManifest(manifest)) {
+        var detectedScope = ConfigManager.resolveScopeFromPath(filePath);
+        if (!detectedScope) {
+            return undefined;
+        }
+        var scopeMan = ConfigManager.resolveManifestForScope(manifest, detectedScope);
+        if (!scopeMan) {
+            return undefined;
+        }
+        scope = scopeMan.scope || detectedScope;
+        tables = scopeMan.tables;
+    }
+    else {
+        scope = manifest.scope;
+        tables = manifest.tables;
+    }
     try {
         const { records } = tables[tableName];
         const record = records[recordName];

package/dist/allScopesCommands.js

@@ -32,18 +32,23 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.initScopesCommand = initScopesCommand;
 exports.watchAllScopesCommand = watchAllScopesCommand;
 const Logger_1 = require("./Logger");
 const FileLogger_1 = require("./FileLogger");
 const ConfigManager = __importStar(require("./config"));
+const AppUtils = __importStar(require("./appUtils"));
 const wizard_1 = require("./wizard");
 const snClient_1 = require("./snClient");
 const commands_1 = require("./commands");
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
 const child_process_1 = require("child_process");
+const progress_1 = __importDefault(require("progress"));
 const fsp = fs.promises;
 // Custom function to process manifest with specific source directory
 async function processManifestForScope(manifest, sourceDirectory, forceWrite = false) {
@@ -58,7 +63,20 @@ async function processManifestForScope(manifest, sourceDirectory, forceWrite = f
         }
         const tables = manifest.tables || {};
         const tableNames = Object.keys(tables);
-        Logger_1.logger.info("Processing " + tableNames.length + " tables for " + sourceDirectory);
+        var totalRecords = 0;
+        for (var tn = 0; tn < tableNames.length; tn++) {
+            totalRecords += Object.keys(tables[tableNames[tn]].records || {}).length;
+        }
+        var scopeLabel = sourceDirectory.split(path.sep).pop() || "scope";
+        var progBar = null;
+        if (Logger_1.logger.getLogLevel() === "info" && totalRecords > 0) {
+            progBar = new progress_1.default(":scope :bar :current/:total (:percent)", {
+                total: totalRecords,
+                width: 40,
+                complete: "=",
+                incomplete: "-",
+            });
+        }
         for (const tableName of tableNames) {
             const tableRecords = tables[tableName];
             const tablePath = path.join(sourceDirectory, tableName);
@@ -102,9 +120,10 @@ async function processManifestForScope(manifest, sourceDirectory, forceWrite = f
                         Logger_1.logger.error("Failed to write metadata: " + metadataFilePath);
                     }
                 }
+                if (progBar)
+                    progBar.tick({ scope: scopeLabel });
             }
         }
-        Logger_1.logger.info("Files written to " + sourceDirectory);
     }
     catch (error) {
         Logger_1.logger.error("Error processing files for " + sourceDirectory + ": " + error);
@@ -175,6 +194,8 @@ async function processScope(scopeName, scopeConfig, apiDelay = 0) {
         else {
             Logger_1.logger.warn("No _tables whitelist defined — writing ALL tables for " + scopeName);
         }
+        // Normalize record keys from sys_id to display name
+        AppUtils.normalizeManifestKeys(manifest);
         // Build the missing files structure from the filtered manifest
         var manifestTables = manifest.tables || {};
         var allMissingFiles = {};
@@ -340,7 +361,7 @@ async function watchAllScopesCommand(args) {
         }
         // Start dashboard unless --no-dashboard flag is set
         if (!args.noDashboard) {
-            dashboardProcess = startDashboardProcess();
+            dashboardProcess = startDashboardProcess(args.port);
         }
         // Import and start the multi-scope watcher
         const { startMultiScopeWatching } = await Promise.resolve().then(() => __importStar(require("./MultiScopeWatcher")));
@@ -365,7 +386,7 @@ async function watchAllScopesCommand(args) {
         throw error;
     }
 }
-function startDashboardProcess() {
+function startDashboardProcess(portOverride) {
     var serverPath;
     try {
         serverPath = require.resolve("@tenonhq/sincronia-dashboard/server.js");
@@ -374,11 +395,11 @@ function startDashboardProcess() {
         Logger_1.logger.warn("Dashboard package not installed. Run: npm install @tenonhq/sincronia-dashboard");
         return null;
     }
-    var port = process.env.DASHBOARD_PORT || "3456";
+    var port = portOverride ? String(portOverride) : (process.env.DASHBOARD_PORT || "3456");
     var server = (0, child_process_1.spawn)("node", [serverPath], {
         cwd: process.cwd(),
         stdio: "ignore",
-        env: { ...process.env },
+        env: { ...process.env, DASHBOARD_PORT: port },
         detached: false,
     });
     server.on("error", function (err) {

package/dist/appUtils.js

@@ -36,7 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkScope = exports.createAndAssignUpdateSet = exports.swapScope = exports.buildFiles = exports.summarizeRecord = exports.pushFiles = exports.getAppFileList = exports.groupAppFiles = exports.processMissingFiles = exports.findMissingFiles = exports.syncManifest = exports.processManifest = void 0;
+exports.createAndAssignUpdateSet = exports.swapScope = exports.buildFiles = exports.summarizeRecord = exports.pushFiles = exports.getAppFileList = exports.groupAppFiles = exports.processMissingFiles = exports.findMissingFiles = exports.syncManifest = exports.processManifest = exports.normalizeManifestKeys = void 0;
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const progress_1 = __importDefault(require("progress"));
@@ -72,10 +72,7 @@ const processFilesInManRec = async (recPath, rec, forceWrite) => {
         }, null, 2)
     };
     await fileWrite(metadataFile, recPath);
-    const regularPromises = rec.files.map((file) => {
-        return fileWrite(file, recPath);
-    });
-    const writeResults = await Promise.allSettled(regularPromises);
+    const writeResults = await (0, genericUtils_1.allSettledBatched)(rec.files, constants_1.CONCURRENCY_FILES, function (file) { return fileWrite(file, recPath); });
     const writeFailures = writeResults.filter((r) => r.status === "rejected");
     if (writeFailures.length > 0) {
         writeFailures.forEach((f) => {
@@ -89,7 +86,7 @@ const processFilesInManRec = async (recPath, rec, forceWrite) => {
         return fileCopy;
     });
 };
-const processRecsInManTable = async (tablePath, table, forceWrite) => {
+const processRecsInManTable = async (tablePath, table, forceWrite, onRecordProcessed) => {
     const { records } = table;
     const recKeys = Object.keys(records);
     const recKeyToPath = (key) => path_1.default.join(tablePath, records[key].name);
@@ -97,26 +94,62 @@ const processRecsInManTable = async (tablePath, table, forceWrite) => {
         .map(recKeyToPath)
         .map(fUtils.createDirRecursively);
     await Promise.all(recPathPromises);
-    const filePromises = recKeys.reduce((acc, recKey) => {
-        return [
-            ...acc,
-            processFilesInManRec(recKeyToPath(recKey), records[recKey], forceWrite),
-        ];
-    }, []);
-    return Promise.all(filePromises);
+    await (0, genericUtils_1.processBatched)(recKeys, constants_1.CONCURRENCY_RECORDS, function (recKey) {
+        return processFilesInManRec(recKeyToPath(recKey), records[recKey], forceWrite).then(function () {
+            if (onRecordProcessed)
+                onRecordProcessed();
+        });
+    });
 };
-const processTablesInManifest = async (tables, forceWrite, sourcePath) => {
+const countRecordsInTables = (tables) => {
+    return Object.keys(tables).reduce(function (sum, tableName) {
+        return sum + Object.keys(tables[tableName].records).length;
+    }, 0);
+};
+const processTablesInManifest = async (tables, forceWrite, sourcePath, onRecordProcessed) => {
     var basePath = sourcePath || ConfigManager.getSourcePath();
     const tableNames = Object.keys(tables);
-    const tablePromises = tableNames.map((tableName) => {
-        return processRecsInManTable(path_1.default.join(basePath, tableName), tables[tableName], forceWrite);
+    await (0, genericUtils_1.processBatched)(tableNames, constants_1.CONCURRENCY_TABLES, function (tableName) {
+        return processRecsInManTable(path_1.default.join(basePath, tableName), tables[tableName], forceWrite, onRecordProcessed);
     });
-    await Promise.all(tablePromises);
 };
+/**
+ * Re-keys manifest records from sys_id to record.name (display value).
+ * Some ServiceNow tables return records keyed by sys_id instead of display name.
+ * This ensures consistent naming for directories and manifest lookups.
+ */
+const normalizeManifestKeys = (manifest) => {
+    var tables = manifest.tables || {};
+    var tableNames = Object.keys(tables);
+    for (var i = 0; i < tableNames.length; i++) {
+        var tableName = tableNames[i];
+        var records = tables[tableName].records || {};
+        var recordKeys = Object.keys(records);
+        var normalized = {};
+        for (var j = 0; j < recordKeys.length; j++) {
+            var key = recordKeys[j];
+            var record = records[key];
+            var displayKey = record.name || key;
+            // Handle duplicate display names by appending sys_id suffix
+            if (normalized[displayKey]) {
+                displayKey = displayKey + " (" + record.sys_id.substring(0, 8) + ")";
+            }
+            normalized[displayKey] = record;
+        }
+        tables[tableName].records = normalized;
+    }
+    return manifest;
+};
+exports.normalizeManifestKeys = normalizeManifestKeys;
 const processManifest = async (manifest, forceWrite = false, sourcePath) => {
     const tableCount = Object.keys(manifest.tables).length;
     FileLogger_1.fileLogger.debug("Processing manifest: " + (manifest.scope || "legacy") + " (" + tableCount + " tables)");
-    await processTablesInManifest(manifest.tables, forceWrite, sourcePath);
+    var recordCount = countRecordsInTables(manifest.tables);
+    var progress = createScopeProgress(Logger_1.logger.getLogLevel(), {
+        scope: manifest.scope || "default",
+        total: recordCount,
+    });
+    await processTablesInManifest(manifest.tables, forceWrite, sourcePath, progress.tick);
     if (manifest.scope) {
         await fUtils.writeScopeManifest(manifest.scope, manifest);
     }
@@ -137,20 +170,20 @@ const syncManifest = async (scope) => {
             const config = ConfigManager.getConfig();
             // Resolve scope-specific source directory
             var scopeSourcePath = ConfigManager.getSourcePathForScope(scope);
-            const newManifest = await (0, snClient_1.unwrapSNResponse)(client.getManifest(scope, config));
+            const newManifest = (0, exports.normalizeManifestKeys)(await (0, snClient_1.unwrapSNResponse)(client.getManifest(scope, config)));
             const refreshTableCount = Object.keys(newManifest.tables).length;
             FileLogger_1.fileLogger.debug("Refreshed manifest for " + scope + ": " + refreshTableCount + " tables");
             await fUtils.writeScopeManifest(scope, newManifest);
             await (0, exports.processMissingFiles)(newManifest, scopeSourcePath);
             // Update the in-memory manifest for this scope
-            if (typeof curManifest === "object" && !curManifest.tables) {
+            if (ConfigManager.isMultiScopeManifest(curManifest)) {
                 curManifest[scope] = newManifest;
                 ConfigManager.updateManifest(curManifest);
             }
         }
         else {
             // Sync all scopes if manifest has multiple scopes
-            if (typeof curManifest === "object" && !curManifest.tables) {
+            if (ConfigManager.isMultiScopeManifest(curManifest)) {
                 // Multiple scopes detected
                 for (const scopeName of Object.keys(curManifest)) {
                     await (0, exports.syncManifest)(scopeName);
@@ -245,13 +278,18 @@ const processMissingFiles = async (newManifest, sourcePath) => {
     try {
         const missing = await (0, exports.findMissingFiles)(newManifest, sourcePath);
         const missingTableCount = Object.keys(missing).length;
-        if (missingTableCount > 0) {
-            FileLogger_1.fileLogger.debug("Downloading missing files from " + missingTableCount + " tables");
-        }
+        if (missingTableCount === 0)
+            return;
+        FileLogger_1.fileLogger.debug("Downloading missing files from " + missingTableCount + " tables");
         const { tableOptions = {} } = ConfigManager.getConfig();
         const client = (0, snClient_1.defaultClient)();
         const filesToProcess = await (0, snClient_1.unwrapSNResponse)(client.getMissingFiles(missing, tableOptions));
-        await processTablesInManifest(filesToProcess, false, sourcePath);
+        var recordCount = countRecordsInTables(filesToProcess);
+        var progress = createScopeProgress(Logger_1.logger.getLogLevel(), {
+            scope: newManifest.scope || "default",
+            total: recordCount,
+        });
+        await processTablesInManifest(filesToProcess, false, sourcePath, progress.tick);
     }
     catch (e) {
         throw e;
@@ -349,7 +387,7 @@ const pushFiles = async (recs) => {
         Logger_1.logger.info(`Update set routing active: ${activeScopes}`);
     }
     const tick = getProgTick(Logger_1.logger.getLogLevel(), recs.length * 2) || (() => { });
-    const pushResultPromises = recs.map(async (rec) => {
+    const results = await (0, genericUtils_1.allSettledBatched)(recs, constants_1.CONCURRENCY_PUSH, async function (rec) {
         const fieldNames = Object.keys(rec.fields);
         const firstField = rec.fields[fieldNames[0]];
         const recSummary = (0, exports.summarizeRecord)(rec.table, firstField.name);
@@ -364,8 +402,7 @@ const pushFiles = async (recs) => {
         tick();
         return pushRes;
     });
-    const results = await Promise.allSettled(pushResultPromises);
-    return results.map((result) => {
+    return results.map(function (result) {
         if (result.status === "fulfilled") {
             return result.value;
         }
@@ -375,6 +412,25 @@ const pushFiles = async (recs) => {
 exports.pushFiles = pushFiles;
 const summarizeRecord = (table, recDescriptor) => `${table} > ${recDescriptor}`;
 exports.summarizeRecord = summarizeRecord;
+const createScopeProgress = (logLevel, options) => {
+    if (logLevel !== "info" || options.total === 0) {
+        return { tick: function () { }, setTotal: function () { } };
+    }
+    var progBar = new progress_1.default(":scope :bar :current/:total (:percent)", {
+        total: options.total,
+        width: 40,
+        complete: "=",
+        incomplete: "-",
+    });
+    return {
+        tick: function () {
+            progBar.tick({ scope: options.scope });
+        },
+        setTotal: function (n) {
+            progBar.total = n;
+        },
+    };
+};
 const getProgTick = (logLevel, total) => {
     if (logLevel === "info") {
         const progBar = new progress_1.default(":bar (:percent)", {
@@ -399,7 +455,7 @@ const writeBuildFile = async (preBuild, buildRes, summary) => {
         const srcFilePath = fieldCtx.filePath;
         const relativePath = path_1.default.relative(sourcePath, srcFilePath);
         const relPathNoExt = relativePath.split(".").slice(0, -1).join();
-        const buildExt = fUtils.getBuildExt(fieldCtx.tableName, fieldCtx.name, fieldCtx.targetField);
+        const buildExt = fUtils.getBuildExt(fieldCtx.tableName, fieldCtx.name, fieldCtx.targetField, fieldCtx.scope);
         const relPathNewExt = `${relPathNoExt}.${buildExt}`;
         const buildFilePath = path_1.default.join(buildPath, relPathNewExt);
         await fUtils.createDirRecursively(path_1.default.dirname(buildFilePath));
@@ -407,7 +463,17 @@ const writeBuildFile = async (preBuild, buildRes, summary) => {
         return writeResult;
     });
     try {
-        await Promise.all(writePromises);
+        await (0, genericUtils_1.processBatched)(fieldNames, constants_1.CONCURRENCY_FILES, async function (field) {
+            const fieldCtx = fields[field];
+            const srcFilePath = fieldCtx.filePath;
+            const relativePath = path_1.default.relative(sourcePath, srcFilePath);
+            const relPathNoExt = relativePath.split(".").slice(0, -1).join();
+            const buildExt = fUtils.getBuildExt(fieldCtx.tableName, fieldCtx.name, fieldCtx.targetField);
+            const relPathNewExt = `${relPathNoExt}.${buildExt}`;
+            const buildFilePath = path_1.default.join(buildPath, relPathNewExt);
+            await fUtils.createDirRecursively(path_1.default.dirname(buildFilePath));
+            await fUtils.writeFileForce(buildFilePath, buildRes.builtRec[fieldCtx.targetField]);
+        });
         return { success: true, message: `${recSummary} built successfully` };
     }
     catch (e) {
@@ -419,7 +485,7 @@ const writeBuildFile = async (preBuild, buildRes, summary) => {
 };
 const buildFiles = async (fileList) => {
     const tick = getProgTick(Logger_1.logger.getLogLevel(), fileList.length * 2) || (() => { });
-    const buildPromises = fileList.map(async (rec) => {
+    const results = await (0, genericUtils_1.allSettledBatched)(fileList, constants_1.CONCURRENCY_BUILD, async function (rec) {
         const { fields, table } = rec;
         const fieldNames = Object.keys(fields);
         const recSummary = (0, exports.summarizeRecord)(table, fields[fieldNames[0]].name);
@@ -434,8 +500,7 @@ const buildFiles = async (fileList) => {
         tick();
         return writeRes;
     });
-    const results = await Promise.allSettled(buildPromises);
-    return results.map((result) => {
+    return results.map(function (result) {
         if (result.status === "fulfilled") {
             return result.value;
         }
@@ -507,92 +572,3 @@ const createAndAssignUpdateSet = async (updateSetName = "", scope) => {
     };
 };
 exports.createAndAssignUpdateSet = createAndAssignUpdateSet;
-const checkScope = async (swap) => {
-    try {
-        const man = ConfigManager.getManifest();
-        if (man) {
-            // Detect multi-scope manifest (keys are scope names, no top-level .scope)
-            var isMultiScope = typeof man === "object" && !man.scope && !man.tables;
-            if (isMultiScope) {
-                // Multi-scope: session scope just needs to match any configured scope
-                var configuredScopes = Object.keys(man);
-                var client = (0, snClient_1.defaultClient)();
-                var scopeObj;
-                try {
-                    scopeObj = await (0, snClient_1.unwrapSNResponse)(client.getCurrentScope());
-                }
-                catch (scopeErr) {
-                    Logger_1.logger.info("Scope check endpoint unavailable, assuming match for multi-scope project");
-                    return { match: true, sessionScope: configuredScopes[0], manifestScope: configuredScopes[0] };
-                }
-                var sessionScope = scopeObj.scope;
-                var scopeMatch = configuredScopes.indexOf(sessionScope) !== -1;
-                Logger_1.logger.info("Current scope: " + sessionScope + ", Configured scopes: " + configuredScopes.join(", "));
-                if (scopeMatch) {
-                    return { match: true, sessionScope: sessionScope, manifestScope: sessionScope };
-                }
-                else if (swap && configuredScopes.length > 0) {
-                    Logger_1.logger.info("Current scope (" + sessionScope + ") not in configured scopes. Swapping to " + configuredScopes[0] + "...\n");
-                    var swappedScopeObj = await (0, exports.swapScope)(configuredScopes[0]);
-                    return {
-                        match: configuredScopes.indexOf(swappedScopeObj.scope) !== -1,
-                        sessionScope: swappedScopeObj.scope,
-                        manifestScope: configuredScopes[0],
-                    };
-                }
-                else {
-                    return { match: false, sessionScope: sessionScope, manifestScope: configuredScopes.join(", ") };
-                }
-            }
-            // Single-scope manifest
-            var singleClient = (0, snClient_1.defaultClient)();
-            var singleScopeObj;
-            try {
-                singleScopeObj = await (0, snClient_1.unwrapSNResponse)(singleClient.getCurrentScope());
-            }
-            catch (scopeErr) {
-                // getCurrentScope endpoint may not exist on this instance — skip scope check
-                Logger_1.logger.info(`Scope check endpoint unavailable, assuming scope match for: ${man.scope}`);
-                return {
-                    match: true,
-                    sessionScope: man.scope,
-                    manifestScope: man.scope,
-                };
-            }
-            Logger_1.logger.info(`Current scope: ${singleScopeObj.scope}, Manifest scope: ${man.scope}`);
-            if (singleScopeObj.scope === man.scope) {
-                return {
-                    match: true,
-                    sessionScope: singleScopeObj.scope,
-                    manifestScope: man.scope,
-                };
-            }
-            else if (swap) {
-                Logger_1.logger.info(`Current scope (${singleScopeObj.scope}) does not match manifest scope (${man.scope}). Swapping...\n`);
-                var singleSwapped = await (0, exports.swapScope)(man.scope);
-                return {
-                    match: singleSwapped.scope === man.scope,
-                    sessionScope: singleSwapped.scope,
-                    manifestScope: man.scope,
-                };
-            }
-            else {
-                return {
-                    match: false,
-                    sessionScope: singleScopeObj.scope,
-                    manifestScope: man.scope,
-                };
-            }
-        }
-        //first time case
-        return {
-            match: true,
-            sessionScope: "",
-            manifestScope: "",
-        };
-    }
-    catch (e) {
-        throw e;
-    }
-};
-exports.checkScope = checkScope;

package/dist/commander.js

@@ -30,6 +30,11 @@ async function initCommands() {
                 default: false,
                 describe: "Skip launching the dashboard web UI",
             },
+            port: {
+                alias: "p",
+                type: "number",
+                describe: "Dashboard port (default: DASHBOARD_PORT env or 3456)",
+            },
         });
         return cmdArgs;
     }, async (args) => {
@@ -45,12 +50,6 @@ async function initCommands() {
                 default: "",
                 describe: "Specify branch to do git diff against",
             },
-            scopeSwap: {
-                alias: "ss",
-                type: "boolean",
-                default: false,
-                describe: "Will auto-swap to the correct scope for the files being pushed",
-            },
             updateSet: {
                 alias: "us",
                 type: "string",
@@ -286,7 +285,19 @@ async function initCommands() {
         });
         return cmdArgs;
     }, updateSetCommands_1.showCurrentScopeCommand)
-        .command("dashboard", "Launch the Update Set Dashboard web UI", sharedOptions, dashboardCommand_1.dashboardCommand)
+        .command("dashboard", "Launch the Update Set Dashboard web UI", (cmdArgs) => {
+        cmdArgs.options({
+            ...sharedOptions,
+            port: {
+                alias: "p",
+                type: "number",
+                describe: "Dashboard port (default: DASHBOARD_PORT env or 3456)",
+            },
+        });
+        return cmdArgs;
+    }, async (args) => {
+        await (0, dashboardCommand_1.dashboardCommand)(args);
+    })
         .command("schema <subcommand>", "Manage ServiceNow table schemas (subcommands: pull)", (cmdArgs) => {
         cmdArgs.positional("subcommand", {
             describe: "Schema subcommand to run",

package/dist/commands.js

@@ -37,7 +37,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setLogLevel = setLogLevel;
-exports.devCommand = devCommand;
 exports.refreshCommand = refreshCommand;
 exports.pushCommand = pushCommand;
 exports.downloadCommand = downloadCommand;
@@ -46,7 +45,6 @@ exports.buildCommand = buildCommand;
 exports.deployCommand = deployCommand;
 exports.statusCommand = statusCommand;
 const ConfigManager = __importStar(require("./config"));
-const Watcher_1 = require("./Watcher");
 const AppUtils = __importStar(require("./appUtils"));
 const orchestrator_1 = require("./initSystem/orchestrator");
 const Logger_1 = require("./Logger");
@@ -56,135 +54,108 @@ const snClient_1 = require("./snClient");
 const inquirer_1 = __importDefault(require("inquirer"));
 const gitUtils_1 = require("./gitUtils");
 const FileUtils_1 = require("./FileUtils");
-async function scopeCheck(successFunc, swapScopes = false) {
+function setLogLevel(args) {
+    Logger_1.logger.setLogLevel(args.logLevel);
+}
+async function refreshCommand(args, log = true) {
+    setLogLevel(args);
     try {
-        const scopeCheck = await AppUtils.checkScope(swapScopes);
-        if (!scopeCheck.match) {
-            (0, logMessages_1.scopeCheckMessage)(scopeCheck);
-            // Throw exception to register this as an error
-            throw new Error();
-        }
-        else {
-            await successFunc();
-        }
+        if (!log)
+            setLogLevel({ logLevel: "warn" });
+        FileLogger_1.fileLogger.debug("Syncing manifest from instance");
+        await AppUtils.syncManifest();
+        Logger_1.logger.success("Refresh complete!");
+        setLogLevel(args);
     }
     catch (e) {
-        Logger_1.logger.error("Scope check failed. Verify your project configuration or run `npx sinc init`");
-        // Throw exception to register this as an error
-        process.exit(1);
+        throw e;
     }
 }
-function setLogLevel(args) {
-    Logger_1.logger.setLogLevel(args.logLevel);
-}
-async function devCommand(args) {
+async function pushCommand(args) {
     setLogLevel(args);
-    await scopeCheck(async () => {
-        (0, Watcher_1.startWatching)(ConfigManager.getSourcePath());
-        (0, logMessages_1.devModeLog)();
-        let refresher = () => {
-            refreshCommand(args, false);
-        };
-        let interval = ConfigManager.getRefresh();
-        if (interval && interval > 0) {
-            Logger_1.logger.info(`Checking for new manifest files every ${interval} seconds`);
-            setInterval(refresher, interval * 1000);
+    try {
+        const { updateSet, ci: skipPrompt, target, diff } = args;
+        let encodedPaths;
+        if (target !== undefined && target !== "")
+            encodedPaths = target;
+        else
+            encodedPaths = await (0, gitUtils_1.gitDiffToEncodedPaths)(diff);
+        const fileList = await AppUtils.getAppFileList(encodedPaths);
+        const instance = process.env.SN_INSTANCE || "unknown";
+        Logger_1.logger.info(fileList.length + " files to push to " + instance);
+        if (!skipPrompt) {
+            const targetServer = process.env.SN_INSTANCE;
+            if (!targetServer) {
+                Logger_1.logger.error("No SN_INSTANCE configured. Set it in your .env file.");
+                return;
+            }
+            const answers = await inquirer_1.default.prompt([
+                {
+                    type: "confirm",
+                    name: "confirmed",
+                    message: "Pushing will overwrite code in your instance. Are you sure?",
+                    default: false,
+                },
+            ]);
+            if (!answers["confirmed"])
+                return;
         }
-    });
-}
-async function refreshCommand(args, log = true) {
-    setLogLevel(args);
-    await scopeCheck(async () => {
-        try {
-            if (!log)
-                setLogLevel({ logLevel: "warn" });
-            FileLogger_1.fileLogger.debug("Syncing manifest from instance");
-            await AppUtils.syncManifest();
-            Logger_1.logger.success("Refresh complete!");
-            setLogLevel(args);
+        // Handle --clickup flag: resolve ClickUp task into an update set name
+        let resolvedUpdateSet = updateSet;
+        if (!resolvedUpdateSet && args.clickup) {
+            try {
+                const { resolveClickUpForPush } = await Promise.resolve().then(() => __importStar(require("./clickupPushHelper")));
+                resolvedUpdateSet = await resolveClickUpForPush(args.clickup);
+            }
+            catch (cuErr) {
+                if (cuErr instanceof Error)
+                    Logger_1.logger.error(cuErr.message);
+                process.exit(1);
+            }
         }
-        catch (e) {
-            throw e;
+        // Extract scope from file list and auto-swap to it
+        var pushScope;
+        if (fileList.length > 0) {
+            var fieldKeys = Object.keys(fileList[0].fields);
+            if (fieldKeys.length > 0) {
+                pushScope = fileList[0].fields[fieldKeys[0]].scope;
+            }
         }
-    });
-}
-async function pushCommand(args) {
-    setLogLevel(args);
-    await scopeCheck(async () => {
-        try {
-            const { updateSet, ci: skipPrompt, target, diff } = args;
-            let encodedPaths;
-            if (target !== undefined && target !== "")
-                encodedPaths = target;
-            else
-                encodedPaths = await (0, gitUtils_1.gitDiffToEncodedPaths)(diff);
-            const fileList = await AppUtils.getAppFileList(encodedPaths);
-            const instance = process.env.SN_INSTANCE || "unknown";
-            Logger_1.logger.info(fileList.length + " files to push to " + instance);
+        if (pushScope) {
+            try {
+                var client = (0, snClient_1.defaultClient)();
+                await client.changeScope(pushScope);
+                Logger_1.logger.info("Switched to scope: " + pushScope);
+            }
+            catch (scopeErr) {
+                Logger_1.logger.warn("Could not auto-switch scope: " + scopeErr);
+            }
+        }
+        // Does not create update set if updateSetName is blank
+        if (resolvedUpdateSet) {
             if (!skipPrompt) {
-                const targetServer = process.env.SN_INSTANCE;
-                if (!targetServer) {
-                    Logger_1.logger.error("No SN_INSTANCE configured. Set it in your .env file.");
-                    return;
-                }
-                const answers = await inquirer_1.default.prompt([
+                let answers = await inquirer_1.default.prompt([
                     {
                         type: "confirm",
                         name: "confirmed",
-                        message: "Pushing will overwrite code in your instance. Are you sure?",
+                        message: `A new Update Set "${resolvedUpdateSet}" will be created for these pushed changes. Do you want to proceed?`,
                         default: false,
                     },
                 ]);
-                if (!answers["confirmed"])
-                    return;
-            }
-            // Handle --clickup flag: resolve ClickUp task into an update set name
-            let resolvedUpdateSet = updateSet;
-            if (!resolvedUpdateSet && args.clickup) {
-                try {
-                    const { resolveClickUpForPush } = await Promise.resolve().then(() => __importStar(require("./clickupPushHelper")));
-                    resolvedUpdateSet = await resolveClickUpForPush(args.clickup);
-                }
-                catch (cuErr) {
-                    if (cuErr instanceof Error)
-                        Logger_1.logger.error(cuErr.message);
-                    process.exit(1);
+                if (!answers["confirmed"]) {
+                    process.exit(0);
                 }
             }
-            // Extract scope from file list for update set creation
-            var pushScope;
-            if (fileList.length > 0) {
-                var fieldKeys = Object.keys(fileList[0].fields);
-                if (fieldKeys.length > 0) {
-                    pushScope = fileList[0].fields[fieldKeys[0]].scope;
-                }
-            }
-            // Does not create update set if updateSetName is blank
-            if (resolvedUpdateSet) {
-                if (!skipPrompt) {
-                    let answers = await inquirer_1.default.prompt([
-                        {
-                            type: "confirm",
-                            name: "confirmed",
-                            message: `A new Update Set "${resolvedUpdateSet}" will be created for these pushed changes. Do you want to proceed?`,
-                            default: false,
-                        },
-                    ]);
-                    if (!answers["confirmed"]) {
-                        process.exit(0);
-                    }
-                }
-                const newUpdateSet = await AppUtils.createAndAssignUpdateSet(resolvedUpdateSet, pushScope);
-                Logger_1.logger.debug(`New Update Set Created(${newUpdateSet.name}) sys_id:${newUpdateSet.id}`);
-            }
-            const pushResults = await AppUtils.pushFiles(fileList);
-            (0, logMessages_1.logPushResults)(pushResults);
-        }
-        catch (e) {
-            Logger_1.logger.getInternalLogger().error(e);
-            process.exit(1);
+            const newUpdateSet = await AppUtils.createAndAssignUpdateSet(resolvedUpdateSet, pushScope);
+            Logger_1.logger.debug(`New Update Set Created(${newUpdateSet.name}) sys_id:${newUpdateSet.id}`);
         }
-    }, args.scopeSwap);
+        const pushResults = await AppUtils.pushFiles(fileList);
+        (0, logMessages_1.logPushResults)(pushResults);
+    }
+    catch (e) {
+        Logger_1.logger.getInternalLogger().error(e);
+        process.exit(1);
+    }
 }
 async function downloadCommand(args) {
     setLogLevel(args);
@@ -233,7 +204,6 @@ async function downloadCommand(args) {
         });
         Logger_1.logger.info("Received " + tableCount + " tables, " + recordCount + " records");
         FileLogger_1.fileLogger.debug("Download manifest: " + tableCount + " tables, " + recordCount + " records");
-        Logger_1.logger.info("Writing files to disk...");
         await AppUtils.processManifest(man, true);
         Logger_1.logger.success("Download complete — " + recordCount + " records written");
     }
@@ -285,43 +255,72 @@ async function getDeployPaths() {
 }
 async function deployCommand(args) {
     setLogLevel(args);
-    await scopeCheck(async () => {
-        try {
-            const targetServer = process.env.SN_INSTANCE || "";
-            if (!targetServer) {
-                Logger_1.logger.error("No SN_INSTANCE configured. Set it in your .env file.");
-                return;
-            }
-            const { confirmed } = await inquirer_1.default.prompt([
-                {
-                    type: "confirm",
-                    name: "confirmed",
-                    message: "Deploying will overwrite code in your instance. Are you sure?",
-                    default: false,
-                },
-            ]);
-            if (!confirmed) {
-                return;
-            }
-            const paths = await getDeployPaths();
-            Logger_1.logger.silly(`${paths.length} paths found...`);
-            Logger_1.logger.silly(JSON.stringify(paths, null, 2));
-            const appFileList = await AppUtils.getAppFileList(paths);
-            const pushResults = await AppUtils.pushFiles(appFileList);
-            (0, logMessages_1.logPushResults)(pushResults);
+    try {
+        const targetServer = process.env.SN_INSTANCE || "";
+        if (!targetServer) {
+            Logger_1.logger.error("No SN_INSTANCE configured. Set it in your .env file.");
+            return;
         }
-        catch (e) {
-            throw e;
+        const { confirmed } = await inquirer_1.default.prompt([
+            {
+                type: "confirm",
+                name: "confirmed",
+                message: "Deploying will overwrite code in your instance. Are you sure?",
+                default: false,
+            },
+        ]);
+        if (!confirmed) {
+            return;
         }
-    });
+        const paths = await getDeployPaths();
+        Logger_1.logger.silly(`${paths.length} paths found...`);
+        Logger_1.logger.silly(JSON.stringify(paths, null, 2));
+        const appFileList = await AppUtils.getAppFileList(paths);
+        // Auto-swap to scope detected from files
+        if (appFileList.length > 0) {
+            var fieldKeys = Object.keys(appFileList[0].fields);
+            if (fieldKeys.length > 0) {
+                var deployScope = appFileList[0].fields[fieldKeys[0]].scope;
+                if (deployScope) {
+                    try {
+                        var client = (0, snClient_1.defaultClient)();
+                        await client.changeScope(deployScope);
+                        Logger_1.logger.info("Switched to scope: " + deployScope);
+                    }
+                    catch (scopeErr) {
+                        Logger_1.logger.warn("Could not auto-switch scope: " + scopeErr);
+                    }
+                }
+            }
+        }
+        const pushResults = await AppUtils.pushFiles(appFileList);
+        (0, logMessages_1.logPushResults)(pushResults);
+    }
+    catch (e) {
+        throw e;
+    }
 }
 async function statusCommand() {
     try {
         const client = (0, snClient_1.defaultClient)();
+        var config = ConfigManager.getConfig();
         let scopeObj = await (0, snClient_1.unwrapSNResponse)(client.getCurrentScope());
-        Logger_1.logger.info("Instance:  " + (process.env.SN_INSTANCE || "not set"));
-        Logger_1.logger.info("Scope:     " + scopeObj.scope);
-        Logger_1.logger.info("User:      " + (process.env.SN_USER || "not set"));
+        Logger_1.logger.info("Instance:      " + (process.env.SN_INSTANCE || "not set"));
+        Logger_1.logger.info("User:          " + (process.env.SN_USER || "not set"));
+        Logger_1.logger.info("Active scope:  " + scopeObj.scope);
+        if (config.scopes) {
+            var scopeNames = Object.keys(config.scopes);
+            Logger_1.logger.info("\nConfigured scopes (" + scopeNames.length + "):");
+            for (var i = 0; i < scopeNames.length; i++) {
+                var scopeName = scopeNames[i];
+                var scopeConf = config.scopes[scopeName];
+                var srcDir = (typeof scopeConf === "object" && scopeConf.sourceDirectory)
+                    ? scopeConf.sourceDirectory
+                    : "src/" + scopeName;
+                var marker = scopeName === scopeObj.scope ? " (active)" : "";
+                Logger_1.logger.info("  " + scopeName + marker + " — " + srcDir);
+            }
+        }
     }
     catch (e) {
         throw e;

package/dist/config.js

@@ -54,6 +54,9 @@ exports.getRefresh = getRefresh;
 exports.getDefaultConfigFile = getDefaultConfigFile;
 exports.loadScopeManifest = loadScopeManifest;
 exports.updateManifest = updateManifest;
+exports.isMultiScopeManifest = isMultiScopeManifest;
+exports.resolveManifestForScope = resolveManifestForScope;
+exports.resolveScopeFromPath = resolveScopeFromPath;
 exports.isDirectiveKey = isDirectiveKey;
 exports.stripDirectiveKeys = stripDirectiveKeys;
 exports.resolveConfigForScope = resolveConfigForScope;
@@ -290,6 +293,35 @@ async function loadScopeManifest(scope) {
 function updateManifest(man) {
     manifest = man;
 }
+function isMultiScopeManifest(man) {
+    return typeof man === "object" && man !== null && !man.scope && !man.tables;
+}
+function resolveManifestForScope(man, scope) {
+    if (!isMultiScopeManifest(man)) {
+        if (!scope || man.scope === scope) {
+            return man;
+        }
+        return undefined;
+    }
+    var scopeMan = man[scope];
+    if (scopeMan && scopeMan.tables) {
+        return scopeMan;
+    }
+    return undefined;
+}
+function resolveScopeFromPath(filePath) {
+    var cfg = getConfig();
+    if (!cfg.scopes)
+        return undefined;
+    var scopeNames = Object.keys(cfg.scopes);
+    for (var i = 0; i < scopeNames.length; i++) {
+        var scopeSourcePath = getSourcePathForScope(scopeNames[i]);
+        if (filePath.indexOf(scopeSourcePath) === 0) {
+            return scopeNames[i];
+        }
+    }
+    return undefined;
+}
 async function loadConfigPath(pth) {
     if (!pth) {
         pth = process.cwd();

package/dist/constants.js

@@ -3,8 +3,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PUSH_RETRY_LIMIT = exports.PUSH_RETRY_WAIT = exports.PATH_DELIMITER = void 0;
+exports.CONCURRENCY_BUILD = exports.CONCURRENCY_PUSH = exports.CONCURRENCY_FILES = exports.CONCURRENCY_RECORDS = exports.CONCURRENCY_TABLES = exports.PUSH_RETRY_LIMIT = exports.PUSH_RETRY_WAIT = exports.PATH_DELIMITER = void 0;
 const path_1 = __importDefault(require("path"));
 exports.PATH_DELIMITER = `${path_1.default.delimiter}${path_1.default.delimiter}`;
 exports.PUSH_RETRY_WAIT = 3000;
 exports.PUSH_RETRY_LIMIT = 3;
+exports.CONCURRENCY_TABLES = 2;
+exports.CONCURRENCY_RECORDS = 5;
+exports.CONCURRENCY_FILES = 10;
+exports.CONCURRENCY_PUSH = 3;
+exports.CONCURRENCY_BUILD = 5;

package/dist/createRecordCommand.js

@@ -102,7 +102,7 @@ async function resolveScope(args) {
     // Try to get scope from current manifest
     try {
         var manifest = ConfigManager.getManifest();
-        if (manifest && manifest.scope) {
+        if (manifest && !ConfigManager.isMultiScopeManifest(manifest) && manifest.scope) {
             return manifest.scope;
         }
     }

package/dist/dashboardCommand.js

@@ -13,16 +13,16 @@ async function dashboardCommand(args) {
     catch (e) {
         throw new Error("Dashboard package not installed. Run: npm install @tenonhq/sincronia-dashboard");
     }
+    var port = args.port ? String(args.port) : (process.env.DASHBOARD_PORT || "3456");
     Logger_1.logger.info("Starting Update Set Dashboard...");
     const server = (0, child_process_1.spawn)("node", [serverPath], {
         cwd: process.cwd(),
         stdio: "inherit",
-        env: { ...process.env },
+        env: { ...process.env, DASHBOARD_PORT: port },
     });
     // Open browser after a short delay
     setTimeout(() => {
-        const port = process.env.DASHBOARD_PORT || "3456";
-        const url = `http://localhost:${port}`;
+        const url = "http://localhost:" + port;
         (0, child_process_1.spawn)("open", [url]);
     }, 1000);
     server.on("close", (code) => {

package/dist/deleteRecordCommand.js

@@ -57,7 +57,7 @@ async function resolveScope(args) {
     // Try to get scope from current manifest
     try {
         var manifest = ConfigManager.getManifest();
-        if (manifest && manifest.scope) {
+        if (manifest && !ConfigManager.isMultiScopeManifest(manifest) && manifest.scope) {
             return manifest.scope;
         }
     }

package/dist/genericUtils.js

@@ -41,6 +41,8 @@ exports.parseFileNameParams = parseFileNameParams;
 exports.getParsedFilesPayload = getParsedFilesPayload;
 exports.wait = wait;
 exports.chunkArr = chunkArr;
+exports.processBatched = processBatched;
+exports.allSettledBatched = allSettledBatched;
 const path_1 = __importDefault(require("path"));
 const ConfigManager = __importStar(require("./config"));
 async function _getConfigFromPath(params) {
@@ -125,6 +127,48 @@ function chunkArr(arr, chunkSize) {
     }
     return chunks;
 }
+async function processBatched(items, concurrency, fn) {
+    var results = new Array(items.length);
+    var index = 0;
+    async function runNext() {
+        while (index < items.length) {
+            var currentIndex = index;
+            index++;
+            results[currentIndex] = await fn(items[currentIndex]);
+        }
+    }
+    var workers = [];
+    var workerCount = Math.min(concurrency, items.length);
+    for (var i = 0; i < workerCount; i++) {
+        workers.push(runNext());
+    }
+    await Promise.all(workers);
+    return results;
+}
+async function allSettledBatched(items, concurrency, fn) {
+    var results = new Array(items.length);
+    var index = 0;
+    async function runNext() {
+        while (index < items.length) {
+            var currentIndex = index;
+            index++;
+            try {
+                var value = await fn(items[currentIndex]);
+                results[currentIndex] = { status: "fulfilled", value: value };
+            }
+            catch (e) {
+                results[currentIndex] = { status: "rejected", reason: e };
+            }
+        }
+    }
+    var workers = [];
+    var workerCount = Math.min(concurrency, items.length);
+    for (var i = 0; i < workerCount; i++) {
+        workers.push(runNext());
+    }
+    await Promise.all(workers);
+    return results;
+}
 const allSettled = (promises) => {
     return Promise.all(promises.map((prom) => prom
         .then((value) => ({

package/dist/initSystem/discovery.js

@@ -37,7 +37,16 @@ exports.discoverPlugins = discoverPlugins;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const Logger_1 = require("../Logger");
-const SKIP_PACKAGES = new Set(["sincronia-core", "sincronia-types"]);
+// Skip packages that are not init plugins:
+// - core/types: the discovery system itself
+// - dashboard: starts Express server on require (side effect)
+// - schema: library imported directly by schemaCommand, not a plugin
+const SKIP_PACKAGES = new Set([
+    "sincronia-core",
+    "sincronia-types",
+    "sincronia-dashboard",
+    "sincronia-schema",
+]);
 const MAX_PARENT_DEPTH = 3;
 /**
  * @description Scans node_modules for @tenonhq/sincronia-* packages that export a sincPlugin.

package/dist/initSystem/orchestrator.js

@@ -173,6 +173,34 @@ async function runLoginPhase(plugin, context) {
         }
     }
 }
+async function runConfigPhase(context) {
+    if (context.hasConfig) {
+        var answer = await inquirer_1.default.prompt([{
+                type: "list",
+                name: "configAction",
+                message: "Existing config found. Would you like to update it or use the current one?",
+                choices: [
+                    { name: "Use current config", value: "keep" },
+                    { name: "Update config", value: "update" },
+                ],
+            }]);
+        if (answer.configAction === "keep") {
+            Logger_1.logger.info(chalk_1.default.green("  ✓ Using existing sinc.config.js"));
+            return;
+        }
+    }
+    // TODO: Future config wizard steps:
+    // 1. Scopes — multi-select from available scopes
+    // 2. Tables — multi-select with search (inquirer-autocomplete)
+    // 3. Fields for selected tables
+    // 4. Special scope tables
+    // 5. Special scope fields for tables
+    Logger_1.logger.info("");
+    Logger_1.logger.info(chalk_1.default.magenta("  🎬 Coming soon to a terminal near you!"));
+    Logger_1.logger.info(chalk_1.default.dim("  The config wizard is still in development — stay tuned."));
+    Logger_1.logger.info(chalk_1.default.dim("  For now, " + (context.hasConfig ? "we'll keep your current config." : "we'll set you up with the defaults.")));
+    Logger_1.logger.info("");
+}
 async function runConfigurePhase(plugin, context) {
     const hooks = plugin.configure;
     if (!hooks || hooks.length === 0)
@@ -239,6 +267,11 @@ async function runInit(options) {
         }
         // 5. Save env vars after login
         saveEnvVars(context, selectedPlugins);
+        // 5.5 Config phase
+        Logger_1.logger.info("");
+        Logger_1.logger.info(chalk_1.default.bold("  ── Config " + "─".repeat(29)));
+        Logger_1.logger.info("");
+        await runConfigPhase(context);
         // 6. Configure phase
         Logger_1.logger.info("");
         Logger_1.logger.info(chalk_1.default.bold("  ── Configure " + "─".repeat(26)));

package/dist/logMessages.js

@@ -4,21 +4,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.logBuildResults = exports.logPushResults = exports.log = void 0;
-exports.scopeCheckMessage = scopeCheckMessage;
-exports.devModeLog = devModeLog;
 exports.logFilePush = logFilePush;
 exports.logDeploy = logDeploy;
 const Logger_1 = require("./Logger");
 const chalk_1 = __importDefault(require("chalk"));
 exports.log = console.log;
-function scopeCheckMessage(scopeCheck) {
-    let sScope = chalk_1.default.blue(scopeCheck.sessionScope);
-    let mScope = chalk_1.default.blue(scopeCheck.manifestScope);
-    Logger_1.logger.error("Scope mismatch: your session is " + sScope + " but this project targets " + mScope + ". Switch scopes in ServiceNow to continue.");
-}
-function devModeLog() {
-    Logger_1.logger.info(`Dev mode started! Watching for changes...[${chalk_1.default.red("Press CTRL-C to Stop")}]\n`);
-}
 function parseError(err) {
     return `${err.name}:
  ${err.message}

package/dist/tests/discovery.test.js

@@ -53,4 +53,15 @@ describe("discoverPlugins", function () {
         const names = plugins.map(function (p) { return p.name; });
         expect(names).not.toContain("sass-plugin");
     });
+    it("skips sincronia-dashboard and sincronia-schema", function () {
+        Logger_1.logger.warn.mockClear();
+        mockReaddirSync.mockReturnValue([
+            "sincronia-dashboard",
+            "sincronia-schema",
+        ]);
+        const plugins = (0, discovery_1.discoverPlugins)();
+        expect(plugins).toEqual([]);
+        // No require() attempted, so no warn from load failure
+        expect(Logger_1.logger.warn).not.toHaveBeenCalled();
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tenonhq/sincronia-core",
-  "version": "0.0.72",
+  "version": "0.0.74",
   "description": "Next-gen file syncer",
   "license": "GPL-3.0",
   "main": "./dist/index.js",