@tenonhq/dovetail-core 0.0.125 → 0.0.126

package/dist/tests/gitHead.test.js

@@ -0,0 +1,65 @@
+"use strict";
+// readGitHead backs the watcher's branch-switch guard. It must resolve the
+// HEAD commit inside a work tree and resolve null (never throw) elsewhere.
+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"));
+const gitHead_1 = require("../gitHead");
+describe("readGitHead", function () {
+    it("resolves the HEAD commit id inside a git work tree", async function () {
+        // This test file lives inside the repository's own work tree.
+        var head = await (0, gitHead_1.readGitHead)(__dirname);
+        expect(head).toMatch(/^[0-9a-f]{40}([0-9a-f]{24})?$/);
+    });
+    it("resolves null outside a git work tree", async function () {
+        var dir = fs.mkdtempSync(path.join(os.tmpdir(), "dove-githead-"));
+        try {
+            expect(await (0, gitHead_1.readGitHead)(dir)).toBeNull();
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    it("resolves null for a directory that does not exist", async function () {
+        var head = await (0, gitHead_1.readGitHead)(path.join(os.tmpdir(), "dove-githead-missing-" + Date.now()));
+        expect(head).toBeNull();
+    });
+    it("resolves null for an empty or non-string dir", async function () {
+        expect(await (0, gitHead_1.readGitHead)("")).toBeNull();
+        expect(await (0, gitHead_1.readGitHead)(undefined)).toBeNull();
+    });
+});

package/dist/tests/multi-scope-watcher.test.js

@@ -103,6 +103,11 @@ jest.mock("../logMessages", () => ({
 jest.mock("../recentEdits", () => ({
     writeRecentEdit: jest.fn(),
 }));
+// Branch-switch guard: default to "not a git work tree" (guard off) so the
+// existing tests keep today's behaviour; the guard block overrides it.
+jest.mock("../gitHead", () => ({
+    readGitHead: jest.fn().mockResolvedValue(null),
+}));
 jest.mock("../Logger", () => ({
     logger: {
         info: jest.fn(),
@@ -152,6 +157,7 @@ const ConfigManager = __importStar(require("../config"));
 const FileUtils_1 = require("../FileUtils");
 const appUtils_1 = require("../appUtils");
 const Logger_1 = require("../Logger");
+const gitHead_1 = require("../gitHead");
 const MultiScopeWatcher_1 = require("../MultiScopeWatcher");
 // Helper to flush microtask queue (for async code in setInterval callbacks)
 const flushPromises = () => new Promise((resolve) => setImmediate(resolve));
@@ -400,6 +406,77 @@ describe("MultiScopeWatcherManager", () => {
             expect(Logger_1.logger.error).toHaveBeenCalledWith(expect.stringContaining("Watcher error: FS error"));
         });
     });
+    describe("branch-switch guard (git HEAD)", () => {
+        var HEAD_A = "a".repeat(40);
+        var HEAD_B = "b".repeat(40);
+        beforeEach(async () => {
+            ConfigManager.getConfig.mockReturnValue({
+                ...MOCK_CONFIG_TWO_SCOPES,
+                scopes: { x_test_core: { sourceDirectory: "src/x_test_core" } },
+            });
+            fs_1.default.existsSync.mockReturnValue(false);
+            FileUtils_1.getFileContextWithSkipReason.mockReturnValue({ context: makeFileContext() });
+            appUtils_1.groupAppFiles.mockReturnValue([{ table: "sys_script_include", sysId: "abc123", fields: {} }]);
+            appUtils_1.pushFiles.mockResolvedValue([{ success: true, message: "ok" }]);
+        });
+        afterEach(() => {
+            gitHead_1.readGitHead.mockReset();
+            gitHead_1.readGitHead.mockResolvedValue(null);
+        });
+        it("reads HEAD in the project root at start", async () => {
+            gitHead_1.readGitHead.mockResolvedValue(HEAD_A);
+            await (0, MultiScopeWatcher_1.startMultiScopeWatching)();
+            expect(gitHead_1.readGitHead).toHaveBeenCalledWith("/project");
+        });
+        it("pushes when HEAD is unchanged at flush time", async () => {
+            gitHead_1.readGitHead.mockResolvedValue(HEAD_A);
+            await (0, MultiScopeWatcher_1.startMultiScopeWatching)();
+            mockWatchers[0]._emit("change", makeFileContext().filePath);
+            await capturedDebounceFns[0]();
+            expect(gitHead_1.readGitHead).toHaveBeenCalledTimes(2);
+            expect(appUtils_1.pushFiles).toHaveBeenCalledTimes(1);
+            expect(Logger_1.logger.error).not.toHaveBeenCalledWith(expect.stringContaining("Git HEAD changed"));
+        });
+        it("drops the queue, pushes nothing, logs an error and pauses when HEAD moves between enqueue and flush", async () => {
+            gitHead_1.readGitHead.mockResolvedValue(HEAD_A);
+            await (0, MultiScopeWatcher_1.startMultiScopeWatching)();
+            mockWatchers[0]._emit("change", makeFileContext().filePath);
+            // A `git checkout` lands before the debounce fires.
+            gitHead_1.readGitHead.mockResolvedValue(HEAD_B);
+            await capturedDebounceFns[0]();
+            expect(appUtils_1.pushFiles).not.toHaveBeenCalled();
+            expect(mockSNClient.changeScope).not.toHaveBeenCalled();
+            expect(Logger_1.logger.error).toHaveBeenCalledWith(expect.stringContaining("Git HEAD changed"));
+            expect(Logger_1.logger.error).toHaveBeenCalledWith(expect.stringContaining("restart"));
+            var internals = MultiScopeWatcher_1.multiScopeWatcher;
+            expect(internals.pendingScopes.size).toBe(0);
+            internals.scopeWatchers.forEach(function (w) {
+                expect(w.pushQueue).toEqual([]);
+            });
+            // Paused: even if HEAD goes back, later changes are not pushed until restart.
+            gitHead_1.readGitHead.mockResolvedValue(HEAD_A);
+            mockWatchers[0]._emit("change", makeFileContext().filePath);
+            await capturedDebounceFns[0]();
+            expect(appUtils_1.pushFiles).not.toHaveBeenCalled();
+        });
+        it("treats an unreadable HEAD after start as a change (fail safe)", async () => {
+            gitHead_1.readGitHead.mockResolvedValue(HEAD_A);
+            await (0, MultiScopeWatcher_1.startMultiScopeWatching)();
+            mockWatchers[0]._emit("change", makeFileContext().filePath);
+            gitHead_1.readGitHead.mockResolvedValue(null);
+            await capturedDebounceFns[0]();
+            expect(appUtils_1.pushFiles).not.toHaveBeenCalled();
+            expect(Logger_1.logger.error).toHaveBeenCalledWith(expect.stringContaining("unreadable"));
+        });
+        it("behaves as before outside a git work tree (no HEAD at start)", async () => {
+            gitHead_1.readGitHead.mockResolvedValue(null);
+            await (0, MultiScopeWatcher_1.startMultiScopeWatching)();
+            mockWatchers[0]._emit("change", makeFileContext().filePath);
+            await capturedDebounceFns[0]();
+            expect(gitHead_1.readGitHead).toHaveBeenCalledTimes(1);
+            expect(appUtils_1.pushFiles).toHaveBeenCalledTimes(1);
+        });
+    });
     describe("processScopeQueue - empty queue", () => {
         it("returns early when queue is empty", async () => {
             ConfigManager.getConfig.mockReturnValue({

package/dist/tests/pullRecord.test.js

@@ -517,6 +517,87 @@ describe("planPull — renamed record", function () {
         expect(plan.warnings.join("\n")).toMatch(/formatting differs/);
     });
 });
+describe("planPull — manifest key collisions (never overwrite another sys_id)", function () {
+    const TABLE = "sys_one_extend_capability";
+    const ID_DUP = "ddddddddddddddddddddddddddddddd4";
+    const NAME = "Skill Capability";
+    function metaFolder(key) {
+        return path.join(tmpRoot, "src", SCOPE, TABLE, key, "metaData.json");
+    }
+    test("two same-named metaData-only records pulled one after the other → both entries + both folders survive", async function () {
+        mockClient.getMissingFiles.mockResolvedValue(bulkDownload(TABLE, ID_META_ONLY, NAME, []));
+        await (0, pullRecord_1.applyPull)(await (0, pullRecord_1.planPull)([{ table: TABLE, sysId: ID_META_ONLY }]));
+        mockClient.getMissingFiles.mockResolvedValue(bulkDownload(TABLE, ID_DUP, NAME, []));
+        const plan = await (0, pullRecord_1.planPull)([{ table: TABLE, sysId: ID_DUP }]);
+        const dupKey = NAME + " (" + ID_DUP.substring(0, 8) + ")";
+        expect(plan.records[0].key).toBe(dupKey);
+        expect(plan.records[0].manifestAction).toBe("add");
+        await (0, pullRecord_1.applyPull)(plan);
+        const records = JSON.parse(readLocalManifest()).tables[TABLE].records;
+        expect(Object.keys(records)).toEqual([NAME, dupKey]);
+        expect(records[NAME].sys_id).toBe(ID_META_ONLY);
+        expect(records[dupKey]).toEqual({ files: [], name: dupKey, sys_id: ID_DUP });
+        expect(JSON.parse(fs.readFileSync(metaFolder(NAME), "utf8"))._sys_id).toBe(ID_META_ONLY);
+        expect(JSON.parse(fs.readFileSync(metaFolder(dupKey), "utf8"))._sys_id).toBe(ID_DUP);
+        // re-pulling either record is a no-op: the suffixed key is stable
+        const again = await (0, pullRecord_1.planPull)([{ table: TABLE, sysId: ID_DUP }]);
+        expect(again.records[0].key).toBe(dupKey);
+        expect(again.records[0].manifestAction).toBe("unchanged");
+        mockClient.getMissingFiles.mockResolvedValue(bulkDownload(TABLE, ID_META_ONLY, NAME, []));
+        const first = await (0, pullRecord_1.planPull)([{ table: TABLE, sysId: ID_META_ONLY }]);
+        expect(first.records[0].key).toBe(NAME);
+        expect(first.records[0].manifestAction).toBe("unchanged");
+    });
+    test("two same-named metaData-only records in ONE batch → both entries + both folders survive", async function () {
+        const a = bulkDownload(TABLE, ID_META_ONLY, NAME, [])[TABLE].records[NAME];
+        const b = bulkDownload(TABLE, ID_DUP, NAME, [])[TABLE].records[NAME];
+        mockClient.getMissingFiles.mockResolvedValue({ [TABLE]: { records: { [ID_META_ONLY]: a, [ID_DUP]: b } } });
+        const plan = await (0, pullRecord_1.planPull)([{ table: TABLE, sysId: ID_META_ONLY }, { table: TABLE, sysId: ID_DUP }]);
+        const dupKey = NAME + " (" + ID_DUP.substring(0, 8) + ")";
+        expect(plan.records.map(function (r) { return r.key + ":" + r.manifestAction; }))
+            .toEqual([NAME + ":add", dupKey + ":add"]);
+        await (0, pullRecord_1.applyPull)(plan);
+        const records = JSON.parse(readLocalManifest()).tables[TABLE].records;
+        expect(Object.keys(records)).toEqual([NAME, dupKey]);
+        expect(records[NAME].sys_id).toBe(ID_META_ONLY);
+        expect(records[dupKey].sys_id).toBe(ID_DUP);
+        expect(JSON.parse(fs.readFileSync(metaFolder(NAME), "utf8"))._sys_id).toBe(ID_META_ONLY);
+        expect(JSON.parse(fs.readFileSync(metaFolder(dupKey), "utf8"))._sys_id).toBe(ID_DUP);
+    });
+    test("a fallback key never takes a key the server manifest gives another record", async function () {
+        mockClient.getManifest.mockResolvedValue({
+            scope: SCOPE,
+            tables: { [TABLE]: { records: { [NAME]: { name: NAME, sys_id: ID_META_ONLY, files: [{ name: "script", type: "js" }] } } } },
+        });
+        mockClient.getMissingFiles.mockResolvedValue(bulkDownload(TABLE, ID_DUP, NAME, []));
+        const plan = await (0, pullRecord_1.planPull)([{ table: TABLE, sysId: ID_DUP }]);
+        expect(plan.records[0].key).toBe(NAME + " (" + ID_DUP.substring(0, 8) + ")");
+    });
+    test("a server-provided key held locally by a DIFFERENT sys_id → refused, points at dove refresh -t, writes nothing", async function () {
+        // Local manifest says "Sibling" is ID_SIB; the server now hands "Sibling" to
+        // another record (its duplicate-suffix order moved since the last refresh).
+        seedSibling();
+        writeLocalManifest(localManifestWithSibling(), true);
+        const before = snapshot(tmpRoot);
+        mockClient.getManifest.mockResolvedValue({
+            scope: SCOPE,
+            tables: { sys_script_include: { records: {
+                        Sibling: { name: "Sibling", sys_id: ID_NEW, files: [{ name: "script", type: "js" }] },
+                    } } },
+        });
+        await expect((0, pullRecord_1.planPull)([{ table: "sys_script_include", sysId: ID_NEW }]))
+            .rejects.toThrow(/manifest key 'Sibling' already belongs to sys_id aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1[\s\S]*dove refresh -t sys_script_include/);
+        expect(mockClient.getMissingFiles).not.toHaveBeenCalled();
+        expect(snapshot(tmpRoot)).toEqual(before);
+    });
+    test("spliceManifestRecord refuses to overwrite a key held by a different sys_id", function () {
+        expect(function () {
+            (0, pullRecord_1.spliceManifestRecord)(localManifestWithSibling(), SCOPE, "sys_script_include", {
+                files: [], name: "Sibling", sys_id: ID_NEW,
+            });
+        }).toThrow(/already belongs to sys_id/);
+    });
+});
 // ---------- --from-update-set ----------
 describe("targetsFromUpdateSet", function () {
     const SET = "d".repeat(32);

package/dist/tests/reconcileCreateGuard.test.js

@@ -0,0 +1,60 @@
+"use strict";
+// `dove reconcile --apply` creates net-new branch records through
+// snClient.createRecord. A sys_update_set record in the branch must not crash
+// the apply or be silently created in the session app: the createRecord guard
+// refuses it and the refusal surfaces as a named, per-record failure (which
+// applyMode lists and turns into exit code 1).
+Object.defineProperty(exports, "__esModule", { value: true });
+jest.mock("../Logger", function () {
+    return {
+        logger: {
+            info: jest.fn(),
+            debug: jest.fn(),
+            warn: jest.fn(),
+            error: jest.fn(),
+            success: jest.fn(),
+            getLogLevel: function () { return "debug"; },
+        },
+    };
+});
+jest.mock("../FileLogger", function () {
+    return { fileLogger: { debug: jest.fn(), info: jest.fn(), warn: jest.fn(), error: jest.fn() } };
+});
+jest.mock("../config", function () {
+    return {
+        getSourcePathForScope: function () {
+            return "/nonexistent-reconcile-source";
+        },
+    };
+});
+var mockPost = jest.fn();
+jest.mock("../snClient", function () {
+    var actual = jest.requireActual("../snClient");
+    var client = actual.snClient("https://x.service-now.com/", "u", "p");
+    client.client.post = mockPost;
+    return Object.assign({}, actual, {
+        defaultClient: function () {
+            return client;
+        },
+    });
+});
+const reconcileCommand_1 = require("../reconcileCommand");
+describe("reconcile applyCreates with a sys_update_set record", function () {
+    it("reports a clear per-record failure and never posts", async function () {
+        var change = {
+            kind: "create",
+            table: "sys_update_set",
+            scope: "x_s",
+            sys_id: "abc123",
+            name: "Foo",
+            fieldDeltas: [],
+        };
+        var outcomes = await (0, reconcileCommand_1.applyCreates)("x_s", [change], "us1");
+        expect(outcomes).toHaveLength(1);
+        expect(outcomes[0].ok).toBe(false);
+        expect(outcomes[0].change.sys_id).toBe("abc123");
+        expect(outcomes[0].error).toMatch(/Refusing to insert sys_update_set/);
+        expect(outcomes[0].error).toMatch(/dove createUpdateSet/);
+        expect(mockPost).not.toHaveBeenCalled();
+    });
+});

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

@@ -0,0 +1,35 @@
+"use strict";
+// snClient.createRecord refuses tables the generic createRecord op cannot
+// write correctly. sys_update_set: the op never sets `application`, so the set
+// would land in the session app — callers must use createUpdateSet instead.
+// The refusal happens before any HTTP call.
+Object.defineProperty(exports, "__esModule", { value: true });
+jest.mock("../Logger", function () {
+    return {
+        logger: {
+            info: jest.fn(),
+            debug: jest.fn(),
+            warn: jest.fn(),
+            error: jest.fn(),
+            getLogLevel: function () { return "debug"; },
+        },
+    };
+});
+jest.mock("../FileLogger", function () {
+    return { fileLogger: { debug: jest.fn(), info: jest.fn(), warn: jest.fn(), error: jest.fn() } };
+});
+const snClient_1 = require("../snClient");
+describe("snClient.createRecord guards", function () {
+    it("rejects sys_update_set without posting, pointing at dove createUpdateSet", async function () {
+        var c = (0, snClient_1.snClient)("https://x.service-now.com/", "u", "p");
+        var post = jest.spyOn(c.client, "post");
+        await expect(c.createRecord({ table: "sys_update_set", fields: { name: "Foo" }, scope: "x_s" })).rejects.toThrow(/dove createUpdateSet/);
+        expect(post).not.toHaveBeenCalled();
+    });
+    it("still rejects sys_db_object without posting", async function () {
+        var c = (0, snClient_1.snClient)("https://x.service-now.com/", "u", "p");
+        var post = jest.spyOn(c.client, "post");
+        await expect(c.createRecord({ table: "sys_db_object", fields: { name: "x_t" } })).rejects.toThrow(/sys_db_object/);
+        expect(post).not.toHaveBeenCalled();
+    });
+});

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

@@ -0,0 +1,67 @@
+"use strict";
+// snClient.getScopeId must resolve a scope name to exactly one sys_scope row.
+// `scope=global` also matches sys_app rows on live instances, so Global is
+// addressed by its fixed sys_id; any other name with >1 row is refused.
+Object.defineProperty(exports, "__esModule", { value: true });
+jest.mock("../Logger", function () {
+    return {
+        logger: {
+            info: jest.fn(),
+            debug: jest.fn(),
+            warn: jest.fn(),
+            error: jest.fn(),
+            getLogLevel: function () { return "debug"; },
+        },
+    };
+});
+jest.mock("../FileLogger", function () {
+    return { fileLogger: { debug: jest.fn(), info: jest.fn(), warn: jest.fn(), error: jest.fn() } };
+});
+const snClient_1 = require("../snClient");
+// Rows keyed by the encoded query the client sends.
+function stubGet(c, rowsByQuery) {
+    var queries = [];
+    jest.spyOn(c.client, "get").mockImplementation(async function (_url, config) {
+        var params = (config && config.params);
+        var q = (params && params.sysparm_query) || "";
+        queries.push(q);
+        return {
+            status: 200,
+            statusText: "OK",
+            headers: {},
+            config: {},
+            data: { result: rowsByQuery[q] || [] },
+        };
+    });
+    return queries;
+}
+describe("snClient.getScopeId", function () {
+    it("resolves global to the real Global scope even when sys_app rows share scope=global", async function () {
+        var c = (0, snClient_1.snClient)("https://x.service-now.com/", "u", "p");
+        var queries = stubGet(c, {
+            "scope=global": [{ sys_id: "489827aabbccdd" }, { sys_id: "global" }],
+            "sys_id=global": [{ sys_id: "global" }],
+        });
+        var rows = await (0, snClient_1.unwrapSNResponse)(c.getScopeId("global"));
+        expect(rows).toHaveLength(1);
+        expect(rows[0].sys_id).toBe("global");
+        expect(queries).toEqual(["sys_id=global"]);
+    });
+    it("throws when a non-global scope name matches more than one row", async function () {
+        var c = (0, snClient_1.snClient)("https://x.service-now.com/", "u", "p");
+        stubGet(c, { "scope=x_dup": [{ sys_id: "a1" }, { sys_id: "b2" }] });
+        await expect(c.getScopeId("x_dup")).rejects.toThrow(/ambiguous.*a1, b2/);
+    });
+    it("returns the single row for an unambiguous scope", async function () {
+        var c = (0, snClient_1.snClient)("https://x.service-now.com/", "u", "p");
+        stubGet(c, { "scope=x_one": [{ sys_id: "s1" }] });
+        var rows = await (0, snClient_1.unwrapSNResponse)(c.getScopeId("x_one"));
+        expect(rows).toEqual([{ sys_id: "s1" }]);
+    });
+    it("returns no rows for an unknown scope (callers handle the empty case)", async function () {
+        var c = (0, snClient_1.snClient)("https://x.service-now.com/", "u", "p");
+        stubGet(c, {});
+        var rows = await (0, snClient_1.unwrapSNResponse)(c.getScopeId("x_missing"));
+        expect(rows).toEqual([]);
+    });
+});

package/dist/tests/switchUpdateSetSysId.test.js

@@ -0,0 +1,83 @@
+"use strict";
+// `dove switchUpdateSet --sysId <id>` selects the in-progress set by exact
+// sys_id, so two same-named sets can't be confused. Invalid ids are refused
+// before any query; an id with no in-progress match is an error, not a prompt.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var mockLogger = {
+    info: jest.fn(),
+    error: jest.fn(),
+    warn: jest.fn(),
+    debug: jest.fn(),
+    success: jest.fn(),
+    getLogLevel: jest.fn().mockReturnValue("info"),
+};
+jest.mock("../Logger", function () {
+    return { logger: mockLogger };
+});
+jest.mock("../commands", function () {
+    return { setLogLevel: jest.fn() };
+});
+var mockWriteRouting = jest.fn().mockReturnValue(true);
+jest.mock("../updateSetConfig", function () {
+    return { writeUpdateSetRouting: mockWriteRouting };
+});
+jest.mock("inquirer", function () {
+    return { prompt: jest.fn() };
+});
+var TARGET_ID = "0123456789abcdef0123456789abcdef";
+var SCOPE_SYS_ID = "scopeSysId0000000000000000000001";
+var mockGet = jest.fn();
+var mockClient = {
+    getScopeId: jest.fn(),
+    changeUpdateSet: jest.fn(),
+    getCurrentUpdateSet: jest.fn(),
+    getScopeById: jest.fn(),
+    client: { get: mockGet },
+};
+jest.mock("../snClient", function () {
+    return {
+        defaultClient: jest.fn(function () { return mockClient; }),
+        unwrapSNResponse: jest.fn(async function (p) {
+            var resp = await p;
+            return resp.data.result;
+        }),
+        unwrapTableAPIFirstItem: jest.fn(),
+    };
+});
+const inquirer_1 = __importDefault(require("inquirer"));
+const updateSetCommands_1 = require("../updateSetCommands");
+function axiosResult(result) {
+    return Promise.resolve({ data: { result: result } });
+}
+describe("switchUpdateSet --sysId", function () {
+    beforeEach(function () {
+        jest.clearAllMocks();
+        mockClient.getScopeId.mockReturnValue(axiosResult([{ sys_id: SCOPE_SYS_ID }]));
+        mockClient.changeUpdateSet.mockResolvedValue({ data: { result: { message: "Success" } } });
+        mockClient.getCurrentUpdateSet.mockResolvedValue({ data: { result: { sysId: TARGET_ID } } });
+    });
+    it("queries by exact sys_id within the scope and switches to that set", async function () {
+        mockGet.mockReturnValue(axiosResult([{ sys_id: TARGET_ID, name: "Dup Name", application: { value: SCOPE_SYS_ID, display_value: "App" } }]));
+        await (0, updateSetCommands_1.switchUpdateSetCommand)({ sysId: TARGET_ID, scope: "x_app", logLevel: "info" });
+        expect(mockGet).toHaveBeenCalledTimes(1);
+        var query = mockGet.mock.calls[0][1].params.sysparm_query;
+        expect(query).toBe("state=in progress^application=" + SCOPE_SYS_ID + "^sys_id=" + TARGET_ID);
+        expect(mockClient.changeUpdateSet).toHaveBeenCalledWith(expect.objectContaining({ sysId: TARGET_ID }));
+        expect(mockWriteRouting).toHaveBeenCalledWith({ scope: "x_app", sysId: TARGET_ID, name: "Dup Name" });
+        expect(inquirer_1.default.prompt).not.toHaveBeenCalled();
+    });
+    it("refuses a malformed sys_id before querying", async function () {
+        await expect((0, updateSetCommands_1.switchUpdateSetCommand)({ sysId: "abc^name=x", scope: "x_app", logLevel: "info" })).rejects.toThrow(/No update set selected/);
+        expect(mockGet).not.toHaveBeenCalled();
+        expect(mockClient.changeUpdateSet).not.toHaveBeenCalled();
+    });
+    it("errors (no prompt, no switch) when no in-progress set has that sys_id", async function () {
+        mockGet.mockReturnValue(axiosResult([]));
+        await expect((0, updateSetCommands_1.switchUpdateSetCommand)({ sysId: TARGET_ID, scope: "x_app", logLevel: "info" })).rejects.toThrow(/No update set selected/);
+        expect(mockClient.changeUpdateSet).not.toHaveBeenCalled();
+        expect(inquirer_1.default.prompt).not.toHaveBeenCalled();
+    });
+});

package/dist/tests/watchClaudeGuard.test.js

@@ -0,0 +1,132 @@
+"use strict";
+// Handler-level tests for the Claude Code guard on the human-only watcher
+// (watchAllScopesCommand, TenonHQ/Dovetail#155):
+//   - CLAUDECODE set          -> exit 1 before the watcher starts;
+//   - CLAUDECODE + override   -> warns, starts;
+//   - only a CLAUDE_CODE_* config variable (a human shell) -> warns, starts.
+// The watcher module is mocked, so nothing is watched or pushed.
+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"; },
+};
+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("../config", function () { return {}; });
+jest.mock("../snClient", function () {
+    return {
+        defaultClient: function () { return {}; },
+        unwrapSNResponse: function (p) { return Promise.resolve(p); },
+    };
+});
+jest.mock("../wizard", function () {
+    return { setupDotEnv: jest.fn(), getLoginInfo: jest.fn() };
+});
+jest.mock("../commands", function () { return { setLogLevel: jest.fn() }; });
+var mockStartWatching = jest.fn().mockResolvedValue(undefined);
+jest.mock("../MultiScopeWatcher", function () {
+    return { startMultiScopeWatching: mockStartWatching, stopMultiScopeWatching: jest.fn() };
+});
+const allScopesCommands_1 = require("../allScopesCommands");
+const claudeSession_1 = require("../claudeSession");
+class ExitSignal extends Error {
+    code;
+    constructor(code) {
+        super("process.exit(" + code + ")");
+        this.code = code;
+    }
+}
+var ARGS = { logLevel: "info", noDashboard: true, noMonitoring: true };
+// Every env key this suite touches. The suite may itself run inside a Claude
+// Code shell, so the Claude markers are cleared before each test.
+function isManagedKey(key) {
+    return (key === "CLAUDECODE" ||
+        key.indexOf("CLAUDE_CODE_") === 0 ||
+        key === claudeSession_1.WATCH_ALLOW_IN_CLAUDE_ENV ||
+        key === "SN_USER" ||
+        key === "SN_INSTANCE" ||
+        key === "SN_PASSWORD");
+}
+describe("watchAllScopesCommand Claude Code guard", function () {
+    var savedEnv = {};
+    var exitSpy;
+    var sigintBefore = [];
+    beforeEach(function () {
+        jest.clearAllMocks();
+        savedEnv = {};
+        Object.keys(process.env).forEach(function (key) {
+            if (isManagedKey(key)) {
+                savedEnv[key] = process.env[key];
+                delete process.env[key];
+            }
+        });
+        process.env.SN_USER = "test-user";
+        process.env.SN_INSTANCE = "example.service-now.com";
+        process.env.SN_PASSWORD = "not-a-real-value";
+        sigintBefore = process.listeners("SIGINT").slice();
+        exitSpy = jest
+            .spyOn(process, "exit")
+            .mockImplementation(function (code) {
+            throw new ExitSignal(typeof code === "number" ? code : undefined);
+        });
+    });
+    afterEach(function () {
+        exitSpy.mockRestore();
+        process.listeners("SIGINT").forEach(function (listener) {
+            if (sigintBefore.indexOf(listener) === -1) {
+                process.removeListener("SIGINT", listener);
+            }
+        });
+        Object.keys(process.env).forEach(function (key) {
+            if (isManagedKey(key)) {
+                delete process.env[key];
+            }
+        });
+        Object.keys(savedEnv).forEach(function (key) {
+            if (savedEnv[key] !== undefined) {
+                process.env[key] = savedEnv[key];
+            }
+        });
+    });
+    it("exits 1 before starting the watcher when CLAUDECODE is set", async function () {
+        process.env.CLAUDECODE = "1";
+        await expect((0, allScopesCommands_1.watchAllScopesCommand)(ARGS)).rejects.toBeInstanceOf(ExitSignal);
+        expect(exitSpy).toHaveBeenCalledWith(1);
+        expect(mockStartWatching).not.toHaveBeenCalled();
+        expect(mockLogger.error).toHaveBeenCalledWith(claudeSession_1.WATCH_BLOCKED_IN_CLAUDE_ERROR);
+        expect(claudeSession_1.WATCH_BLOCKED_IN_CLAUDE_ERROR).toContain(claudeSession_1.WATCH_ALLOW_IN_CLAUDE_ENV + "=1");
+    });
+    it("starts (with the warning) when CLAUDECODE is set and the human override is 1", async function () {
+        process.env.CLAUDECODE = "1";
+        process.env[claudeSession_1.WATCH_ALLOW_IN_CLAUDE_ENV] = "1";
+        await (0, allScopesCommands_1.watchAllScopesCommand)(ARGS);
+        expect(exitSpy).not.toHaveBeenCalled();
+        expect(mockStartWatching).toHaveBeenCalledTimes(1);
+        expect(mockLogger.warn).toHaveBeenCalledWith(claudeSession_1.WATCH_HUMAN_ONLY_WARNING);
+    });
+    it("does not treat an override other than 1 as consent", async function () {
+        process.env.CLAUDECODE = "1";
+        process.env[claudeSession_1.WATCH_ALLOW_IN_CLAUDE_ENV] = "true";
+        await expect((0, allScopesCommands_1.watchAllScopesCommand)(ARGS)).rejects.toBeInstanceOf(ExitSignal);
+        expect(mockStartWatching).not.toHaveBeenCalled();
+    });
+    it("only warns (and starts) for a human shell with a CLAUDE_CODE_* config variable", async function () {
+        process.env.CLAUDE_CODE_USE_BEDROCK = "1";
+        await (0, allScopesCommands_1.watchAllScopesCommand)(ARGS);
+        expect(exitSpy).not.toHaveBeenCalled();
+        expect(mockStartWatching).toHaveBeenCalledTimes(1);
+        expect(mockLogger.warn).toHaveBeenCalledWith(claudeSession_1.WATCH_HUMAN_ONLY_WARNING);
+    });
+    it("starts silently with no Claude markers at all", async function () {
+        await (0, allScopesCommands_1.watchAllScopesCommand)(ARGS);
+        expect(exitSpy).not.toHaveBeenCalled();
+        expect(mockStartWatching).toHaveBeenCalledTimes(1);
+        expect(mockLogger.warn).not.toHaveBeenCalledWith(claudeSession_1.WATCH_HUMAN_ONLY_WARNING);
+    });
+});