@tenonhq/sincronia-core 0.0.80 → 0.0.82

package/dist/tests/syncManifestRefresh.test.js

@@ -0,0 +1,287 @@
+"use strict";
+/**
+ * Tests for the refresh content-compare path.
+ *
+ * Regression target: `npx sinc refresh` previously only downloaded files that
+ * were absent from disk. Files edited on the ServiceNow instance would never
+ * propagate to a developer's local copy — the refresh command silently
+ * skipped existing files without checking content.
+ *
+ * These tests assert:
+ *   1. refresh fetches content for EVERY file in the manifest (not just missing)
+ *   2. Files whose local content differs are overwritten
+ *   3. Files whose local content matches are left alone (no rewrite)
+ *   4. Files missing locally are created
+ *   5. --force bypasses the content check and writes all files unconditionally
+ */
+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 });
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+// ---------- mocks (must come before importing the module under test) ----------
+var mockLogger = {
+    info: jest.fn(),
+    debug: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    success: jest.fn(),
+    getLogLevel: function () { return "warn"; },
+};
+var mockFileLogger = {
+    debug: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+};
+var mockClient = {
+    getManifest: jest.fn(),
+    getMissingFiles: jest.fn(),
+};
+jest.mock("../Logger", function () { return { logger: mockLogger }; });
+jest.mock("../FileLogger", function () { return { fileLogger: mockFileLogger }; });
+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(),
+    };
+});
+var mockConfig = {
+    getConfig: jest.fn().mockReturnValue({
+        scopes: { x_cadso_core: {} },
+        tableOptions: {},
+    }),
+    getManifest: jest.fn().mockResolvedValue({
+        x_cadso_core: { scope: "x_cadso_core", tables: {} },
+    }),
+    getSourcePathForScope: jest.fn(),
+    getSourcePath: jest.fn(),
+    getManifestPath: jest.fn().mockReturnValue("/tmp/sinc.manifest.json"),
+    resolveConfigForScope: jest.fn().mockImplementation(function () {
+        return {
+            tables: ["sys_script_include"],
+            fieldOverrides: {},
+            apiIncludes: {},
+            apiExcludes: {},
+        };
+    }),
+    isMultiScopeManifest: jest.fn().mockReturnValue(true),
+    updateManifest: jest.fn(),
+};
+jest.mock("../config", function () { return mockConfig; });
+// Silence ProgressBar's stdout writes.
+jest.mock("progress", function () {
+    return jest.fn().mockImplementation(function () {
+        return { tick: jest.fn() };
+    });
+});
+// Stub writeScopeManifest so we don't actually write a manifest file. Leave
+// the other FileUtils exports (writeSNFileCurry, writeSNFileIfDifferent,
+// createDirRecursively, etc.) as real implementations so we can assert
+// against the file system.
+jest.mock("../FileUtils", function () {
+    var actual = jest.requireActual("../FileUtils");
+    return Object.assign({}, actual, {
+        writeScopeManifest: jest.fn().mockResolvedValue(undefined),
+    });
+});
+const AppUtils = __importStar(require("../appUtils"));
+// ---------- tmp dir scaffolding ----------
+var tmpRoot;
+function setupScope(files) {
+    // Build a manifest whose single table (sys_script_include) contains the
+    // supplied records/files. Content is stripped (manifests do not carry it).
+    var records = {};
+    files.forEach(function (f) {
+        if (!records[f.record]) {
+            records[f.record] = { name: f.record, sys_id: "sysid_" + f.record, files: [] };
+        }
+        records[f.record].files.push({ name: f.name, type: f.type });
+    });
+    return {
+        scope: "x_cadso_core",
+        tables: {
+            sys_script_include: { records: records },
+        },
+    };
+}
+function writeLocal(record, name, type, content) {
+    var recDir = path.join(tmpRoot, "sys_script_include", record);
+    fs.mkdirSync(recDir, { recursive: true });
+    fs.writeFileSync(path.join(recDir, name + "." + type), content);
+}
+function readLocal(record, name, type) {
+    var p = path.join(tmpRoot, "sys_script_include", record, name + "." + type);
+    try {
+        return fs.readFileSync(p, "utf8");
+    }
+    catch (e) {
+        return null;
+    }
+}
+function statMtime(record, name, type) {
+    var p = path.join(tmpRoot, "sys_script_include", record, name + "." + type);
+    return fs.statSync(p).mtimeMs;
+}
+describe("syncManifest — refresh pulls instance edits down", function () {
+    beforeEach(function () {
+        jest.clearAllMocks();
+        tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "sinc-refresh-test-"));
+        mockConfig.getSourcePathForScope.mockReturnValue(tmpRoot);
+        mockConfig.getSourcePath.mockReturnValue(tmpRoot);
+    });
+    afterEach(function () {
+        try {
+            fs.rmSync(tmpRoot, { recursive: true, force: true });
+        }
+        catch (e) { }
+    });
+    test("overwrites existing file when instance content differs", async function () {
+        writeLocal("Foo", "script", "js", "var x = 1;"); // stale local
+        var manifest = setupScope([{ record: "Foo", name: "script", type: "js", content: "" }]);
+        mockClient.getManifest.mockResolvedValue(manifest);
+        mockClient.getMissingFiles.mockResolvedValue({
+            sys_script_include: {
+                records: {
+                    Foo: {
+                        name: "Foo",
+                        sys_id: "sysid_Foo",
+                        files: [{ name: "script", type: "js", content: "var x = 2; // from instance" }],
+                    },
+                },
+            },
+        });
+        await AppUtils.syncManifest("x_cadso_core");
+        expect(mockClient.getMissingFiles).toHaveBeenCalledTimes(1);
+        expect(readLocal("Foo", "script", "js")).toBe("var x = 2; // from instance");
+    });
+    test("does not rewrite a file when content already matches", async function () {
+        var identical = "var answer = 42;";
+        writeLocal("Bar", "script", "js", identical);
+        var beforeMtime = statMtime("Bar", "script", "js");
+        var manifest = setupScope([{ record: "Bar", name: "script", type: "js", content: "" }]);
+        mockClient.getManifest.mockResolvedValue(manifest);
+        mockClient.getMissingFiles.mockResolvedValue({
+            sys_script_include: {
+                records: {
+                    Bar: {
+                        name: "Bar",
+                        sys_id: "sysid_Bar",
+                        files: [{ name: "script", type: "js", content: identical }],
+                    },
+                },
+            },
+        });
+        // Give the fs a moment so any write would register a different mtime.
+        await new Promise(function (r) { setTimeout(r, 10); });
+        await AppUtils.syncManifest("x_cadso_core");
+        expect(readLocal("Bar", "script", "js")).toBe(identical);
+        expect(statMtime("Bar", "script", "js")).toBe(beforeMtime);
+        // metaData should NOT be written when nothing changed in the record
+        expect(readLocal("Bar", "metaData", "json")).toBeNull();
+    });
+    test("creates the file when it is missing locally", async function () {
+        var manifest = setupScope([{ record: "Baz", name: "script", type: "js", content: "" }]);
+        mockClient.getManifest.mockResolvedValue(manifest);
+        mockClient.getMissingFiles.mockResolvedValue({
+            sys_script_include: {
+                records: {
+                    Baz: {
+                        name: "Baz",
+                        sys_id: "sysid_Baz",
+                        files: [{ name: "script", type: "js", content: "// fresh file" }],
+                    },
+                },
+            },
+        });
+        await AppUtils.syncManifest("x_cadso_core");
+        expect(readLocal("Baz", "script", "js")).toBe("// fresh file");
+        expect(readLocal("Baz", "metaData", "json")).not.toBeNull();
+    });
+    test("--force overwrites even when local content already matches", async function () {
+        var identical = "var same = true;";
+        writeLocal("Qux", "script", "js", identical);
+        var manifest = setupScope([{ record: "Qux", name: "script", type: "js", content: "" }]);
+        mockClient.getManifest.mockResolvedValue(manifest);
+        mockClient.getMissingFiles.mockResolvedValue({
+            sys_script_include: {
+                records: {
+                    Qux: {
+                        name: "Qux",
+                        sys_id: "sysid_Qux",
+                        files: [{ name: "script", type: "js", content: identical }],
+                    },
+                },
+            },
+        });
+        var beforeMtime = statMtime("Qux", "script", "js");
+        await new Promise(function (r) { setTimeout(r, 10); });
+        await AppUtils.syncManifest("x_cadso_core", { force: true });
+        // Force path rewrites regardless — mtime should advance.
+        expect(statMtime("Qux", "script", "js")).toBeGreaterThan(beforeMtime);
+        expect(readLocal("Qux", "metaData", "json")).not.toBeNull();
+    });
+    test("bulkDownload is requested for EVERY file in the manifest, not just missing ones", async function () {
+        writeLocal("RecA", "script", "js", "local A");
+        writeLocal("RecB", "script", "js", "local B");
+        var manifest = setupScope([
+            { record: "RecA", name: "script", type: "js", content: "" },
+            { record: "RecB", name: "script", type: "js", content: "" },
+        ]);
+        mockClient.getManifest.mockResolvedValue(manifest);
+        mockClient.getMissingFiles.mockResolvedValue({
+            sys_script_include: {
+                records: {
+                    RecA: {
+                        name: "RecA", sys_id: "sysid_RecA",
+                        files: [{ name: "script", type: "js", content: "local A" }],
+                    },
+                    RecB: {
+                        name: "RecB", sys_id: "sysid_RecB",
+                        files: [{ name: "script", type: "js", content: "local B" }],
+                    },
+                },
+            },
+        });
+        await AppUtils.syncManifest("x_cadso_core");
+        expect(mockClient.getMissingFiles).toHaveBeenCalledTimes(1);
+        var missingArg = mockClient.getMissingFiles.mock.calls[0][0];
+        expect(Object.keys(missingArg.sys_script_include).sort()).toEqual(["sysid_RecA", "sysid_RecB"]);
+    });
+});

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.80",
+  "version": "0.0.82",
   "description": "Next-gen file syncer",
   "license": "GPL-3.0",
   "main": "./dist/index.js",