@tenonhq/dovetail-core 0.0.126 → 0.0.127

package/dist/appUtils.js

@@ -424,6 +424,7 @@ const narrowManifestToRecord = (manifest, table, sysId) => {
 };
 exports.narrowManifestToRecord = narrowManifestToRecord;
 const syncManifest = async (scope, options = {}) => {
+    var failedScopes = [];
     // Top-level entry owns the collector lifecycle. Recursive calls (all-scopes
     // → per-scope) inherit the collector via options._benchmarkCollector.
     var isBenchmarkOwner = false;
@@ -448,7 +449,7 @@ const syncManifest = async (scope, options = {}) => {
                 Logger_1.logger.warn("Skipping scope '" + scope + "' — not declared in dove.config.js `scopes`. " +
                     "Add it to config.scopes to sync, or remove its manifest file.");
                 FileLogger_1.fileLogger.debug("syncManifest: skipped undeclared scope '" + scope + "'");
-                return;
+                return { failedScopes: failedScopes };
             }
             Logger_1.logger.info("Refreshing scope: " + scope + "...");
             const client = (0, snClient_1.defaultClient)();
@@ -555,20 +556,25 @@ const syncManifest = async (scope, options = {}) => {
                 tables: options.tables,
                 _benchmarkCollector: collector,
             };
+            // Each child call catches its own failure and reports it in its result,
+            // so one broken scope never stops the rest — collect, then report.
+            var childScopes = [];
             if (declaredScopes.length > 0) {
-                for (var d = 0; d < declaredScopes.length; d++) {
-                    await (0, exports.syncManifest)(declaredScopes[d], childOptions);
-                }
+                childScopes = declaredScopes;
             }
             else if (ConfigManager.isMultiScopeManifest(curManifest)) {
                 // No declared scopes — fall back to the persisted manifest's scopes.
-                for (const scopeName of Object.keys(curManifest)) {
-                    await (0, exports.syncManifest)(scopeName, childOptions);
-                }
+                childScopes = Object.keys(curManifest);
             }
             else if (curManifest.scope) {
                 // Single scope manifest
-                await (0, exports.syncManifest)(curManifest.scope, childOptions);
+                childScopes = [curManifest.scope];
+            }
+            for (var d = 0; d < childScopes.length; d++) {
+                var childResult = await (0, exports.syncManifest)(childScopes[d], childOptions);
+                if (childResult && Array.isArray(childResult.failedScopes)) {
+                    failedScopes = failedScopes.concat(childResult.failedScopes);
+                }
             }
         }
     }
@@ -578,7 +584,8 @@ const syncManifest = async (scope, options = {}) => {
             message = e.message;
         else
             message = String(e);
-        Logger_1.logger.error("Refresh failed: " + message);
+        Logger_1.logger.error("Refresh failed" + (scope ? " for " + scope : "") + ": " + message);
+        failedScopes.push({ scope: scope || "(all scopes)", error: message });
     }
     finally {
         if (isBenchmarkOwner && collector) {
@@ -586,6 +593,7 @@ const syncManifest = async (scope, options = {}) => {
             Logger_1.logger.info(collector.formatSummary());
         }
     }
+    return { failedScopes: failedScopes };
 };
 exports.syncManifest = syncManifest;
 const markFileMissing = (missingObj) => (table) => (recordId) => (file) => {

package/dist/commands.js

@@ -134,13 +134,27 @@ async function refreshCommand(args, log = true) {
             ", metadataOnly=" + !!args.metadataOnly +
             ", benchmark=" + !!args.benchmark +
             ", tables=" + (tables.length > 0 ? tables.join(",") : "all") + ")");
-        await AppUtils.syncManifest(args.scope, {
+        const result = await AppUtils.syncManifest(args.scope, {
             force: !!args.force,
             metadataOnly: !!args.metadataOnly,
             benchmark: !!args.benchmark,
             tables: tables.length > 0 ? tables : undefined,
         });
-        Logger_1.logger.success("Refresh complete!");
+        const failed = (result && Array.isArray(result.failedScopes)) ? result.failedScopes : [];
+        if (failed.length > 0) {
+            // Every remaining scope was still attempted (syncManifest keeps going
+            // past a broken scope); now say so loudly and exit non-zero so scripts
+            // and CI can't mistake a partial refresh for a clean one.
+            Logger_1.logger.error("Refresh finished with " + failed.length + " failed scope" +
+                (failed.length === 1 ? "" : "s") + ":");
+            for (const f of failed) {
+                Logger_1.logger.error("  - " + f.scope + ": " + f.error);
+            }
+            process.exitCode = 1;
+        }
+        else {
+            Logger_1.logger.success("Refresh complete!");
+        }
         setLogLevel(args);
     }
     catch (e) {

package/dist/createRecordCommand.js

@@ -536,9 +536,15 @@ async function createRecordCommand(args) {
             Logger_1.logger.info("Syncing record to local files...");
             FileLogger_1.fileLogger.debug("Starting single-record sync for scope:", scope);
             try {
-                await AppUtils.syncManifest(scope, {
+                var syncResult = await AppUtils.syncManifest(scope, {
                     record: { table: table, sysId: newSysId },
                 });
+                // syncManifest reports a failed scope in its result instead of
+                // throwing; route it to the catch below so we never claim the local
+                // files were created when the refresh failed.
+                if (syncResult && syncResult.failedScopes && syncResult.failedScopes.length > 0) {
+                    throw new Error(syncResult.failedScopes[0].error);
+                }
                 // Resolve the scope's own source directory — syncManifest writes into
                 // getSourcePathForScope(scope), which a scope config can override. Using
                 // the top-level getSourcePath() here would print a wrong path in

package/dist/tests/refreshFailedScopes.test.js

@@ -0,0 +1,194 @@
+"use strict";
+/**
+ * `dove refresh` must fail loudly when a scope fails.
+ *
+ * Regression target: against an instance without the sync API, every scope's
+ * getManifest returned HTTP 400, each failure was caught and logged inside
+ * syncManifest, and refreshCommand still printed "Refresh complete!" and
+ * exited 0 — so scripts and CI read a total failure as success.
+ *
+ * Contract pinned here:
+ *   1. An all-scopes refresh keeps going past a failed scope (the rest still
+ *      refresh) and returns every failure in `failedScopes`.
+ *   2. refreshCommand prints a per-scope failure summary, sets a non-zero exit
+ *      code, and does NOT print "Refresh complete!".
+ *   3. A clean refresh still prints "Refresh complete!" and leaves the exit
+ *      code alone.
+ */
+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(),
+    setLogLevel: jest.fn(),
+    getLogLevel: function () { return "info"; },
+};
+var mockClient = {
+    getManifest: jest.fn(),
+    getMissingFiles: jest.fn().mockResolvedValue({}),
+};
+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: { debug: jest.fn(), info: jest.fn(), warn: jest.fn(), error: jest.fn() } };
+});
+jest.mock("../FileUtils", function () { return mockFUtils; });
+jest.mock("../snClient", function () {
+    return {
+        defaultClient: function () { return mockClient; },
+        unwrapSNResponse: function (p) { return Promise.resolve(p); },
+        processPushResponse: jest.fn(),
+        retryOnErr: jest.fn(),
+        retryOnHttpErr: jest.fn(),
+        unwrapTableAPIFirstItem: jest.fn(),
+    };
+});
+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().mockReturnValue({
+        tables: ["sys_script_include"],
+        fieldOverrides: {},
+        apiIncludes: {},
+        apiExcludes: {},
+    }),
+    isMultiScopeManifest: jest.fn().mockReturnValue(true),
+    updateManifest: jest.fn(),
+};
+jest.mock("../config", function () { return mockConfig; });
+jest.mock("progress", function () {
+    return jest.fn().mockImplementation(function () { return { tick: jest.fn() }; });
+});
+const AppUtils = __importStar(require("../appUtils"));
+const commands_1 = require("../commands");
+var SCOPES = ["x_cadso_core", "x_cadso_work", "x_cadso_journey"];
+function declareScopes() {
+    var scopes = {};
+    var manifest = {};
+    SCOPES.forEach(function (s) {
+        scopes[s] = {};
+        manifest[s] = { scope: s, tables: {} };
+    });
+    mockConfig.getConfig.mockReturnValue({ scopes: scopes });
+    mockConfig.getManifest.mockResolvedValue(manifest);
+}
+function errorLines() {
+    return mockLogger.error.mock.calls.map(function (c) { return String(c[0]); });
+}
+describe("syncManifest — failed scopes are collected, not swallowed", function () {
+    beforeEach(function () {
+        jest.clearAllMocks();
+        mockConfig.isMultiScopeManifest.mockReturnValue(true);
+        declareScopes();
+    });
+    test("keeps refreshing past a failed scope and reports it", async function () {
+        mockClient.getManifest.mockImplementation(function (scope) {
+            if (scope === "x_cadso_work") {
+                return Promise.reject(new Error("HTTP 400 from api/cadso/dovetail_sync/getManifest/x_cadso_work"));
+            }
+            return Promise.resolve({ scope: scope, tables: {} });
+        });
+        var result = await AppUtils.syncManifest();
+        var attempted = mockClient.getManifest.mock.calls.map(function (c) { return c[0]; });
+        expect(attempted).toEqual(SCOPES);
+        expect(result.failedScopes).toHaveLength(1);
+        expect(result.failedScopes[0].scope).toBe("x_cadso_work");
+        expect(result.failedScopes[0].error).toContain("HTTP 400");
+        // The scopes either side of the failure still wrote their manifests.
+        expect(mockFUtils.writeScopeManifest).toHaveBeenCalledTimes(2);
+    });
+    test("every scope failing reports every scope", async function () {
+        mockClient.getManifest.mockRejectedValue(new Error("HTTP 400"));
+        var result = await AppUtils.syncManifest();
+        expect(result.failedScopes.map(function (f) { return f.scope; })).toEqual(SCOPES);
+    });
+    test("a clean refresh reports no failures", async function () {
+        mockClient.getManifest.mockImplementation(function (scope) {
+            return Promise.resolve({ scope: scope, tables: {} });
+        });
+        var result = await AppUtils.syncManifest();
+        expect(result.failedScopes).toEqual([]);
+    });
+    test("a top-level failure (no manifest) is reported too", async function () {
+        mockConfig.getManifest.mockResolvedValue(undefined);
+        var result = await AppUtils.syncManifest();
+        expect(result.failedScopes).toHaveLength(1);
+        expect(result.failedScopes[0].error).toContain("No manifest file loaded");
+    });
+});
+describe("refreshCommand — exit code reflects failed scopes", function () {
+    var originalExitCode;
+    beforeEach(function () {
+        jest.clearAllMocks();
+        originalExitCode = process.exitCode;
+        process.exitCode = undefined;
+    });
+    afterEach(function () {
+        process.exitCode = originalExitCode;
+        jest.restoreAllMocks();
+    });
+    test("failed scopes → summary, non-zero exit, no 'Refresh complete!'", async function () {
+        jest.spyOn(AppUtils, "syncManifest").mockResolvedValue({
+            failedScopes: [
+                { scope: "x_cadso_core", error: "HTTP 400" },
+                { scope: "x_cadso_work", error: "HTTP 400" },
+            ],
+        });
+        await (0, commands_1.refreshCommand)({});
+        expect(process.exitCode).toBe(1);
+        expect(mockLogger.success).not.toHaveBeenCalled();
+        var lines = errorLines();
+        expect(lines.some(function (l) { return l.indexOf("2 failed scopes") !== -1; })).toBe(true);
+        expect(lines.some(function (l) { return l.indexOf("x_cadso_core: HTTP 400") !== -1; })).toBe(true);
+        expect(lines.some(function (l) { return l.indexOf("x_cadso_work: HTTP 400") !== -1; })).toBe(true);
+    });
+    test("clean refresh → 'Refresh complete!' and exit code untouched", async function () {
+        jest.spyOn(AppUtils, "syncManifest").mockResolvedValue({ failedScopes: [] });
+        await (0, commands_1.refreshCommand)({});
+        expect(process.exitCode).toBeUndefined();
+        expect(mockLogger.success).toHaveBeenCalledWith("Refresh complete!");
+    });
+});

package/package.json

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

package/release-manifest.json

@@ -1,7 +1,42 @@
 {
   "$schema": "dovetail-manifest/v1",
-  "generated_at": "2026-10-08T18:59:46.354Z",
+  "generated_at": "2026-10-09T03:55:11.874Z",
   "events": [
+    {
+      "$schema": "dovetail-release-event/v1",
+      "event_id": "dovetail-core@0.0.126",
+      "package": "@tenonhq/dovetail-core",
+      "version": "0.0.126",
+      "prev_version": "0.0.125",
+      "published_at": "2026-10-09T03:55:11.868Z",
+      "git": {
+        "sha": "ca4fdead0bbd5c4f7ed3dd544ac3ae19a4037e42",
+        "tag": "dovetail-core@0.0.126"
+      },
+      "semver_bump": "patch",
+      "commits": [
+        {
+          "sha": "ca4fdead0",
+          "subject": "fix(core): dove --env accepts a bare instance name like dove-sn (#325)",
+          "pr": 325
+        },
+        {
+          "sha": "435341abf",
+          "subject": "chore(release): publish 2 packages [skip ci]"
+        },
+        {
+          "sha": "301dfbb75",
+          "subject": "fix: review fixes for the Oct 1-8 merges, re-land reverted #288 and #311 (#322)",
+          "pr": 322
+        },
+        {
+          "sha": "16fd9248d",
+          "subject": "chore(release): @tenonhq/dovetail-core@0.0.125 [skip ci]"
+        }
+      ],
+      "exports_delta": null,
+      "narrative": null
+    },
     {
       "$schema": "dovetail-release-event/v1",
       "event_id": "dovetail-servicenow@0.0.52",
@@ -1312,32 +1347,6 @@
       ],
       "exports_delta": null,
       "narrative": null
-    },
-    {
-      "$schema": "dovetail-release-event/v1",
-      "event_id": "dovetail-servicenow@0.0.38",
-      "package": "@tenonhq/dovetail-servicenow",
-      "version": "0.0.38",
-      "prev_version": "0.0.37",
-      "published_at": "2026-09-15T23:33:16.570Z",
-      "git": {
-        "sha": "925c0ca40cc6407fa78f28b25b82f8dc0fbd460f",
-        "tag": "dovetail-servicenow@0.0.38"
-      },
-      "semver_bump": "patch",
-      "commits": [
-        {
-          "sha": "925c0ca40",
-          "subject": "feat(servicenow): headless update-set / app export with mandatory secret stripping (#276)",
-          "pr": 276
-        },
-        {
-          "sha": "83df94645",
-          "subject": "chore(release): publish 2 packages [skip ci]"
-        }
-      ],
-      "exports_delta": null,
-      "narrative": null
     }
   ]
 }