@tenonhq/dovetail-core 0.0.99 → 0.0.100

package/dist/allScopesCommands.js

@@ -36,6 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.processManifestForScope = processManifestForScope;
 exports.processScope = processScope;
 exports.initScopesCommand = initScopesCommand;
 exports.watchAllScopesCommand = watchAllScopesCommand;
@@ -51,7 +52,8 @@ const fs = __importStar(require("fs"));
 const child_process_1 = require("child_process");
 const progress_1 = __importDefault(require("progress"));
 const fsp = fs.promises;
-// Custom function to process manifest with specific source directory
+// Custom function to process manifest with specific source directory.
+// Exported for regression testing of filesystem-safe folder writing.
 async function processManifestForScope(manifest, sourceDirectory, forceWrite = false) {
     try {
         // Ensure the source directory exists
@@ -62,6 +64,13 @@ async function processManifestForScope(manifest, sourceDirectory, forceWrite = f
             Logger_1.logger.error("Failed to create directory: " + sourceDirectory);
             throw dirError;
         }
+        // Re-key the manifest to filesystem-safe folder names before writing.
+        // Idempotent, so it is safe even when the caller already normalized.
+        // Without this, a Windows-illegal display name (trailing dot/space, or
+        // any of <>:"|?*) would be written as a raw folder and abort `git clone`
+        // on Windows. Keeps the folder ≡ manifest-key invariant `dove push` relies
+        // on. See toSafeFolderName / normalizeManifestKeys (PR #117, #133).
+        AppUtils.normalizeManifestKeys(manifest);
         const tables = manifest.tables || {};
         const tableNames = Object.keys(tables);
         var totalRecords = 0;
@@ -86,8 +95,10 @@ async function processManifestForScope(manifest, sourceDirectory, forceWrite = f
             FileLogger_1.fileLogger.debug("Table " + tableName + ": " + recordNames.length + " records");
             for (const recordName of recordNames) {
                 const record = tableRecords.records[recordName];
-                // Use the record's name property instead of the key for the directory name
-                const recordDirName = record.name || recordName;
+                // Derive the folder via toSafeFolderName (never the raw record.name):
+                // normalizeManifestKeys above already re-keyed unsafe names to sys_id,
+                // and this keeps the writer defensive if that ever changes.
+                const recordDirName = AppUtils.toSafeFolderName(record);
                 const recordPath = path.join(tablePath, recordDirName);
                 // Check if metadata file exists in the files from server
                 const hasMetadataFromServer = record.files && record.files.some((f) => f.name === 'metaData' && f.type === 'json');
@@ -195,8 +206,9 @@ async function processScope(scopeName, scopeConfig, apiDelay = 0) {
         else {
             Logger_1.logger.warn("No _tables whitelist defined — writing ALL tables for " + scopeName);
         }
-        // Normalize record keys from sys_id to display name
-        AppUtils.normalizeManifestKeys(manifest);
+        // Record-key normalization now happens inside processManifestForScope (the
+        // writer owns the folder ≡ key invariant). The missing-files structure
+        // below keys by record.sys_id, so it does not depend on normalized names.
         // Build the missing files structure from the filtered manifest
         var manifestTables = manifest.tables || {};
         var allMissingFiles = {};

package/dist/tests/downloadSafeFolderNames.test.js

@@ -0,0 +1,189 @@
+"use strict";
+/**
+ * Regression: the download / initScopes writer must produce filesystem-SAFE
+ * folder names — even when its caller forgets to normalize the manifest first.
+ *
+ * `processManifestForScope` (allScopesCommands.ts) builds one folder per record.
+ * It used to do `record.name || recordName` with no sanitization, so a record
+ * whose ServiceNow display name is Windows-illegal — e.g. a sys_ui_script named
+ * `x_cadso_core.` (trailing dot) — was written as a literal `x_cadso_core.`
+ * folder. Windows forbids trailing dots/spaces in path segments, so Git aborts
+ * the whole checkout (`error: invalid path`) and the clone fails for every
+ * Windows dev. It only avoided the bug because one caller happened to call
+ * normalizeManifestKeys first; any other caller re-introduced it.
+ *
+ * The writer now normalizes the manifest itself and routes folder names through
+ * toSafeFolderName, so an unsafe name falls back to its sys_id (and the manifest
+ * is re-keyed to match — preserving the folder ≡ key invariant `dove push`
+ * relies on), while a safe name stays human-readable.
+ */
+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(),
+};
+jest.mock("../Logger", function () { return { logger: mockLogger }; });
+jest.mock("../FileLogger", function () { return { fileLogger: mockFileLogger }; });
+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() }; });
+jest.mock("progress", function () {
+    return jest.fn().mockImplementation(function () {
+        return { tick: jest.fn() };
+    });
+});
+const AllScopes = __importStar(require("../allScopesCommands"));
+// ---------- helpers ----------
+var tmpRoot;
+var UI_SYS_ID = "89295b86334983d07b18bc534d5c7b8a";
+var SAFE_SYS_ID = "aa11bb22cc33dd44ee55ff6600112233";
+function listFolders(table) {
+    try {
+        return fs.readdirSync(path.join(tmpRoot, table)).sort();
+    }
+    catch (e) {
+        return [];
+    }
+}
+describe("download — folder names are filesystem-safe (self-sufficient writer)", function () {
+    beforeEach(function () {
+        jest.clearAllMocks();
+        tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "dove-dl-safe-"));
+    });
+    afterEach(function () {
+        try {
+            fs.rmSync(tmpRoot, { recursive: true, force: true });
+        }
+        catch (e) { }
+    });
+    test("a trailing-dot record name is written to its sys_id folder, never `x_cadso_core.`", async function () {
+        // Manifest keyed by the raw, Windows-illegal display name — i.e. a caller
+        // that did NOT pre-normalize. The writer must defend itself.
+        var manifest = {
+            tables: {
+                sys_ui_script: {
+                    records: {
+                        "x_cadso_core.": {
+                            name: "x_cadso_core.",
+                            sys_id: UI_SYS_ID,
+                            files: [{ name: "script", type: "js", content: "// ui" }],
+                        },
+                    },
+                },
+            },
+        };
+        await AllScopes.processManifestForScope(manifest, tmpRoot, true);
+        var folders = listFolders("sys_ui_script");
+        expect(folders).toContain(UI_SYS_ID);
+        expect(folders).not.toContain("x_cadso_core.");
+        // File landed inside the sys_id folder.
+        expect(fs.readFileSync(path.join(tmpRoot, "sys_ui_script", UI_SYS_ID, "script.js"), "utf8")).toBe("// ui");
+        // Folder ≡ manifest-key invariant: the manifest was re-keyed to the sys_id
+        // so `dove push` (which looks records up by folder name) still resolves it.
+        expect(Object.keys(manifest.tables.sys_ui_script.records)).toEqual([UI_SYS_ID]);
+    });
+    test("other Windows-illegal names also fall back to sys_id (wildcard ACL, trailing space)", async function () {
+        var ACL_SYS_ID = "bc91c2a5f334621048dff31590812771";
+        var SPACE_SYS_ID = "cc22dd33ee44ff5500112233445566aa";
+        var manifest = {
+            tables: {
+                sys_security_acl: {
+                    records: {
+                        // A `<table>.*` wildcard ACL — the `*` (and trailing `.*`) is illegal on Windows.
+                        "x_cadso_work_campaign.*": {
+                            name: "x_cadso_work_campaign.*",
+                            sys_id: ACL_SYS_ID,
+                            files: [{ name: "script", type: "js", content: "// acl" }],
+                        },
+                        // A trailing space is silently stripped by Win32 — also unsafe.
+                        "Trailing Space ": {
+                            name: "Trailing Space ",
+                            sys_id: SPACE_SYS_ID,
+                            files: [{ name: "script", type: "js", content: "// space" }],
+                        },
+                    },
+                },
+            },
+        };
+        await AllScopes.processManifestForScope(manifest, tmpRoot, true);
+        var folders = listFolders("sys_security_acl");
+        expect(folders).toContain(ACL_SYS_ID);
+        expect(folders).toContain(SPACE_SYS_ID);
+        expect(folders).not.toContain("x_cadso_work_campaign.*");
+        expect(folders).not.toContain("Trailing Space ");
+    });
+    test("a filesystem-safe name stays human-readable (no needless sys_id fallback)", async function () {
+        var manifest = {
+            tables: {
+                sys_ui_script: {
+                    records: {
+                        "Tenon Shell": {
+                            name: "Tenon Shell",
+                            sys_id: SAFE_SYS_ID,
+                            files: [{ name: "script", type: "js", content: "// shell" }],
+                        },
+                    },
+                },
+            },
+        };
+        await AllScopes.processManifestForScope(manifest, tmpRoot, true);
+        var folders = listFolders("sys_ui_script");
+        expect(folders).toContain("Tenon Shell");
+        expect(folders).not.toContain(SAFE_SYS_ID);
+    });
+});

package/package.json

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

package/release-manifest.json

@@ -1,7 +1,41 @@
 {
   "$schema": "dovetail-manifest/v1",
-  "generated_at": "2026-06-02T17:01:03.752Z",
+  "generated_at": "2026-06-02T18:16:07.004Z",
   "events": [
+    {
+      "$schema": "dovetail-release-event/v1",
+      "event_id": "dovetail-core@0.0.99",
+      "package": "@tenonhq/dovetail-core",
+      "version": "0.0.99",
+      "prev_version": "0.0.98",
+      "published_at": "2026-06-02T18:16:06.996Z",
+      "git": {
+        "sha": "bad6776e9a426207b700d39dd139438c8a934d49",
+        "tag": "dovetail-core@0.0.99"
+      },
+      "semver_bump": "patch",
+      "commits": [
+        {
+          "sha": "bad6776e9",
+          "subject": "fix(core): write instance-relative _record_link in metaData.json (#139)",
+          "pr": 139
+        },
+        {
+          "sha": "e0cf83a8c",
+          "subject": "chore(release): @tenonhq/dovetail-servicenow@0.0.13 [skip ci]"
+        },
+        {
+          "sha": "bd127c726",
+          "subject": "chore(release): @tenonhq/dovetail-servicenow@0.0.12 [skip ci]"
+        },
+        {
+          "sha": "448696846",
+          "subject": "chore(release): publish 3 packages [skip ci]"
+        }
+      ],
+      "exports_delta": null,
+      "narrative": null
+    },
     {
       "$schema": "dovetail-release-event/v1",
       "event_id": "dovetail-servicenow@0.0.13",