@tenonhq/sincronia-core 0.0.79 → 0.0.81

package/dist/MultiScopeWatcher.js

@@ -55,7 +55,6 @@ class MultiScopeWatcherManager {
     updateSetCheckInterval = null;
     scopeLock = Promise.resolve();
     cachedScope = null;
-    cachedUserSysId = null;
     pendingScopes = new Map(); // scope -> first change timestamp
     globalProcessQueue = null;
     async startWatchingAllScopes(options) {
@@ -206,7 +205,41 @@ class MultiScopeWatcherManager {
         }
         var activeTask = this.readActiveTask();
         if (!activeTask) {
-            Logger_1.logger.warn(`[${scopeName}] No update set configured for scope ${scopeName}. Changes will go to Default. Use sinc createUpdateSet or activate a task in the dashboard.`);
+            // No active task — try to resolve the current update set from the ServiceNow
+            // session so pushWithUpdateSet can be used instead of the fallback updateRecord.
+            try {
+                var { defaultClient } = await Promise.resolve().then(() => __importStar(require("./snClient")));
+                var sessionClient = defaultClient();
+                var curResp = await sessionClient.getCurrentUpdateSet(scopeName);
+                var curData = curResp.data;
+                if (curData && curData.result) {
+                    curData = curData.result;
+                }
+                var curSysId = curData && curData.sysId ? curData.sysId : null;
+                var curName = curData && curData.name ? curData.name : null;
+                if (curSysId && curName) {
+                    var isDefault = curName === "Default" || curName.toLowerCase().indexOf("default") !== -1;
+                    if (isDefault) {
+                        Logger_1.logger.warn(`[${scopeName}] No update set configured and current update set is Default. ` +
+                            `Use sinc createUpdateSet or activate a task in the dashboard.`);
+                    }
+                    else {
+                        // Use the session's current non-Default update set
+                        config = this.getUpdateSetConfig();
+                        config[scopeName] = { sys_id: curSysId, name: curName };
+                        this.saveUpdateSetConfig(config);
+                        Logger_1.logger.info(`[${scopeName}] Using session update set: ${curName}`);
+                    }
+                }
+                else {
+                    Logger_1.logger.warn(`[${scopeName}] No update set configured for scope ${scopeName}. ` +
+                        `Use sinc createUpdateSet or activate a task in the dashboard.`);
+                }
+            }
+            catch (queryErr) {
+                Logger_1.logger.warn(`[${scopeName}] No update set configured and could not query current update set. ` +
+                    `Changes will use direct Table API. Use sinc createUpdateSet or activate a task in the dashboard.`);
+            }
             return;
         }
         var taskId = activeTask.taskId;
@@ -450,31 +483,14 @@ class MultiScopeWatcherManager {
             return;
         }
         try {
-            const { defaultClient, unwrapSNResponse } = await Promise.resolve().then(() => __importStar(require("./snClient")));
-            const client = defaultClient();
-            // Get the scope ID
-            const scopeResponse = await unwrapSNResponse(client.getScopeId(scopeName));
-            if (!scopeResponse || !Array.isArray(scopeResponse) || scopeResponse.length === 0 || !scopeResponse[0].sys_id) {
-                throw new Error(`Scope ${scopeName} not found`);
-            }
-            // Get user sys_id (cached for the session — never changes)
-            if (!this.cachedUserSysId) {
-                const userResponse = await unwrapSNResponse(client.getUserSysId());
-                if (!userResponse || !Array.isArray(userResponse) || userResponse.length === 0 || !userResponse[0].sys_id) {
-                    throw new Error("Could not get user sys_id");
-                }
-                this.cachedUserSysId = userResponse[0].sys_id;
-            }
-            // Get current app preference
-            const prefResponse = await unwrapSNResponse(client.getCurrentAppUserPrefSysId(this.cachedUserSysId));
-            if (prefResponse && Array.isArray(prefResponse) && prefResponse.length > 0 && prefResponse[0].sys_id) {
-                // Update existing preference
-                await client.updateCurrentAppUserPref(scopeResponse[0].sys_id, prefResponse[0].sys_id);
-            }
-            else {
-                // Create new preference
-                await client.createCurrentAppUserPref(scopeResponse[0].sys_id, this.cachedUserSysId);
-            }
+            var { defaultClient } = await Promise.resolve().then(() => __importStar(require("./snClient")));
+            var client = defaultClient();
+            // Use the Claude REST API changeScope endpoint to switch the session scope.
+            // This uses gs.setCurrentApplicationId() server-side, which correctly changes
+            // the REST API session scope. The previous approach used user preference updates
+            // (apps.current_app) which only writes a DB record and does NOT affect the
+            // active REST session — causing updateRecord() to operate in the wrong scope.
+            await client.changeScope(scopeName);
             this.cachedScope = scopeName;
             Logger_1.logger.debug(`Switched to scope: ${scopeName}`);
         }

package/dist/appUtils.js

@@ -106,9 +106,37 @@ const countRecordsInTables = (tables) => {
         return sum + Object.keys(tables[tableName].records).length;
     }, 0);
 };
-const processTablesInManifest = async (tables, forceWrite, sourcePath, onRecordProcessed) => {
+const processTablesInManifest = async (tables, forceWrite, sourcePath, onRecordProcessed, scope) => {
     var basePath = sourcePath || ConfigManager.getSourcePath();
-    const tableNames = Object.keys(tables);
+    var tableNames = Object.keys(tables);
+    // Defense-in-depth: filter out any table not in the resolved whitelist before
+    // writing to disk. Protects against upstream defects that let non-whitelisted
+    // tables through (e.g. server-side manifest fanout, stale manifest entries).
+    if (scope) {
+        try {
+            var resolved = ConfigManager.resolveConfigForScope(scope);
+            var allowed = resolved.tables;
+            if (allowed && allowed.length > 0) {
+                var skipped = [];
+                tableNames = tableNames.filter(function (t) {
+                    if (allowed.indexOf(t) === -1) {
+                        skipped.push(t);
+                        return false;
+                    }
+                    return true;
+                });
+                if (skipped.length > 0) {
+                    FileLogger_1.fileLogger.debug("processTablesInManifest: dropped " + skipped.length +
+                        " non-whitelisted tables for scope '" + scope + "': " + skipped.join(", "));
+                }
+            }
+        }
+        catch (e) {
+            // Config resolution can fail for legacy single-scope manifests; fall
+            // through and process whatever the manifest contains.
+            FileLogger_1.fileLogger.debug("processTablesInManifest: could not resolve whitelist for scope '" + scope + "'");
+        }
+    }
     await (0, genericUtils_1.processBatched)(tableNames, constants_1.CONCURRENCY_TABLES, function (tableName) {
         return processRecsInManTable(path_1.default.join(basePath, tableName), tables[tableName], forceWrite, onRecordProcessed);
     });
@@ -149,7 +177,7 @@ const processManifest = async (manifest, forceWrite = false, sourcePath) => {
         scope: manifest.scope || "default",
         total: recordCount,
     });
-    await processTablesInManifest(manifest.tables, forceWrite, sourcePath, progress.tick);
+    await processTablesInManifest(manifest.tables, forceWrite, sourcePath, progress.tick, manifest.scope);
     if (manifest.scope) {
         await fUtils.writeScopeManifest(manifest.scope, manifest);
     }
@@ -163,14 +191,51 @@ const syncManifest = async (scope) => {
         const curManifest = await ConfigManager.getManifest();
         if (!curManifest)
             throw new Error("No manifest file loaded!");
+        const config = ConfigManager.getConfig();
+        const declaredScopes = (config.scopes && Object.keys(config.scopes)) || [];
         // If a specific scope is provided, sync only that scope
         if (scope) {
+            // Scope whitelist gate: refuse to refresh scopes not declared in sinc.config.js.
+            // Without this, stale entries in sinc.manifest.json leak undeclared scopes into
+            // the refresh loop (see RFC-0004 / sys_alias debris incident 2026-04-14).
+            if (declaredScopes.length > 0 && declaredScopes.indexOf(scope) === -1) {
+                Logger_1.logger.warn("Skipping scope '" + scope + "' — not declared in sinc.config.js `scopes`. " +
+                    "Add it to config.scopes to sync, or remove its manifest file.");
+                FileLogger_1.fileLogger.debug("syncManifest: skipped undeclared scope '" + scope + "'");
+                return;
+            }
             Logger_1.logger.info("Refreshing scope: " + scope + "...");
             const client = (0, snClient_1.defaultClient)();
-            const config = ConfigManager.getConfig();
-            // Resolve scope-specific source directory
+            // Resolve scope-specific source directory + table whitelist
             var scopeSourcePath = ConfigManager.getSourcePathForScope(scope);
+            var resolvedConfig = ConfigManager.resolveConfigForScope(scope);
+            var allowedTables = resolvedConfig.tables;
             const newManifest = (0, exports.normalizeManifestKeys)(await (0, snClient_1.unwrapSNResponse)(client.getManifest(scope, config)));
+            // Table whitelist gate: drop any table the server returned that is not in
+            // the resolved _tables whitelist for this scope. Mirrors the filter in
+            // commands.ts downloadCommand() and allScopesCommands.ts processScope().
+            if (allowedTables && allowedTables.length > 0) {
+                var manifestTableNames = Object.keys(newManifest.tables || {});
+                var filteredTables = {};
+                var skippedCount = 0;
+                for (var t = 0; t < manifestTableNames.length; t++) {
+                    var tName = manifestTableNames[t];
+                    if (allowedTables.indexOf(tName) !== -1) {
+                        filteredTables[tName] = newManifest.tables[tName];
+                    }
+                    else {
+                        skippedCount++;
+                    }
+                }
+                if (skippedCount > 0) {
+                    FileLogger_1.fileLogger.debug("syncManifest: filtered " + skippedCount + " tables not in _tables whitelist for " +
+                        scope + " (kept " + Object.keys(filteredTables).length + " of " + manifestTableNames.length + ")");
+                }
+                newManifest.tables = filteredTables;
+            }
+            else {
+                Logger_1.logger.warn("No _tables whitelist defined — writing ALL tables for " + scope);
+            }
             const refreshTableCount = Object.keys(newManifest.tables).length;
             FileLogger_1.fileLogger.debug("Refreshed manifest for " + scope + ": " + refreshTableCount + " tables");
             await fUtils.writeScopeManifest(scope, newManifest);
@@ -182,9 +247,16 @@ const syncManifest = async (scope) => {
             }
         }
         else {
-            // Sync all scopes if manifest has multiple scopes
-            if (ConfigManager.isMultiScopeManifest(curManifest)) {
-                // Multiple scopes detected
+            // Sync all scopes. Prefer the declared-scopes list (config.scopes) over
+            // the persisted manifest keys — the manifest may contain stale undeclared
+            // scopes that leaked in before the whitelist gate existed.
+            if (declaredScopes.length > 0) {
+                for (var d = 0; d < declaredScopes.length; d++) {
+                    await (0, exports.syncManifest)(declaredScopes[d]);
+                }
+            }
+            else if (ConfigManager.isMultiScopeManifest(curManifest)) {
+                // No declared scopes — fall back to the persisted manifest's scopes.
                 for (const scopeName of Object.keys(curManifest)) {
                     await (0, exports.syncManifest)(scopeName);
                 }
@@ -274,6 +346,11 @@ const findMissingFiles = async (manifest, sourcePath) => {
     return missing;
 };
 exports.findMissingFiles = findMissingFiles;
+// Chunk bulkDownload by table to stay under ServiceNow's 10 MB REST payload cap.
+// A single unchunked call 500s on large scopes (e.g. x_cadso_automate at ~29 MB).
+// Must mirror the chunk size used by allScopesCommands.ts (watch path) so behaviour
+// is consistent across `refresh` and `watch`.
+const BULK_DOWNLOAD_TABLE_CHUNK_SIZE = 5;
 const processMissingFiles = async (newManifest, sourcePath) => {
     try {
         const missing = await (0, exports.findMissingFiles)(newManifest, sourcePath);
@@ -283,13 +360,32 @@ const processMissingFiles = async (newManifest, sourcePath) => {
         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));
+        // Chunk the bulkDownload request: ServiceNow rejects REST payloads > 10 MB,
+        // so send table batches and merge the results before processing.
+        const tableNames = Object.keys(missing);
+        const totalChunks = Math.ceil(tableNames.length / BULK_DOWNLOAD_TABLE_CHUNK_SIZE);
+        const filesToProcess = {};
+        for (var i = 0; i < tableNames.length; i += BULK_DOWNLOAD_TABLE_CHUNK_SIZE) {
+            const chunkTableNames = tableNames.slice(i, i + BULK_DOWNLOAD_TABLE_CHUNK_SIZE);
+            const chunkMissing = {};
+            for (var j = 0; j < chunkTableNames.length; j++) {
+                chunkMissing[chunkTableNames[j]] = missing[chunkTableNames[j]];
+            }
+            const batchNum = Math.floor(i / BULK_DOWNLOAD_TABLE_CHUNK_SIZE) + 1;
+            FileLogger_1.fileLogger.debug("Bulk download batch " + batchNum + "/" + totalChunks +
+                " (" + chunkTableNames.length + " tables): " + chunkTableNames.join(", "));
+            const chunkResult = await (0, snClient_1.unwrapSNResponse)(client.getMissingFiles(chunkMissing, tableOptions));
+            // Chunks are partitioned by table key, so merging is a simple assign.
+            for (var tableName in chunkResult) {
+                filesToProcess[tableName] = chunkResult[tableName];
+            }
+        }
         var recordCount = countRecordsInTables(filesToProcess);
         var progress = createScopeProgress(Logger_1.logger.getLogLevel(), {
             scope: newManifest.scope || "default",
             total: recordCount,
         });
-        await processTablesInManifest(filesToProcess, false, sourcePath, progress.tick);
+        await processTablesInManifest(filesToProcess, false, sourcePath, progress.tick, newManifest.scope);
     }
     catch (e) {
         throw e;

package/dist/snClient.js

@@ -369,13 +369,56 @@ const unwrapSNResponse = async (clientPromise) => {
         return resp.data.result;
     }
     catch (e) {
-        let message;
-        if (e instanceof Error)
-            message = e.message;
-        else
-            message = String(e);
         const instance = process.env.SN_INSTANCE || "unknown";
-        Logger_1.logger.error("Error from " + instance + ": " + message);
+        if (axios_1.default.isAxiosError(e) && e.response) {
+            const status = e.response.status;
+            const statusText = e.response.statusText || "";
+            const method = ((e.config && e.config.method) || "").toUpperCase();
+            const url = (e.config && e.config.url) || "";
+            const data = e.response.data;
+            // Extract ServiceNow-shaped error message if present (`{error: {message, detail}, status}`)
+            let snMessage = "";
+            if (data && typeof data === "object") {
+                if (data.error && typeof data.error === "object" && data.error.message) {
+                    snMessage = " — " + String(data.error.message);
+                }
+                else if (typeof data.message === "string") {
+                    snMessage = " — " + data.message;
+                }
+            }
+            // Pull scope out of /getManifest/:scope URLs for easy grepping
+            let scope;
+            const manifestMatch = url.match(/\/getManifest\/([^/?]+)/);
+            if (manifestMatch)
+                scope = manifestMatch[1];
+            Logger_1.logger.error("Error from " + instance + ": HTTP " + status + " " +
+                method + " " + url + snMessage);
+            FileLogger_1.fileLogger.debug("REST error detail", {
+                instance: instance,
+                scope: scope,
+                method: method,
+                url: url,
+                status: status,
+                statusText: statusText,
+                responseData: data,
+                responseHeaders: e.response.headers,
+            });
+        }
+        else {
+            // Non-Axios error: preserve today's behaviour, add debug detail
+            let message;
+            if (e instanceof Error)
+                message = e.message;
+            else
+                message = String(e);
+            Logger_1.logger.error("Error from " + instance + ": " + message);
+            FileLogger_1.fileLogger.debug("Non-Axios error detail", {
+                instance: instance,
+                errorName: e instanceof Error ? e.name : undefined,
+                errorStack: e instanceof Error ? e.stack : undefined,
+                message: message,
+            });
+        }
         throw e;
     }
 };

package/dist/tests/syncManifestWhitelist.test.js

@@ -0,0 +1,192 @@
+"use strict";
+/**
+ * Tests for the scope + table whitelist gates in syncManifest() and
+ * processTablesInManifest().
+ *
+ * Regression target: 2026-04-14 sys_alias debris incident.
+ *  - `npx sinc refresh` iterated every scope in the persisted multi-scope
+ *    manifest, including scopes not declared in sinc.config.js.
+ *  - For each of those scopes, the server-side getManifest response returned
+ *    hundreds of tables (up to 129 for x_cadso_work) that the config _tables
+ *    whitelist never authorised, and the client wrote all of them to disk —
+ *    including sys_alias/sys_alias_templates folders with 314 field files per
+ *    record (fan-out of every script/html/css/xml field config across tables).
+ *
+ * These tests assert the two defensive filters:
+ *   1. Undeclared scopes are skipped before any REST call.
+ *   2. Tables not in the _tables whitelist are filtered from the manifest
+ *      before writeScopeManifest / processMissingFiles run.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var mockLogger = {
+    info: jest.fn(),
+    debug: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    success: jest.fn(),
+    getLogLevel: function () { return "info"; },
+};
+var mockFileLogger = {
+    debug: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+};
+var mockClient = {
+    getManifest: jest.fn(),
+};
+var mockFUtils = {
+    writeScopeManifest: jest.fn().mockResolvedValue(undefined),
+    writeFileForce: jest.fn().mockResolvedValue(undefined),
+    writeSNFileCurry: jest.fn(() => jest.fn().mockResolvedValue(undefined)),
+    createDirRecursively: jest.fn().mockResolvedValue(undefined),
+};
+jest.mock("../Logger", function () { return { logger: mockLogger }; });
+jest.mock("../FileLogger", function () { return { fileLogger: mockFileLogger }; });
+jest.mock("../FileUtils", function () { return mockFUtils; });
+jest.mock("../snClient", function () {
+    return {
+        defaultClient: function () { return mockClient; },
+        unwrapSNResponse: function (p) { return Promise.resolve(p).then(function (r) { return r; }); },
+        processPushResponse: jest.fn(),
+        retryOnErr: jest.fn(),
+        retryOnHttpErr: jest.fn(),
+        unwrapTableAPIFirstItem: jest.fn(),
+    };
+});
+// Mock config module. Individual tests override getConfig/getManifest/etc.
+var mockConfig = {
+    getConfig: jest.fn(),
+    getManifest: jest.fn(),
+    getSourcePathForScope: jest.fn().mockReturnValue("/tmp/src"),
+    getSourcePath: jest.fn().mockReturnValue("/tmp/src"),
+    getManifestPath: jest.fn().mockReturnValue("/tmp/sinc.manifest.json"),
+    resolveConfigForScope: jest.fn(),
+    isMultiScopeManifest: jest.fn().mockReturnValue(true),
+    updateManifest: jest.fn(),
+};
+jest.mock("../config", function () { return mockConfig; });
+// Prevent processMissingFiles' progress bar from touching stdout in tests.
+jest.mock("progress", function () {
+    return jest.fn().mockImplementation(function () {
+        return { tick: jest.fn() };
+    });
+});
+// Keep the per-scope progress shim simple.
+jest.mock("../genericUtils", function () {
+    var actual = jest.requireActual("../genericUtils");
+    return actual;
+});
+const AppUtils = __importStar(require("../appUtils"));
+describe("syncManifest — scope + table whitelist gates", function () {
+    beforeEach(function () {
+        jest.clearAllMocks();
+        mockConfig.isMultiScopeManifest.mockReturnValue(true);
+        mockConfig.resolveConfigForScope.mockImplementation(function (_scope) {
+            return {
+                tables: ["sys_script_include", "sys_script", "sys_ux_macroponent"],
+                fieldOverrides: {},
+                apiIncludes: {},
+                apiExcludes: {},
+            };
+        });
+    });
+    test("skips undeclared scope — no REST call, warn logged", async function () {
+        mockConfig.getConfig.mockReturnValue({
+            scopes: { x_cadso_core: {}, x_cadso_work: {} },
+        });
+        mockConfig.getManifest.mockResolvedValue({
+            x_cadso_core: { scope: "x_cadso_core", tables: {} },
+            x_cadso_click: { scope: "x_cadso_click", tables: {} }, // stale undeclared
+        });
+        await AppUtils.syncManifest("x_cadso_click");
+        expect(mockClient.getManifest).not.toHaveBeenCalled();
+        expect(mockFUtils.writeScopeManifest).not.toHaveBeenCalled();
+        var warnedAboutScope = mockLogger.warn.mock.calls.some(function (args) {
+            return typeof args[0] === "string" && args[0].indexOf("x_cadso_click") !== -1;
+        });
+        expect(warnedAboutScope).toBe(true);
+    });
+    test("declared scope — filters non-whitelisted tables before write", async function () {
+        mockConfig.getConfig.mockReturnValue({
+            scopes: { x_cadso_core: {} },
+        });
+        mockConfig.getManifest.mockResolvedValue({
+            x_cadso_core: { scope: "x_cadso_core", tables: {} },
+        });
+        // Server returns two whitelisted tables + sys_alias (not whitelisted).
+        mockClient.getManifest.mockResolvedValue({
+            scope: "x_cadso_core",
+            tables: {
+                sys_script_include: { records: { FooInclude: { name: "FooInclude", sys_id: "a1", files: [] } } },
+                sys_script: { records: { BarBR: { name: "BarBR", sys_id: "a2", files: [] } } },
+                sys_alias: { records: { DebrisRec: { name: "DebrisRec", sys_id: "a3", files: [] } } },
+            },
+        });
+        await AppUtils.syncManifest("x_cadso_core");
+        expect(mockClient.getManifest).toHaveBeenCalledWith("x_cadso_core", expect.any(Object));
+        expect(mockFUtils.writeScopeManifest).toHaveBeenCalledTimes(1);
+        var writtenScope = mockFUtils.writeScopeManifest.mock.calls[0][0];
+        var writtenManifest = mockFUtils.writeScopeManifest.mock.calls[0][1];
+        expect(writtenScope).toBe("x_cadso_core");
+        var writtenTables = Object.keys(writtenManifest.tables);
+        expect(writtenTables).toContain("sys_script_include");
+        expect(writtenTables).toContain("sys_script");
+        expect(writtenTables).not.toContain("sys_alias");
+    });
+    test("no-scope call iterates only declared scopes, even when manifest has stale ones", async function () {
+        mockConfig.getConfig.mockReturnValue({
+            scopes: { x_cadso_core: {}, x_cadso_work: {} },
+        });
+        // Persisted multi-scope manifest still carries stale undeclared scopes.
+        mockConfig.getManifest.mockResolvedValue({
+            x_cadso_core: { scope: "x_cadso_core", tables: {} },
+            x_cadso_work: { scope: "x_cadso_work", tables: {} },
+            x_cadso_click: { scope: "x_cadso_click", tables: {} },
+            x_nuvo_sinc: { scope: "x_nuvo_sinc", tables: {} },
+            x_cadso_ti_agile: { scope: "x_cadso_ti_agile", tables: {} },
+        });
+        mockClient.getManifest.mockImplementation(function (scope) {
+            return Promise.resolve({ scope: scope, tables: {} });
+        });
+        await AppUtils.syncManifest();
+        var refreshedScopes = mockClient.getManifest.mock.calls.map(function (c) { return c[0]; });
+        expect(refreshedScopes.sort()).toEqual(["x_cadso_core", "x_cadso_work"]);
+        expect(refreshedScopes).not.toContain("x_cadso_click");
+        expect(refreshedScopes).not.toContain("x_nuvo_sinc");
+        expect(refreshedScopes).not.toContain("x_cadso_ti_agile");
+    });
+});

package/dist/tests/unwrapSNResponseError.test.js

@@ -0,0 +1,145 @@
+"use strict";
+/**
+ * Tests for the enhanced error path in unwrapSNResponse.
+ *
+ * When a ServiceNow REST call throws, the catch block must:
+ *  - Log a structured one-liner via logger.error including HTTP status, method, URL
+ *    and (when present) the ServiceNow-shaped error message from the response body.
+ *  - Dump the full error surface (status, statusText, responseData, responseHeaders,
+ *    scope extracted from /getManifest/:scope URLs) via fileLogger.debug.
+ *  - Re-throw the original error so upstream callers see identical behaviour.
+ *
+ * Non-Axios errors must preserve the original log shape ("Error from <instance>: <msg>")
+ * and also produce a debug dump for future triage.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var mockLogger = {
+    info: jest.fn(),
+    debug: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    getLogLevel: function () { return "debug"; },
+};
+var mockFileLogger = {
+    debug: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+};
+jest.mock("../Logger", function () {
+    return { logger: mockLogger };
+});
+jest.mock("../FileLogger", function () {
+    return { fileLogger: mockFileLogger };
+});
+const snClient_1 = require("../snClient");
+function makeAxiosError(overrides) {
+    var error = new Error("Request failed with status code " + overrides.status);
+    error.isAxiosError = true;
+    error.config = {
+        method: overrides.method || "post",
+        url: overrides.url || "api/sinc/sincronia/getManifest/x_cadso_example",
+    };
+    error.response = {
+        status: overrides.status,
+        statusText: overrides.statusText || "",
+        headers: overrides.headers || { "x-test": "1" },
+        data: overrides.data,
+    };
+    return error;
+}
+describe("unwrapSNResponse — error handling", function () {
+    var origInstance;
+    beforeAll(function () {
+        origInstance = process.env.SN_INSTANCE;
+        process.env.SN_INSTANCE = "tenontest.service-now.com";
+    });
+    afterAll(function () {
+        if (origInstance === undefined)
+            delete process.env.SN_INSTANCE;
+        else
+            process.env.SN_INSTANCE = origInstance;
+    });
+    beforeEach(function () {
+        jest.clearAllMocks();
+    });
+    test("Axios 500 with ServiceNow-shaped body: one-liner includes status + URL + SN message, debug dump carries full detail", async function () {
+        var snBody = {
+            error: {
+                message: "org.mozilla.javascript.EcmaError: TypeError",
+                detail: "Cannot read property 'name' of null",
+            },
+            status: "failure",
+        };
+        var axErr = makeAxiosError({
+            status: 500,
+            method: "post",
+            url: "api/sinc/sincronia/getManifest/x_cadso_automate",
+            data: snBody,
+            statusText: "Internal Server Error",
+        });
+        var rejected = Promise.reject(axErr);
+        // Silence the unhandled-rejection warning before jest inspects it
+        rejected.catch(function () { });
+        await expect((0, snClient_1.unwrapSNResponse)(rejected)).rejects.toBe(axErr);
+        expect(mockLogger.error).toHaveBeenCalledTimes(1);
+        var userLine = mockLogger.error.mock.calls[0][0];
+        expect(userLine).toContain("tenontest.service-now.com");
+        expect(userLine).toContain("HTTP 500");
+        expect(userLine).toContain("POST");
+        expect(userLine).toContain("getManifest/x_cadso_automate");
+        expect(userLine).toContain("org.mozilla.javascript.EcmaError");
+        expect(mockFileLogger.debug).toHaveBeenCalledTimes(1);
+        var debugLabel = mockFileLogger.debug.mock.calls[0][0];
+        var debugPayload = mockFileLogger.debug.mock.calls[0][1];
+        expect(debugLabel).toBe("REST error detail");
+        expect(debugPayload).toMatchObject({
+            instance: "tenontest.service-now.com",
+            scope: "x_cadso_automate",
+            method: "POST",
+            status: 500,
+            statusText: "Internal Server Error",
+            responseData: snBody,
+            responseHeaders: { "x-test": "1" },
+        });
+        expect(debugPayload.url).toContain("getManifest/x_cadso_automate");
+    });
+    test("Axios 500 with non-SN body: one-liner falls back cleanly, no crash", async function () {
+        var axErr = makeAxiosError({
+            status: 500,
+            method: "get",
+            url: "api/now/table/sys_script_include",
+            data: "<html><body>Gateway error</body></html>",
+        });
+        var rejected = Promise.reject(axErr);
+        rejected.catch(function () { });
+        await expect((0, snClient_1.unwrapSNResponse)(rejected)).rejects.toBe(axErr);
+        var userLine = mockLogger.error.mock.calls[0][0];
+        expect(userLine).toContain("HTTP 500");
+        expect(userLine).toContain("GET");
+        expect(userLine).toContain("table/sys_script_include");
+        // No SN message to append; no em dash
+        expect(userLine).not.toContain(" — ");
+        expect(mockFileLogger.debug).toHaveBeenCalledTimes(1);
+        var debugPayload = mockFileLogger.debug.mock.calls[0][1];
+        // Non-manifest URL — scope should be undefined
+        expect(debugPayload.scope).toBeUndefined();
+        expect(debugPayload.responseData).toBe("<html><body>Gateway error</body></html>");
+    });
+    test("Non-Axios error: preserves legacy log shape and re-throws", async function () {
+        var nonAxios = new Error("socket hang up");
+        var rejected = Promise.reject(nonAxios);
+        rejected.catch(function () { });
+        await expect((0, snClient_1.unwrapSNResponse)(rejected)).rejects.toBe(nonAxios);
+        expect(mockLogger.error).toHaveBeenCalledTimes(1);
+        var userLine = mockLogger.error.mock.calls[0][0];
+        expect(userLine).toBe("Error from tenontest.service-now.com: socket hang up");
+        expect(mockFileLogger.debug).toHaveBeenCalledTimes(1);
+        var debugLabel = mockFileLogger.debug.mock.calls[0][0];
+        expect(debugLabel).toBe("Non-Axios error detail");
+        var debugPayload = mockFileLogger.debug.mock.calls[0][1];
+        expect(debugPayload.message).toBe("socket hang up");
+        expect(debugPayload.errorName).toBe("Error");
+        expect(typeof debugPayload.errorStack).toBe("string");
+    });
+});

package/package.json

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