@tenonhq/sincronia-core 0.0.82 → 0.0.84

package/dist/allScopesCommands.js

@@ -90,7 +90,7 @@ async function processManifestForScope(manifest, sourceDirectory, forceWrite = f
                 const recordDirName = record.name || recordName;
                 const recordPath = path.join(tablePath, recordDirName);
                 // Check if metadata file exists in the files from server
-                const hasMetadataFromServer = record.files?.some((f) => f.name === 'metaData' && f.type === 'json');
+                const hasMetadataFromServer = record.files && record.files.some((f) => f.name === 'metaData' && f.type === 'json');
                 // Ensure the record directory exists
                 await fsp.mkdir(recordPath, { recursive: true });
                 // Process each file in the record
@@ -243,7 +243,7 @@ async function processScope(scopeName, scopeConfig, apiDelay = 0) {
                 }
             }
         }
-        const tableCount = Object.keys(manifest?.tables || {}).length;
+        const tableCount = Object.keys((manifest && manifest.tables) || {}).length;
         Logger_1.logger.info("Writing " + tableCount + " tables for " + scopeName + "...");
         await processManifestForScope(manifest, sourceDirectory, true);
         // Create the scope-specific manifest structure
@@ -325,8 +325,8 @@ async function initScopesCommand(args) {
             }
             else {
                 failCount++;
-                const error = result.status === "rejected" ? result.reason : result.value?.error;
-                Logger_1.logger.error(`Failed to process ${scopeName}: ${error?.message || "Unknown error"}`);
+                const error = result.status === "rejected" ? result.reason : (result.value && result.value.error);
+                Logger_1.logger.error(`Failed to process ${scopeName}: ${(error && error.message) || "Unknown error"}`);
             }
         });
         // Write per-scope manifest files instead of a single combined one

package/dist/appUtils.js

@@ -61,19 +61,46 @@ const getUpdateSetConfig = () => {
     }
     return {};
 };
+// Merge _lastUpdatedOn into the server-provided metadata content. Preserves all
+// record fields (sys_id, sys_scope, field value/display_value pairs, etc.) so
+// the local metaData.json is a full snapshot of the record, not just a stub.
+const stampMetadataContent = (file) => {
+    if (file.name !== "metaData" || file.type !== "json")
+        return file;
+    const stamp = new Date().toISOString();
+    if (!file.content) {
+        return { ...file, content: JSON.stringify({ _lastUpdatedOn: stamp }, null, 2) };
+    }
+    try {
+        const metadata = JSON.parse(file.content);
+        if (metadata.sys_updated_on && metadata.sys_updated_on.value) {
+            metadata._lastUpdatedOn = metadata.sys_updated_on.value;
+        }
+        else {
+            metadata._lastUpdatedOn = stamp;
+        }
+        return { ...file, content: JSON.stringify(metadata, null, 2) };
+    }
+    catch (e) {
+        // Content isn't JSON — leave as-is, it will be written verbatim.
+        return file;
+    }
+};
+const hasServerMetadata = (files) => files.some((f) => f.name === "metaData" && f.type === "json" && !!f.content);
 const processFilesInManRec = async (recPath, rec, forceWrite) => {
     FileLogger_1.fileLogger.debug("Processing record: " + rec.name + " (" + rec.files.length + " files)");
     const fileWrite = fUtils.writeSNFileCurry(forceWrite);
-    // Create metadata file with current timestamp
-    const metadataFile = {
-        name: "metaData",
-        type: "json",
-        content: JSON.stringify({
-            _lastUpdatedOn: new Date().toISOString()
-        }, null, 2)
-    };
-    await fileWrite(metadataFile, recPath);
-    const writeResults = await (0, genericUtils_1.allSettledBatched)(rec.files, constants_1.CONCURRENCY_FILES, function (file) { return fileWrite(file, recPath); });
+    // If the server did not provide a metadata file, fall back to a timestamp-only
+    // stub so the record directory always has a metaData.json.
+    if (!hasServerMetadata(rec.files)) {
+        const stubMetadata = {
+            name: "metaData",
+            type: "json",
+            content: JSON.stringify({ _lastUpdatedOn: new Date().toISOString() }, null, 2),
+        };
+        await fileWrite(stubMetadata, recPath);
+    }
+    const writeResults = await (0, genericUtils_1.allSettledBatched)(rec.files, constants_1.CONCURRENCY_FILES, function (file) { return fileWrite(stampMetadataContent(file), recPath); });
     const writeFailures = writeResults.filter((r) => r.status === "rejected");
     if (writeFailures.length > 0) {
         writeFailures.forEach((f) => {
@@ -461,7 +488,22 @@ const refreshAllFiles = async (newManifest, sourcePath, options = {}) => {
             await (0, genericUtils_1.processBatched)(recKeys, constants_1.CONCURRENCY_RECORDS, async function (recKey) {
                 var rec = recs[recKey];
                 var recPath = path_1.default.join(tablePath, rec.name);
-                var results = await (0, genericUtils_1.allSettledBatched)(rec.files, constants_1.CONCURRENCY_FILES, async function (file) {
+                // Split server-provided metadata off from the regular files so we can
+                // track whether any regular file actually changed — metaData shouldn't
+                // be the trigger for "this record changed" since we stamp it on every
+                // touch.
+                var metadataFiles = [];
+                var regularFiles = [];
+                for (var mi = 0; mi < rec.files.length; mi++) {
+                    var rf = rec.files[mi];
+                    if (rf.name === "metaData" && rf.type === "json") {
+                        metadataFiles.push(rf);
+                    }
+                    else {
+                        regularFiles.push(rf);
+                    }
+                }
+                var results = await (0, genericUtils_1.allSettledBatched)(regularFiles, constants_1.CONCURRENCY_FILES, async function (file) {
                     if (forceWrite) {
                         await forceWriter(file, recPath);
                         return true;
@@ -483,15 +525,23 @@ const refreshAllFiles = async (newManifest, sourcePath, options = {}) => {
                         unchangedCount++;
                     }
                 }
-                // Only touch metaData when at least one file in the record actually
-                // changed. Avoids rewriting _lastUpdatedOn for records that were
-                // already in sync with the instance.
+                // Only touch metaData when at least one regular file in the record
+                // actually changed. Avoids rewriting _lastUpdatedOn for records that
+                // were already in sync with the instance. Prefer the server-provided
+                // metadata (full field snapshot) over a stub; fall back to a stub only
+                // when the server didn't send metadata at all.
                 if (anyChanged || forceWrite) {
-                    const metadataFile = {
-                        name: "metaData",
-                        type: "json",
-                        content: JSON.stringify({ _lastUpdatedOn: new Date().toISOString() }, null, 2),
-                    };
+                    let metadataFile;
+                    if (metadataFiles.length > 0 && metadataFiles[0].content) {
+                        metadataFile = stampMetadataContent(metadataFiles[0]);
+                    }
+                    else {
+                        metadataFile = {
+                            name: "metaData",
+                            type: "json",
+                            content: JSON.stringify({ _lastUpdatedOn: new Date().toISOString() }, null, 2),
+                        };
+                    }
                     await forceWriter(metadataFile, recPath);
                 }
                 // Strip content from manifest entries to keep memory bounded.
@@ -665,12 +715,37 @@ const pushFiles = async (recs) => {
             .join(", ");
         Logger_1.logger.info(`Update set routing active: ${activeScopes}`);
     }
+    // Pre-resolve read-only table sets for every scope present in this batch.
+    // Cheaper than re-resolving per record. Tables flagged in _readOnlyTables
+    // are pulled normally but pushes are skipped.
+    const readOnlyByScope = {};
+    for (const rec of recs) {
+        const fieldNames = Object.keys(rec.fields);
+        if (fieldNames.length === 0)
+            continue;
+        const scope = rec.fields[fieldNames[0]].scope;
+        if (scope && !readOnlyByScope[scope]) {
+            readOnlyByScope[scope] = ConfigManager.getReadOnlyTablesForScope(scope);
+        }
+    }
+    const announcedSkipTables = {};
     const tick = getProgTick(Logger_1.logger.getLogLevel(), recs.length * 2) || (() => { });
     const results = await (0, genericUtils_1.allSettledBatched)(recs, constants_1.CONCURRENCY_PUSH, async function (rec) {
         const fieldNames = Object.keys(rec.fields);
         const firstField = rec.fields[fieldNames[0]];
         const recSummary = (0, exports.summarizeRecord)(rec.table, firstField.name);
         const scope = firstField.scope;
+        const readOnlySet = scope ? readOnlyByScope[scope] : undefined;
+        if (readOnlySet && readOnlySet.has(rec.table)) {
+            tick();
+            tick();
+            const skipKey = `${scope}:${rec.table}`;
+            if (!announcedSkipTables[skipKey]) {
+                announcedSkipTables[skipKey] = true;
+                Logger_1.logger.info(`Read-only table ${rec.table} in scope ${scope}: push skipped`);
+            }
+            return { success: true, message: `${recSummary} : skipped (read-only table)` };
+        }
         const buildRes = await buildRec(rec);
         tick();
         if (!buildRes.success) {

package/dist/config.js

@@ -61,6 +61,7 @@ exports.resolveScopeFromPath = resolveScopeFromPath;
 exports.isDirectiveKey = isDirectiveKey;
 exports.stripDirectiveKeys = stripDirectiveKeys;
 exports.resolveConfigForScope = resolveConfigForScope;
+exports.getReadOnlyTablesForScope = getReadOnlyTablesForScope;
 const path_1 = __importDefault(require("path"));
 const fs_1 = require("fs");
 const Logger_1 = require("./Logger");
@@ -559,8 +560,8 @@ function stripDirectiveKeys(obj) {
     }
     return result;
 }
-function resolveConfigForScope(scopeName) {
-    var cfg = getConfig();
+function resolveConfigForScope(scopeName, cfgOverride) {
+    var cfg = cfgOverride || getConfig();
     var cfgIncludes = cfg.includes || {};
     var cfgExcludes = cfg.excludes || {};
     // Backward compat: support old "table" key (no underscore)
@@ -639,10 +640,40 @@ function resolveConfigForScope(scopeName) {
     var apiIncludes = Object.assign({}, fieldOverrides);
     // API excludes: strip _ keys
     var apiExcludes = stripDirectiveKeys(cfgExcludes);
+    // Read-only tables: union of global _readOnlyTables and scope-level override.
+    // A table flagged read-only is still pulled from the instance but pushes are
+    // skipped. Default when absent: empty (bidirectional for all tables).
+    var globalReadOnly = Array.isArray(cfgIncludes._readOnlyTables)
+        ? cfgIncludes._readOnlyTables
+        : [];
+    var scopeReadOnly = Array.isArray(scopeOverride._readOnlyTables)
+        ? scopeOverride._readOnlyTables
+        : [];
+    var readOnlySet = {};
+    for (i = 0; i < globalReadOnly.length; i++) {
+        readOnlySet[globalReadOnly[i]] = true;
+    }
+    for (i = 0; i < scopeReadOnly.length; i++) {
+        readOnlySet[scopeReadOnly[i]] = true;
+    }
+    var resolvedReadOnly = Object.keys(readOnlySet);
     return {
         tables: resolvedTables,
         fieldOverrides: fieldOverrides,
         apiIncludes: apiIncludes,
         apiExcludes: apiExcludes,
+        readOnlyTables: resolvedReadOnly,
     };
 }
+// Convenience wrapper for push-side lookups — returns a Set for O(1) membership.
+// Fails safe (empty set = all tables writable) when config isn't available
+// rather than blocking a push over a lookup error.
+function getReadOnlyTablesForScope(scopeName) {
+    try {
+        var resolved = resolveConfigForScope(scopeName);
+        return new Set(resolved.readOnlyTables || []);
+    }
+    catch (e) {
+        return new Set();
+    }
+}

package/dist/flowDesigner/values.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeV2Values = decodeV2Values;
+exports.encodeV2Values = encodeV2Values;
+const zlib_1 = require("zlib");
+/**
+ * Decode a ServiceNow V2 Flow Designer `values` blob.
+ *
+ * Source tables:
+ *   - sys_hub_action_instance_v2.values
+ *   - sys_hub_trigger_instance_v2.values
+ *   - sys_hub_flow_logic_instance_v2.values
+ *
+ * Storage format: base64-encoded gzipped JSON.
+ * Mirrors `GlideStringUtil.base64DecodeAsBytes()` + `GlideCompressionUtil.expandToString()`
+ * + `JSON.parse` on the ServiceNow platform.
+ *
+ * Throws with a clear message if the blob is empty, not base64, or not gzip.
+ */
+function decodeV2Values(blob) {
+    if (typeof blob !== "string" || blob.trim().length === 0) {
+        throw new Error("decodeV2Values: blob must be a non-empty string");
+    }
+    let buf;
+    try {
+        buf = Buffer.from(blob.trim(), "base64");
+    }
+    catch (err) {
+        throw new Error("decodeV2Values: blob is not valid base64");
+    }
+    let json;
+    try {
+        json = (0, zlib_1.gunzipSync)(buf).toString("utf8");
+    }
+    catch (err) {
+        throw new Error("decodeV2Values: decompression failed (input is not valid gzip after base64 decode)");
+    }
+    try {
+        return JSON.parse(json);
+    }
+    catch (err) {
+        throw new Error("decodeV2Values: decompressed body is not valid JSON");
+    }
+}
+/**
+ * Encode a V2 values payload back to ServiceNow's storage format.
+ *
+ * Inverse of decodeV2Values. Provided for symmetry, diagnostic round-trip
+ * tests, and any future write path. Current Craftsman sync treats sys_hub_*
+ * as _readOnlyTables, so this is not invoked on the push path today.
+ */
+function encodeV2Values(value) {
+    const json = JSON.stringify(value);
+    return (0, zlib_1.gzipSync)(Buffer.from(json, "utf8")).toString("base64");
+}

package/dist/index.js

@@ -1,14 +1,25 @@
 #!/usr/bin/env node
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeV2Values = exports.decodeV2Values = void 0;
 const bootstrap_1 = require("./bootstrap");
 const FileLogger_1 = require("./FileLogger");
+// Library exports — consumers can `import { decodeV2Values } from "@tenonhq/sincronia-core"`.
+// Keep exports above the CLI entry so bundlers/TS can tree-shake and require() consumers
+// never accidentally invoke main().
+var values_1 = require("./flowDesigner/values");
+Object.defineProperty(exports, "decodeV2Values", { enumerable: true, get: function () { return values_1.decodeV2Values; } });
+Object.defineProperty(exports, "encodeV2Values", { enumerable: true, get: function () { return values_1.encodeV2Values; } });
 async function main() {
     // Initialize file logging as early as possible
     FileLogger_1.fileLogger.info("Starting Sincronia...");
     await (0, bootstrap_1.init)();
 }
-main().catch(function (e) {
-    FileLogger_1.fileLogger.error("Fatal error: " + String(e));
-    process.exit(1);
-});
+// Only run the CLI when this file is executed directly (e.g. `npx sinc`, `node dist/index.js`).
+// When imported as a library, require.main !== module and main() is skipped.
+if (require.main === module) {
+    main().catch(function (e) {
+        FileLogger_1.fileLogger.error("Fatal error: " + String(e));
+        process.exit(1);
+    });
+}

package/dist/tests/pushFiles.test.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 // Track how many times the update set config file is read
 var configReadCount = 0;
 var mockConfigData = {};
+// Per-scope read-only table sets, consumed by the mocked ../config module.
+// Mutate this object between tests to drive the push-gate behavior.
+var mockReadOnlyByScope = {};
 jest.mock("fs", function () {
     var actualFs = jest.requireActual("fs");
     return {
@@ -22,6 +25,16 @@ jest.mock("fs", function () {
         },
     };
 });
+// Mock only the config surface pushFiles touches. getReadOnlyTablesForScope
+// is the one new call site; the rest of pushFiles reads no ConfigManager
+// exports, so a minimal mock keeps the test focused on the push gate.
+jest.mock("../config", function () {
+    return {
+        getReadOnlyTablesForScope: function (scope) {
+            return mockReadOnlyByScope[scope] || new Set();
+        },
+    };
+});
 // Mock dependencies that pushFiles needs
 var mockPushWithUpdateSet = jest.fn().mockResolvedValue({
     data: { result: { status: "success" } },
@@ -98,6 +111,7 @@ describe("pushFiles", function () {
     beforeEach(function () {
         configReadCount = 0;
         mockConfigData = {};
+        mockReadOnlyByScope = {};
         mockPushWithUpdateSet.mockClear();
         mockUpdateRecord.mockClear();
     });
@@ -159,4 +173,73 @@ describe("pushFiles", function () {
         expect(mockUpdateRecord).toHaveBeenCalledTimes(1);
         expect(mockPushWithUpdateSet).not.toHaveBeenCalled();
     });
+    it("skips push for tables listed in _readOnlyTables for the scope", async function () {
+        mockConfigData = {};
+        mockReadOnlyByScope = {
+            x_cadso_core: new Set(["sys_hub_flow"]),
+        };
+        var { pushFiles } = require("../appUtils");
+        var records = [
+            makeRecord("sys_hub_flow", "flow1", "x_cadso_core"),
+        ];
+        var results = await pushFiles(records);
+        expect(mockPushWithUpdateSet).not.toHaveBeenCalled();
+        expect(mockUpdateRecord).not.toHaveBeenCalled();
+        expect(results).toHaveLength(1);
+        expect(results[0].success).toBe(true);
+        expect(results[0].message).toContain("skipped (read-only table)");
+    });
+    it("pushes normally when the scope has no read-only tables", async function () {
+        mockConfigData = {};
+        mockReadOnlyByScope = {};
+        var { pushFiles } = require("../appUtils");
+        var records = [
+            makeRecord("sys_script_include", "rec1", "x_cadso_core"),
+        ];
+        await pushFiles(records);
+        expect(mockUpdateRecord).toHaveBeenCalledTimes(1);
+        expect(mockPushWithUpdateSet).not.toHaveBeenCalled();
+    });
+    it("in a mixed batch, only non-read-only tables are pushed", async function () {
+        mockConfigData = {};
+        mockReadOnlyByScope = {
+            x_cadso_core: new Set(["sys_hub_flow"]),
+        };
+        var { pushFiles } = require("../appUtils");
+        var records = [
+            makeRecord("sys_hub_flow", "flow1", "x_cadso_core"),
+            makeRecord("sys_script_include", "rec1", "x_cadso_core"),
+            makeRecord("sys_hub_action_instance", "ai1", "x_cadso_core"),
+        ];
+        var results = await pushFiles(records);
+        // Only the read-only flow row is skipped; the other two hit updateRecord.
+        expect(mockUpdateRecord).toHaveBeenCalledTimes(2);
+        expect(mockPushWithUpdateSet).not.toHaveBeenCalled();
+        expect(results).toHaveLength(3);
+        var skipped = results.filter(function (r) {
+            return r.message.indexOf("skipped (read-only table)") !== -1;
+        });
+        expect(skipped).toHaveLength(1);
+    });
+    it("applies scope-specific read-only tables independently across scopes", async function () {
+        mockConfigData = {};
+        mockReadOnlyByScope = {
+            x_cadso_core: new Set(["sys_hub_flow"]),
+            x_cadso_work: new Set(),
+        };
+        var { pushFiles } = require("../appUtils");
+        var records = [
+            makeRecord("sys_hub_flow", "flow1", "x_cadso_core"),
+            makeRecord("sys_hub_flow", "flow2", "x_cadso_work"),
+        ];
+        var results = await pushFiles(records);
+        // x_cadso_core's flow is blocked; x_cadso_work's flow pushes because it
+        // isn't in that scope's read-only set.
+        expect(mockUpdateRecord).toHaveBeenCalledTimes(1);
+        expect(results).toHaveLength(2);
+        var skipped = results.filter(function (r) {
+            return r.message.indexOf("skipped (read-only table)") !== -1;
+        });
+        expect(skipped).toHaveLength(1);
+    });
 });

package/dist/tests/resolveConfigReadOnly.test.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("../config");
+const baseConfig = {
+    sourceDirectory: "src",
+    buildDirectory: "build",
+    includes: {},
+    excludes: {},
+    tableOptions: {},
+    refreshInterval: 30,
+    scopes: {},
+};
+function withIncludes(overrides) {
+    return {
+        ...baseConfig,
+        includes: overrides,
+    };
+}
+describe("resolveConfigForScope - _readOnlyTables", () => {
+    it("returns an empty list when _readOnlyTables is absent", () => {
+        const cfg = withIncludes({ _tables: ["incident", "sys_hub_flow"] });
+        const resolved = (0, config_1.resolveConfigForScope)("any_scope", cfg);
+        expect(resolved.readOnlyTables).toEqual([]);
+    });
+    it("returns the global _readOnlyTables list when no scope override", () => {
+        const cfg = withIncludes({
+            _tables: ["incident", "sys_hub_flow"],
+            _readOnlyTables: ["sys_hub_flow"],
+        });
+        const resolved = (0, config_1.resolveConfigForScope)("x_cadso_core", cfg);
+        expect(resolved.readOnlyTables).toEqual(["sys_hub_flow"]);
+    });
+    it("unions global and scope _readOnlyTables without duplicates", () => {
+        const cfg = withIncludes({
+            _tables: ["incident", "sys_hub_flow", "sys_hub_action_instance"],
+            _readOnlyTables: ["sys_hub_flow"],
+            _scopes: {
+                x_cadso_core: {
+                    _readOnlyTables: ["sys_hub_flow", "sys_hub_action_instance"],
+                },
+            },
+        });
+        const resolved = (0, config_1.resolveConfigForScope)("x_cadso_core", cfg);
+        expect(resolved.readOnlyTables.sort()).toEqual(["sys_hub_action_instance", "sys_hub_flow"].sort());
+    });
+    it("falls back to the global list for scopes without an override", () => {
+        const cfg = withIncludes({
+            _tables: ["incident", "sys_hub_flow"],
+            _readOnlyTables: ["sys_hub_flow"],
+            _scopes: {
+                x_cadso_core: {
+                    _readOnlyTables: ["sys_hub_action_instance"],
+                },
+            },
+        });
+        const resolved = (0, config_1.resolveConfigForScope)("x_cadso_other", cfg);
+        expect(resolved.readOnlyTables).toEqual(["sys_hub_flow"]);
+    });
+    it("ignores non-array _readOnlyTables values safely", () => {
+        const cfg = withIncludes({
+            _tables: ["incident"],
+            _readOnlyTables: "oops-not-an-array",
+        });
+        const resolved = (0, config_1.resolveConfigForScope)("any_scope", cfg);
+        expect(resolved.readOnlyTables).toEqual([]);
+    });
+});

package/dist/tests/v2Values.test.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const zlib_1 = require("zlib");
+const values_1 = require("../flowDesigner/values");
+describe("decodeV2Values / encodeV2Values", () => {
+    describe("round-trip", () => {
+        it("decodes what encodeV2Values encoded (primitive array)", () => {
+            const original = [
+                { actionInstanceSysId: "abc", id: "1", name: "to", value: "user@example.com" },
+                { actionInstanceSysId: "abc", id: "2", name: "subject", value: "hi" },
+            ];
+            const blob = (0, values_1.encodeV2Values)(original);
+            expect((0, values_1.decodeV2Values)(blob)).toEqual(original);
+        });
+        it("decodes what encodeV2Values encoded (nested parameter objects)", () => {
+            const original = [
+                {
+                    actionInstanceSysId: "abc123",
+                    id: "input_a",
+                    name: "record",
+                    value: { table: "incident", sys_id: "xyz" },
+                    parameter: {
+                        type: "reference",
+                        labels: { en: "Record" },
+                        validation: { mandatory: true },
+                    },
+                },
+            ];
+            const blob = (0, values_1.encodeV2Values)(original);
+            expect((0, values_1.decodeV2Values)(blob)).toEqual(original);
+        });
+        it("handles empty array", () => {
+            expect((0, values_1.decodeV2Values)((0, values_1.encodeV2Values)([]))).toEqual([]);
+        });
+        it("handles large payloads without truncation", () => {
+            const big = Array.from({ length: 500 }, (_, i) => ({
+                id: String(i),
+                name: "field_" + i,
+                value: "x".repeat(200),
+            }));
+            expect((0, values_1.decodeV2Values)((0, values_1.encodeV2Values)(big))).toEqual(big);
+        });
+    });
+    describe("decode — input validation", () => {
+        it("throws on empty string", () => {
+            expect(() => (0, values_1.decodeV2Values)("")).toThrow(/non-empty string/);
+        });
+        it("throws on whitespace-only string", () => {
+            expect(() => (0, values_1.decodeV2Values)("   \n  ")).toThrow(/non-empty string/);
+        });
+        it("throws on non-string input", () => {
+            expect(() => (0, values_1.decodeV2Values)(null)).toThrow(/non-empty string/);
+            expect(() => (0, values_1.decodeV2Values)(undefined)).toThrow(/non-empty string/);
+            expect(() => (0, values_1.decodeV2Values)(123)).toThrow(/non-empty string/);
+        });
+        it("throws with a clear message on non-gzip base64 input", () => {
+            // Valid base64, but the decoded bytes are not gzip.
+            const notGzip = Buffer.from("hello world").toString("base64");
+            expect(() => (0, values_1.decodeV2Values)(notGzip)).toThrow(/decompression failed/);
+        });
+        it("throws on gzip of invalid JSON", () => {
+            const badJson = (0, zlib_1.gzipSync)(Buffer.from("{not valid json", "utf8")).toString("base64");
+            expect(() => (0, values_1.decodeV2Values)(badJson)).toThrow(/not valid JSON/);
+        });
+        it("tolerates trailing whitespace and newlines (common from file reads)", () => {
+            const blob = (0, values_1.encodeV2Values)([{ id: "1", value: "a" }]);
+            expect((0, values_1.decodeV2Values)(blob + "\n")).toEqual([{ id: "1", value: "a" }]);
+            expect((0, values_1.decodeV2Values)("  " + blob + "  ")).toEqual([{ id: "1", value: "a" }]);
+        });
+    });
+    describe("generic typing", () => {
+        it("preserves the caller's expected type", () => {
+            const blob = (0, values_1.encodeV2Values)([{ actionInstanceSysId: "a", id: "1" }]);
+            const decoded = (0, values_1.decodeV2Values)(blob);
+            expect(decoded[0].actionInstanceSysId).toBe("a");
+            expect(decoded[0].id).toBe("1");
+        });
+    });
+});

package/dist/updateSetCommands.js

@@ -283,7 +283,7 @@ async function switchUpdateSetCommand(args) {
         // Extract the actual values from display_value objects
         const sysId = typeof targetUpdateSet.sys_id === 'object' && targetUpdateSet.sys_id !== null ? targetUpdateSet.sys_id.value : targetUpdateSet.sys_id;
         const name = typeof targetUpdateSet.name === 'object' && targetUpdateSet.name !== null ? targetUpdateSet.name.value : targetUpdateSet.name;
-        const applicationName = targetUpdateSet.application?.display_value || (typeof targetUpdateSet.application === 'object' && targetUpdateSet.application !== null ? targetUpdateSet.application.value : targetUpdateSet.application);
+        const applicationName = (targetUpdateSet.application && targetUpdateSet.application.display_value) || (typeof targetUpdateSet.application === 'object' && targetUpdateSet.application !== null ? targetUpdateSet.application.value : targetUpdateSet.application);
         const applicationScope = typeof targetUpdateSet.application === 'object' && targetUpdateSet.application !== null ? targetUpdateSet.application.value : targetUpdateSet.application;
         // Switch to the selected update set
         await switchToUpdateSet(sysId, name, args.scope || applicationScope);
@@ -334,7 +334,7 @@ async function listUpdateSetsCommand(args) {
             const name = typeof updateSet.name === 'object' && updateSet.name !== null ? updateSet.name.value : updateSet.name;
             const description = typeof updateSet.description === 'object' && updateSet.description !== null ? updateSet.description.value : updateSet.description;
             const createdBy = typeof updateSet.sys_created_by === 'object' && updateSet.sys_created_by !== null ? updateSet.sys_created_by.display_value || updateSet.sys_created_by.value : updateSet.sys_created_by;
-            const applicationName = updateSet.application?.display_value || (typeof updateSet.application === 'object' && updateSet.application !== null ? updateSet.application.value : updateSet.application);
+            const applicationName = (updateSet.application && updateSet.application.display_value) || (typeof updateSet.application === 'object' && updateSet.application !== null ? updateSet.application.value : updateSet.application);
             const isCurrent = sysId === currentUpdateSetId;
             const marker = isCurrent ? chalk_1.default.green("► ") : "  ";
             const displayName = isCurrent ? chalk_1.default.green(name) : name;
@@ -616,7 +616,7 @@ async function selectUpdateSet(nameFilter, scopeFilter) {
     const choices = filteredSets.map(us => {
         const name = typeof us.name === 'object' && us.name !== null ? us.name.value : us.name;
         const description = typeof us.description === 'object' && us.description !== null ? us.description.value : us.description;
-        const applicationName = us.application?.display_value || (typeof us.application === 'object' && us.application !== null ? us.application.value : us.application);
+        const applicationName = (us.application && us.application.display_value) || (typeof us.application === 'object' && us.application !== null ? us.application.value : us.application);
         return {
             name: `${name}${applicationName ? ` (${applicationName})` : ""} - ${description || "No description"}`,
             value: us

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tenonhq/sincronia-core",
-  "version": "0.0.82",
+  "version": "0.0.84",
   "description": "Next-gen file syncer",
   "license": "GPL-3.0",
   "main": "./dist/index.js",
@@ -38,7 +38,7 @@
     "typescript": "^5.2.2"
   },
   "dependencies": {
-    "@tenonhq/sincronia-clickup": "^0.0.1",
+    "@tenonhq/sincronia-clickup": "^0.0.6",
     "@tenonhq/sincronia-schema": "^0.0.1",
     "axios": "^1.5.1",
     "axios-cookiejar-support": "^4.0.7",