@tenonhq/dovetail-core 0.0.124 → 0.0.126

package/dist/tests/envArg.test.js

@@ -1,26 +1,37 @@
 "use strict";
 // Tests for the per-command `--env` flag parser (envArg.ts). Covers the flag
 // spellings (--env, --env-file, --envFile, -e), `=` and space-separated forms,
-// last-wins precedence, absence, and absolute/relative path resolution.
+// last-wins precedence, absence, and resolution of bare instance names,
+// explicit env filenames, and relative/absolute paths.
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const envArg_1 = require("../envArg");
+// The conventional per-instance env-file prefix (`prod` → `<prefix>prod`).
+var ENV_PREFIX = ".env.";
 describe("parseEnvArg", function () {
     it("returns undefined when no env flag is present", function () {
         expect((0, envArg_1.parseEnvArg)(["push", "--diff", "main"])).toBeUndefined();
     });
     it("parses --env <path> (space-separated)", function () {
-        expect((0, envArg_1.parseEnvArg)(["push", "--env", ".env.prod"])).toBe(".env.prod");
+        expect((0, envArg_1.parseEnvArg)(["push", "--env", ENV_PREFIX + "prod"])).toBe(ENV_PREFIX + "prod");
+    });
+    it("parses --env <name> with a bare instance name", function () {
+        expect((0, envArg_1.parseEnvArg)(["refresh", "--env", "demo8"])).toBe("demo8");
     });
     it("parses --env=<path>", function () {
         expect((0, envArg_1.parseEnvArg)(["status", "--env=../envs/workshop.env"])).toBe("../envs/workshop.env");
     });
+    it("parses --env=<name> with a bare instance name", function () {
+        expect((0, envArg_1.parseEnvArg)(["push", "--env=demo8"])).toBe("demo8");
+    });
     it("parses the -e short alias (space and = forms)", function () {
-        expect((0, envArg_1.parseEnvArg)(["status", "-e", ".env.dev"])).toBe(".env.dev");
-        expect((0, envArg_1.parseEnvArg)(["status", "-e=.env.dev"])).toBe(".env.dev");
+        expect((0, envArg_1.parseEnvArg)(["status", "-e", ENV_PREFIX + "dev"])).toBe(ENV_PREFIX + "dev");
+        expect((0, envArg_1.parseEnvArg)(["status", "-e=" + ENV_PREFIX + "dev"])).toBe(ENV_PREFIX + "dev");
     });
     it("parses --env-file and --envFile spellings", function () {
         expect((0, envArg_1.parseEnvArg)(["push", "--env-file", "a.env"])).toBe("a.env");
@@ -29,21 +40,93 @@ describe("parseEnvArg", function () {
     it("takes the last occurrence when the flag is repeated", function () {
         expect((0, envArg_1.parseEnvArg)(["push", "--env", "first.env", "--env", "second.env"])).toBe("second.env");
     });
+    it("takes the last occurrence across mixed forms and spellings", function () {
+        expect((0, envArg_1.parseEnvArg)(["push", "--env=shop", "-e", "studio", "--env-file", "loft"])).toBe("loft");
+        expect((0, envArg_1.parseEnvArg)(["push", "-e", "studio", "--env=shop"])).toBe("shop");
+    });
     it("ignores a bare --env with no following value", function () {
         expect((0, envArg_1.parseEnvArg)(["push", "--env"])).toBeUndefined();
     });
     it("does not consume the next token when it looks like another flag", function () {
         expect((0, envArg_1.parseEnvArg)(["push", "--env", "--ci"])).toBeUndefined();
     });
-    it("treats an empty --env= as absent", function () {
+    it("treats an empty or whitespace-only --env= as absent", function () {
         expect((0, envArg_1.parseEnvArg)(["push", "--env="])).toBeUndefined();
+        expect((0, envArg_1.parseEnvArg)(["push", "--env=   "])).toBeUndefined();
+    });
+    it("returns undefined for a non-array argv", function () {
+        expect((0, envArg_1.parseEnvArg)(undefined)).toBeUndefined();
     });
 });
 describe("resolveEnvArgPath", function () {
+    var tmpDir;
+    beforeEach(function () {
+        tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "dove-envarg-"));
+    });
+    afterEach(function () {
+        fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+    });
     it("returns absolute paths unchanged", function () {
-        expect((0, envArg_1.resolveEnvArgPath)("/abs/path/.env", "/cwd")).toBe("/abs/path/.env");
+        var abs = path_1.default.join(tmpDir, "abs", ENV_PREFIX + "prod");
+        expect((0, envArg_1.resolveEnvArgPath)(abs, "/cwd")).toBe(abs);
+    });
+    it("resolves an absolute path that has no dot as a path, not a bare name", function () {
+        var abs = path_1.default.join(tmpDir, "creds");
+        expect((0, envArg_1.resolveEnvArgPath)(abs, "/cwd")).toBe(abs);
     });
     it("resolves relative paths against the provided cwd", function () {
-        expect((0, envArg_1.resolveEnvArgPath)(".env.prod", "/projects/sn")).toBe(path_1.default.join("/projects/sn", ".env.prod"));
+        expect((0, envArg_1.resolveEnvArgPath)("../envs/workshop.env", path_1.default.join(tmpDir, "repo"))).toBe(path_1.default.join(tmpDir, "envs", "workshop.env"));
+    });
+    it("treats a relative path without a dot in the basename as a path", function () {
+        expect((0, envArg_1.resolveEnvArgPath)(path_1.default.join("envs", "prod"), tmpDir)).toBe(path_1.default.join(tmpDir, "envs", "prod"));
+    });
+    it("uses an explicit env filename as-is (the file need not exist)", function () {
+        expect((0, envArg_1.resolveEnvArgPath)(ENV_PREFIX + "prod", tmpDir)).toBe(path_1.default.join(tmpDir, ENV_PREFIX + "prod"));
+    });
+    it("uses a dotted filename as-is even when it does not exist yet (dove login creates it)", function () {
+        expect((0, envArg_1.resolveEnvArgPath)("workshop.env", tmpDir)).toBe(path_1.default.join(tmpDir, "workshop.env"));
+    });
+    it("expands a bare instance name to the per-instance env file in cwd", function () {
+        expect((0, envArg_1.resolveEnvArgPath)("demo8", tmpDir)).toBe(path_1.default.join(tmpDir, ENV_PREFIX + "demo8"));
+    });
+    it("expands a bare name whether or not the target file exists", function () {
+        var target = path_1.default.join(tmpDir, ENV_PREFIX + "loft");
+        fs_1.default.writeFileSync(target, "");
+        expect((0, envArg_1.resolveEnvArgPath)("loft", tmpDir)).toBe(target);
+    });
+    it("prefers an existing literal file in cwd over bare-name expansion", function () {
+        var literal = path_1.default.join(tmpDir, "shop");
+        fs_1.default.writeFileSync(literal, "");
+        expect((0, envArg_1.resolveEnvArgPath)("shop", tmpDir)).toBe(literal);
+    });
+    it("does not treat a same-named directory as an existing literal file", function () {
+        fs_1.default.mkdirSync(path_1.default.join(tmpDir, "studio"));
+        expect((0, envArg_1.resolveEnvArgPath)("studio", tmpDir)).toBe(path_1.default.join(tmpDir, ENV_PREFIX + "studio"));
+    });
+    it("trims surrounding whitespace before resolving", function () {
+        expect((0, envArg_1.resolveEnvArgPath)("  demo8  ", tmpDir)).toBe(path_1.default.join(tmpDir, ENV_PREFIX + "demo8"));
+    });
+    it("resolves a bare name parsed from the --env= form end to end", function () {
+        var raw = (0, envArg_1.parseEnvArg)(["refresh", "--env=demo8"]);
+        expect(raw).toBe("demo8");
+        expect((0, envArg_1.resolveEnvArgPath)(raw, tmpDir)).toBe(path_1.default.join(tmpDir, ENV_PREFIX + "demo8"));
+    });
+    it("resolves the last-wins selection end to end", function () {
+        var raw = (0, envArg_1.parseEnvArg)(["push", "--env", ENV_PREFIX + "prod", "-e", "demo8"]);
+        expect((0, envArg_1.resolveEnvArgPath)(raw, tmpDir)).toBe(path_1.default.join(tmpDir, ENV_PREFIX + "demo8"));
+    });
+    it("defaults to process.cwd() when no cwd is given", function () {
+        expect((0, envArg_1.resolveEnvArgPath)("demo8")).toBe(path_1.default.resolve(process.cwd(), ENV_PREFIX + "demo8"));
+    });
+    it("throws on an empty or non-string selector", function () {
+        expect(function () {
+            (0, envArg_1.resolveEnvArgPath)("", tmpDir);
+        }).toThrow(/non-empty/);
+        expect(function () {
+            (0, envArg_1.resolveEnvArgPath)("   ", tmpDir);
+        }).toThrow(/non-empty/);
+        expect(function () {
+            (0, envArg_1.resolveEnvArgPath)(undefined, tmpDir);
+        }).toThrow(/non-empty/);
     });
 });

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({