@tenonhq/dovetail-core 0.0.85

package/dist/tests/snClient.fallback.test.js

@@ -0,0 +1,120 @@
+"use strict";
+// Tests for the /api/cadso/dovetail/* -> /api/cadso/claude/* 404 fallback
+// in _callDovetailApi (snClient.ts). Covers: first call hits the dovetail
+// endpoint, 404 latches the legacy path with a one-time warning, subsequent
+// calls skip dovetail, and non-404 errors do NOT trigger fallback.
+Object.defineProperty(exports, "__esModule", { value: true });
+var mockLogger = {
+    info: jest.fn(),
+    debug: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    getLogLevel: function () { return "debug"; },
+};
+jest.mock("../Logger", function () {
+    return { logger: mockLogger };
+});
+jest.mock("../FileLogger", function () {
+    return { fileLogger: { debug: jest.fn(), info: jest.fn(), warn: jest.fn(), error: jest.fn() } };
+});
+jest.mock("../genericUtils", function () {
+    return { wait: jest.fn().mockResolvedValue(undefined) };
+});
+const snClient_1 = require("../snClient");
+function makeAxiosError(status) {
+    var error = new Error("Request failed with status " + status);
+    error.isAxiosError = true;
+    error.response = { status: status, headers: {}, data: {} };
+    return error;
+}
+function makeAxiosResponse(data) {
+    return { status: 200, data: data, headers: {}, statusText: "OK", config: {} };
+}
+describe("_callDovetailApi 404 fallback", function () {
+    beforeEach(function () {
+        (0, snClient_1._resetDovetailApiFallback)();
+        jest.clearAllMocks();
+    });
+    it("first request hits /api/cadso/dovetail/<op>", async function () {
+        var seen = [];
+        var call = jest.fn(async function (endpoint) {
+            seen.push(endpoint);
+            return makeAxiosResponse({ ok: true });
+        });
+        await (0, snClient_1._callDovetailApi)("changeScope", call);
+        expect(seen).toEqual(["api/cadso/dovetail/changeScope"]);
+        expect((0, snClient_1._isUsingLegacyClaudePath)()).toBe(false);
+    });
+    it("on 404, retries against legacy /api/cadso/claude/<op> and warns once", async function () {
+        var seen = [];
+        var call = jest.fn(async function (endpoint) {
+            seen.push(endpoint);
+            if (endpoint.indexOf("api/cadso/dovetail/") === 0) {
+                throw makeAxiosError(404);
+            }
+            return makeAxiosResponse({ ok: true });
+        });
+        var result = await (0, snClient_1._callDovetailApi)("changeScope", call);
+        expect(result.data).toEqual({ ok: true });
+        expect(seen).toEqual([
+            "api/cadso/dovetail/changeScope",
+            "api/cadso/claude/changeScope",
+        ]);
+        expect((0, snClient_1._isUsingLegacyClaudePath)()).toBe(true);
+        expect(mockLogger.warn).toHaveBeenCalledTimes(1);
+        expect(mockLogger.warn.mock.calls[0][0]).toContain("[deprecation]");
+        expect(mockLogger.warn.mock.calls[0][0]).toContain("/api/cadso/dovetail/changeScope");
+        expect(mockLogger.warn.mock.calls[0][0]).toContain("/api/cadso/claude/changeScope");
+    });
+    it("after latching, subsequent calls skip dovetail and warn no more", async function () {
+        var seen = [];
+        var call = jest.fn(async function (endpoint) {
+            seen.push(endpoint);
+            if (endpoint.indexOf("api/cadso/dovetail/") === 0) {
+                throw makeAxiosError(404);
+            }
+            return makeAxiosResponse({ ok: true });
+        });
+        await (0, snClient_1._callDovetailApi)("currentUpdateSet", call);
+        seen.length = 0;
+        mockLogger.warn.mockClear();
+        await (0, snClient_1._callDovetailApi)("changeScope", call);
+        await (0, snClient_1._callDovetailApi)("changeUpdateSet", call);
+        expect(seen).toEqual([
+            "api/cadso/claude/changeScope",
+            "api/cadso/claude/changeUpdateSet",
+        ]);
+        expect(mockLogger.warn).not.toHaveBeenCalled();
+    });
+    it("does NOT fall back on 401 (auth failure)", async function () {
+        var call = jest.fn(async function (_endpoint) {
+            throw makeAxiosError(401);
+        });
+        await expect((0, snClient_1._callDovetailApi)("changeScope", call)).rejects.toMatchObject({
+            response: { status: 401 },
+        });
+        expect(call).toHaveBeenCalledTimes(1);
+        expect((0, snClient_1._isUsingLegacyClaudePath)()).toBe(false);
+        expect(mockLogger.warn).not.toHaveBeenCalled();
+    });
+    it("does NOT fall back on 500 (server error)", async function () {
+        var call = jest.fn(async function (_endpoint) {
+            throw makeAxiosError(500);
+        });
+        await expect((0, snClient_1._callDovetailApi)("changeScope", call)).rejects.toMatchObject({
+            response: { status: 500 },
+        });
+        expect(call).toHaveBeenCalledTimes(1);
+        expect((0, snClient_1._isUsingLegacyClaudePath)()).toBe(false);
+        expect(mockLogger.warn).not.toHaveBeenCalled();
+    });
+    it("does NOT fall back on a network error with no response", async function () {
+        var call = jest.fn(async function (_endpoint) {
+            throw new Error("ECONNREFUSED");
+        });
+        await expect((0, snClient_1._callDovetailApi)("changeScope", call)).rejects.toThrow("ECONNREFUSED");
+        expect(call).toHaveBeenCalledTimes(1);
+        expect((0, snClient_1._isUsingLegacyClaudePath)()).toBe(false);
+        expect(mockLogger.warn).not.toHaveBeenCalled();
+    });
+});

package/dist/tests/syncManifestRefresh.test.js

@@ -0,0 +1,287 @@
+"use strict";
+/**
+ * Tests for the refresh content-compare path.
+ *
+ * Regression target: `npx dove 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/dove.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 dove refresh` iterated every scope in the persisted multi-scope
+ *    manifest, including scopes not declared in dove.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/dove.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");
+    });
+});