@tenonhq/dovetail-core 0.0.124 → 0.0.126

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);
+    });
+});

package/dist/updateSetCommands.js

@@ -297,7 +297,7 @@ async function switchUpdateSetCommand(args) {
     try {
         const client = (0, snClient_1.defaultClient)();
         // Get update set to switch to
-        const targetUpdateSet = await selectUpdateSet(args.name, args.scope);
+        const targetUpdateSet = await selectUpdateSet(args.name, args.scope, args.sysId);
         if (!targetUpdateSet) {
             throw new Error("No update set selected");
         }
@@ -633,8 +633,16 @@ async function getCurrentUpdateSetDetails(scope) {
 /**
  * Helper function to select an update set from a list
  */
-async function selectUpdateSet(nameFilter, scopeFilter) {
+async function selectUpdateSet(nameFilter, scopeFilter, sysIdFilter) {
     let query = "state=in progress";
+    // An exact sys_id is unambiguous where a name may not be (two in-progress
+    // sets can share a name). Validate it before it reaches the encoded query.
+    if (sysIdFilter !== undefined) {
+        if (typeof sysIdFilter !== "string" || !/^[0-9a-f]{32}$/i.test(sysIdFilter)) {
+            Logger_1.logger.error(`Invalid --sysId "${String(sysIdFilter)}": expected a 32-character sys_id`);
+            return null;
+        }
+    }
     if (scopeFilter) {
         const client = (0, snClient_1.defaultClient)();
         const scopeResult = await (0, snClient_1.unwrapSNResponse)(client.getScopeId(scopeFilter));
@@ -644,6 +652,15 @@ async function selectUpdateSet(nameFilter, scopeFilter) {
         }
         query += `^application=${scopeResult[0].sys_id}`;
     }
+    if (sysIdFilter !== undefined) {
+        const byId = await getUpdateSets(`${query}^sys_id=${sysIdFilter}`);
+        if (byId.length === 0) {
+            Logger_1.logger.error(`No in-progress update set with sys_id ${sysIdFilter}` +
+                (scopeFilter ? ` in scope "${scopeFilter}"` : ""));
+            return null;
+        }
+        return byId[0];
+    }
     const updateSets = await getUpdateSets(query);
     if (updateSets.length === 0) {
         Logger_1.logger.info("No in-progress update sets found");

package/package.json

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