@tenonhq/sincronia-core 0.0.78 → 0.0.80

package/dist/commands.js

@@ -43,6 +43,7 @@ exports.downloadCommand = downloadCommand;
 exports.initCommand = initCommand;
 exports.buildCommand = buildCommand;
 exports.deployCommand = deployCommand;
+exports.taskClearCommand = taskClearCommand;
 exports.statusCommand = statusCommand;
 const ConfigManager = __importStar(require("./config"));
 const AppUtils = __importStar(require("./appUtils"));
@@ -54,6 +55,8 @@ const snClient_1 = require("./snClient");
 const inquirer_1 = __importDefault(require("inquirer"));
 const gitUtils_1 = require("./gitUtils");
 const FileUtils_1 = require("./FileUtils");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
 function setLogLevel(args) {
     Logger_1.logger.setLogLevel(args.logLevel);
 }
@@ -300,6 +303,26 @@ async function deployCommand(args) {
         throw e;
     }
 }
+async function taskClearCommand(args) {
+    setLogLevel(args);
+    var taskPath = path.resolve(process.cwd(), ".sinc-active-task.json");
+    if (fs.existsSync(taskPath)) {
+        try {
+            var parsed = JSON.parse(fs.readFileSync(taskPath, "utf8"));
+            var taskName = parsed.taskName || parsed.taskId || "unknown";
+            fs.unlinkSync(taskPath);
+            Logger_1.logger.success("Active task '" + taskName + "' cleared.");
+        }
+        catch (e) {
+            // File exists but can't be parsed — still remove it
+            fs.unlinkSync(taskPath);
+            Logger_1.logger.success("Active task file removed.");
+        }
+    }
+    else {
+        Logger_1.logger.info("No active task is currently set.");
+    }
+}
 async function statusCommand() {
     try {
         const client = (0, snClient_1.defaultClient)();
@@ -308,6 +331,17 @@ async function statusCommand() {
         Logger_1.logger.info("Instance:      " + (process.env.SN_INSTANCE || "not set"));
         Logger_1.logger.info("User:          " + (process.env.SN_USER || "not set"));
         Logger_1.logger.info("Active scope:  " + scopeObj.scope);
+        // Read update set config
+        var updateSetConfig = {};
+        var updateSetConfigPath = path.resolve(process.cwd(), ".sinc-update-sets.json");
+        try {
+            if (fs.existsSync(updateSetConfigPath)) {
+                updateSetConfig = JSON.parse(fs.readFileSync(updateSetConfigPath, "utf8"));
+            }
+        }
+        catch (e) {
+            Logger_1.logger.warn("Failed to parse .sinc-update-sets.json: " + (e instanceof Error ? e.message : String(e)));
+        }
         if (config.scopes) {
             var scopeNames = Object.keys(config.scopes);
             Logger_1.logger.info("\nConfigured scopes (" + scopeNames.length + "):");
@@ -318,7 +352,10 @@ async function statusCommand() {
                     ? scopeConf.sourceDirectory
                     : "src/" + scopeName;
                 var marker = scopeName === scopeObj.scope ? " (active)" : "";
-                Logger_1.logger.info("  " + scopeName + marker + " — " + srcDir);
+                var updateSetInfo = updateSetConfig[scopeName]
+                    ? " [update set: " + updateSetConfig[scopeName].name + "]"
+                    : " [no update set configured]";
+                Logger_1.logger.info("  " + scopeName + marker + " — " + srcDir + updateSetInfo);
             }
         }
     }

package/dist/config.js

@@ -223,7 +223,7 @@ function generateConfigFile(params) {
         "\t\t\tmatch: /sys_script_include.*\\.ts$/,\n" +
         "\t\t\tplugins: [\n" +
         "\t\t\t\t{\n" +
-        "\t\t\t\t\tname: \"@sincronia/typescript-plugin\",\n" +
+        "\t\t\t\t\tname: \"@tenonhq/sincronia-typescript-plugin\",\n" +
         "\t\t\t\t\toptions: {\n" +
         "\t\t\t\t\t\ttranspile: true,\n" +
         "\t\t\t\t\t\ttypeCheck: true,\n" +
@@ -231,7 +231,7 @@ function generateConfigFile(params) {
         "\t\t\t\t\t},\n" +
         "\t\t\t\t},\n" +
         "\t\t\t\t{\n" +
-        "\t\t\t\t\tname: \"@sincronia/eslint-plugin\",\n" +
+        "\t\t\t\t\tname: \"@tenonhq/sincronia-eslint-plugin\",\n" +
         "\t\t\t\t\toptions: {\n" +
         "\t\t\t\t\t\tconfigFile: \"./.eslintrc.js\",\n" +
         "\t\t\t\t\t\tfix: false,\n" +
@@ -239,13 +239,13 @@ function generateConfigFile(params) {
         "\t\t\t\t\t},\n" +
         "\t\t\t\t},\n" +
         "\t\t\t\t{\n" +
-        "\t\t\t\t\tname: \"@sincronia/babel-plugin\",\n" +
+        "\t\t\t\t\tname: \"@tenonhq/sincronia-babel-plugin\",\n" +
         "\t\t\t\t\toptions: {\n" +
         "\t\t\t\t\t\tconfigFile: \"./.babelrc\",\n" +
         "\t\t\t\t\t},\n" +
         "\t\t\t\t},\n" +
         "\t\t\t\t{\n" +
-        "\t\t\t\t\tname: \"@sincronia/prettier-plugin\",\n" +
+        "\t\t\t\t\tname: \"@tenonhq/sincronia-prettier-plugin\",\n" +
         "\t\t\t\t\toptions: {\n" +
         "\t\t\t\t\t\tconfigFile: \"./.prettierrc.js\",\n" +
         "\t\t\t\t\t},\n" +

package/dist/snClient.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.unwrapSNResponse = exports.defaultClient = exports.snClient = exports.processPushResponse = exports.retryOnErr = void 0;
+exports.unwrapSNResponse = exports.defaultClient = exports.snClient = exports.processPushResponse = exports.retryOnHttpErr = exports.retryOnErr = void 0;
 exports.unwrapTableAPIFirstItem = unwrapTableAPIFirstItem;
 const axios_1 = __importDefault(require("axios"));
 const axios_cookiejar_support_1 = require("axios-cookiejar-support");
@@ -41,6 +41,86 @@ const retryOnErr = async (f, allowedRetries, msBetween = 0, onRetry) => {
     }
 };
 exports.retryOnErr = retryOnErr;
+function _getHttpStatus(e) {
+    if (axios_1.default.isAxiosError(e) && e.response) {
+        return e.response.status;
+    }
+    return undefined;
+}
+function _getRetryAfterMs(e) {
+    if (axios_1.default.isAxiosError(e) && e.response && e.response.headers) {
+        var retryAfter = e.response.headers["retry-after"];
+        if (retryAfter) {
+            var seconds = Number(retryAfter);
+            if (!isNaN(seconds) && seconds > 0) {
+                return seconds * 1000;
+            }
+        }
+    }
+    return 10000; // Default 10s for 429 without Retry-After
+}
+const retryOnHttpErr = async (f, recSummary) => {
+    var maxServerRetries = 3;
+    var backoffMs = 1000;
+    var attempt = 0;
+    while (true) {
+        try {
+            return await f();
+        }
+        catch (e) {
+            var status = _getHttpStatus(e);
+            attempt++;
+            // 401/403: Auth failure — fail immediately
+            if (status === 401 || status === 403) {
+                var authMsg = status === 401 ? "Unauthorized" : "Forbidden";
+                Logger_1.logger.error(authMsg + " (" + status + ") pushing " + recSummary +
+                    ". Verify your ServiceNow credentials and permissions.");
+                throw e;
+            }
+            // 404: Record not found — fail immediately
+            if (status === 404) {
+                Logger_1.logger.error("Record not found (404) pushing " + recSummary +
+                    ". The record may have been deleted from the instance.");
+                throw e;
+            }
+            // 429: Rate limited — honor Retry-After, then retry
+            if (status === 429) {
+                var retryWait = _getRetryAfterMs(e);
+                Logger_1.logger.warn("Rate limited (429) pushing " + recSummary +
+                    ". Waiting " + Math.round(retryWait / 1000) + "s before retry.");
+                await (0, genericUtils_1.wait)(retryWait);
+                continue;
+            }
+            // 500/502/503: Server error — exponential backoff, max 3 retries
+            if (status === 500 || status === 502 || status === 503) {
+                if (attempt > maxServerRetries) {
+                    Logger_1.logger.error("Server error (" + status + ") pushing " + recSummary +
+                        " after " + maxServerRetries + " retries. Giving up.");
+                    throw e;
+                }
+                var cappedBackoff = Math.min(backoffMs, 8000);
+                Logger_1.logger.warn("Server error (" + status + ") pushing " + recSummary +
+                    ". Retrying in " + (cappedBackoff / 1000) + "s (" +
+                    (maxServerRetries - attempt) + " retries left).");
+                await (0, genericUtils_1.wait)(cappedBackoff);
+                backoffMs = backoffMs * 2;
+                continue;
+            }
+            // Unknown status or non-HTTP error — retry once, then fail
+            if (attempt > 1) {
+                var errDetail = status ? "HTTP " + status : "unknown error";
+                Logger_1.logger.error("Push failed for " + recSummary + " (" + errDetail +
+                    ") after 1 retry. Giving up.");
+                throw e;
+            }
+            var retryDetail = status ? "HTTP " + status : "unknown error";
+            Logger_1.logger.warn("Unexpected error (" + retryDetail + ") pushing " + recSummary +
+                ". Retrying once.");
+            await (0, genericUtils_1.wait)(1000);
+        }
+    }
+};
+exports.retryOnHttpErr = retryOnHttpErr;
 const processPushResponse = (response, recSummary) => {
     const { status } = response;
     if (status === 404) {

package/dist/tests/ensureUpdateSetWarnings.test.js

@@ -0,0 +1,218 @@
+"use strict";
+/**
+ * Tests for US-006: Surface warning when no update set is configured
+ *
+ * Validates:
+ * - Prominent warning when readActiveTask() returns null and no update set configured
+ * - Warning message includes specific text about Default and remediation steps
+ * - Invalid scope name produces a clear error (not a global-scope update set)
+ * - scopeSysId validated before creating update set; null/undefined skips with error
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+// --- Mock setup ---
+const mockSNClient = {
+    getScopeId: jest.fn(),
+    getUserSysId: jest.fn(),
+    getCurrentAppUserPrefSysId: jest.fn(),
+    updateCurrentAppUserPref: jest.fn(),
+    createCurrentAppUserPref: jest.fn(),
+    changeScope: jest.fn().mockResolvedValue(undefined),
+    createUpdateSet: jest.fn(),
+    changeUpdateSet: jest.fn(),
+    client: {
+        get: jest.fn(),
+    },
+};
+jest.mock("../snClient", () => ({
+    defaultClient: jest.fn(() => mockSNClient),
+    unwrapSNResponse: jest.fn((val) => val),
+}));
+jest.mock("../FileUtils", () => ({
+    getFileContextFromPath: jest.fn(),
+    getFileContextWithSkipReason: jest.fn(),
+}));
+jest.mock("../appUtils", () => ({
+    groupAppFiles: jest.fn(),
+    pushFiles: jest.fn(),
+}));
+jest.mock("../logMessages", () => ({
+    logFilePush: jest.fn(),
+}));
+jest.mock("../recentEdits", () => ({
+    writeRecentEdit: jest.fn(),
+}));
+jest.mock("../Logger", () => ({
+    logger: {
+        info: jest.fn(),
+        error: jest.fn(),
+        warn: jest.fn(),
+        debug: jest.fn(),
+        success: jest.fn(),
+        getLogLevel: jest.fn().mockReturnValue("info"),
+    },
+}));
+jest.mock("../config", () => ({
+    loadConfigs: jest.fn().mockResolvedValue(undefined),
+    getConfig: jest.fn(),
+    getRootDir: jest.fn().mockReturnValue("/project"),
+    updateManifest: jest.fn(),
+    getManifest: jest.fn(),
+    getSourcePath: jest.fn().mockReturnValue("/project/src"),
+    getScopeManifestPath: jest.fn((scope) => `/project/sinc.manifest.${scope}.json`),
+    getManifestPath: jest.fn().mockReturnValue("/project/sinc.manifest.json"),
+}));
+// Filesystem mock store
+var mockFsStore = {};
+jest.mock("fs", () => ({
+    existsSync: jest.fn((p) => {
+        return p in mockFsStore;
+    }),
+    readFileSync: jest.fn((p) => {
+        if (p in mockFsStore)
+            return mockFsStore[p];
+        throw new Error("ENOENT: " + p);
+    }),
+    writeFileSync: jest.fn((p, data) => {
+        mockFsStore[p] = data;
+    }),
+    statSync: jest.fn(() => ({ mtimeMs: Date.now() })),
+    promises: {
+        readFile: jest.fn(),
+        writeFile: jest.fn(),
+        readdir: jest.fn(),
+        mkdir: jest.fn(),
+        access: jest.fn(),
+        stat: jest.fn(),
+    },
+}));
+jest.mock("chokidar", () => ({
+    watch: jest.fn(() => ({
+        on: jest.fn().mockReturnThis(),
+        close: jest.fn(),
+    })),
+}));
+jest.mock("lodash", () => {
+    var actual = jest.requireActual("lodash");
+    return {
+        ...actual,
+        debounce: jest.fn((fn) => {
+            var wrapper = jest.fn();
+            wrapper.cancel = jest.fn();
+            wrapper.flush = jest.fn(() => fn());
+            return wrapper;
+        }),
+    };
+});
+jest.mock("axios", () => ({
+    default: {
+        create: jest.fn(() => ({
+            get: jest.fn().mockResolvedValue({ data: { result: null } }),
+        })),
+    },
+}));
+// --- Imports ---
+const Logger_1 = require("../Logger");
+const MultiScopeWatcher_1 = require("../MultiScopeWatcher");
+// --- Tests ---
+describe("US-006: Surface warning when no update set is configured", () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockFsStore = {};
+        // Default: scope switching succeeds
+        mockSNClient.getScopeId.mockResolvedValue([{ sys_id: "scope_sys_id" }]);
+        mockSNClient.getUserSysId.mockResolvedValue([{ sys_id: "user_sys_id" }]);
+        mockSNClient.getCurrentAppUserPrefSysId.mockResolvedValue([{ sys_id: "pref_sys_id" }]);
+        mockSNClient.updateCurrentAppUserPref.mockResolvedValue({});
+        mockSNClient.createCurrentAppUserPref.mockResolvedValue({});
+    });
+    afterEach(() => {
+        (0, MultiScopeWatcher_1.stopMultiScopeWatching)();
+    });
+    it("warns with specific message when no active task and no update set configured", async () => {
+        // No .sinc-update-sets.json and no .sinc-active-task.json
+        await MultiScopeWatcher_1.multiScopeWatcher.ensureUpdateSetForScope("x_test_core");
+        expect(Logger_1.logger.warn).toHaveBeenCalledWith(expect.stringContaining("No update set configured for scope x_test_core"));
+        expect(Logger_1.logger.warn).toHaveBeenCalledWith(expect.stringContaining("Changes will go to Default"));
+        expect(Logger_1.logger.warn).toHaveBeenCalledWith(expect.stringContaining("sinc createUpdateSet"));
+        expect(Logger_1.logger.warn).toHaveBeenCalledWith(expect.stringContaining("activate a task in the dashboard"));
+    });
+    it("does not warn when update set already configured for scope", async () => {
+        // Pre-populate the update set config
+        var configPath = require("path").resolve(process.cwd(), ".sinc-update-sets.json");
+        mockFsStore[configPath] = JSON.stringify({
+            x_test_core: { sys_id: "us_123", name: "My Update Set" }
+        });
+        await MultiScopeWatcher_1.multiScopeWatcher.ensureUpdateSetForScope("x_test_core");
+        // Should return early — no warning
+        expect(Logger_1.logger.warn).not.toHaveBeenCalled();
+        expect(Logger_1.logger.error).not.toHaveBeenCalled();
+    });
+    it("logs error and skips creation when scope not found on instance (scopeSysId is undefined)", async () => {
+        // Active task exists so we get past the no-task check
+        var taskPath = require("path").resolve(process.cwd(), ".sinc-active-task.json");
+        mockFsStore[taskPath] = JSON.stringify({
+            taskId: "abc123",
+            taskName: "Test Task",
+            taskDescription: "Test",
+            updateSetName: "CU-abc123 Test Task",
+            description: "Test update set",
+            taskUrl: "https://example.com",
+            scopes: {},
+        });
+        // getScopeId returns empty — scope doesn't exist
+        mockSNClient.getScopeId.mockResolvedValue([]);
+        await MultiScopeWatcher_1.multiScopeWatcher.ensureUpdateSetForScope("x_invalid_scope");
+        expect(Logger_1.logger.error).toHaveBeenCalledWith(expect.stringContaining("x_invalid_scope"));
+        expect(Logger_1.logger.error).toHaveBeenCalledWith(expect.stringContaining("not found on the instance"));
+        // Should NOT attempt to create an update set
+        expect(mockSNClient.createUpdateSet).not.toHaveBeenCalled();
+        expect(mockSNClient.client.get).not.toHaveBeenCalled();
+    });
+    it("logs error and skips creation when getScopeId returns null", async () => {
+        var taskPath = require("path").resolve(process.cwd(), ".sinc-active-task.json");
+        mockFsStore[taskPath] = JSON.stringify({
+            taskId: "abc123",
+            taskName: "Test Task",
+            taskDescription: "Test",
+            updateSetName: "CU-abc123 Test Task",
+            description: "Test update set",
+            taskUrl: "https://example.com",
+            scopes: {},
+        });
+        // getScopeId returns null
+        mockSNClient.getScopeId.mockResolvedValue(null);
+        await MultiScopeWatcher_1.multiScopeWatcher.ensureUpdateSetForScope("x_bad_scope");
+        expect(Logger_1.logger.error).toHaveBeenCalledWith(expect.stringContaining("x_bad_scope"));
+        expect(Logger_1.logger.error).toHaveBeenCalledWith(expect.stringContaining("not found on the instance"));
+        expect(mockSNClient.createUpdateSet).not.toHaveBeenCalled();
+    });
+    it("proceeds to create update set when scope is valid", async () => {
+        var taskPath = require("path").resolve(process.cwd(), ".sinc-active-task.json");
+        mockFsStore[taskPath] = JSON.stringify({
+            taskId: "abc123",
+            taskName: "Test Task",
+            taskDescription: "Test",
+            updateSetName: "CU-abc123 Test Task",
+            description: "Test update set",
+            taskUrl: "https://example.com",
+            scopes: {},
+        });
+        // Valid scope
+        mockSNClient.getScopeId.mockResolvedValue([{ sys_id: "valid_scope_sys_id" }]);
+        // Search returns existing update set
+        mockSNClient.client.get.mockResolvedValue({
+            data: { result: [{ sys_id: "us_existing", name: "CU-abc123 Test Task", state: "in progress" }] }
+        });
+        // changeUpdateSet succeeds
+        mockSNClient.changeUpdateSet.mockResolvedValue(undefined);
+        await MultiScopeWatcher_1.multiScopeWatcher.ensureUpdateSetForScope("x_valid_scope");
+        // Should have searched for existing update sets (scope was valid)
+        expect(mockSNClient.client.get).toHaveBeenCalled();
+        // No "not found on the instance" error
+        var errorCalls = Logger_1.logger.error.mock.calls.map(function (c) { return c[0]; });
+        var hasInvalidScopeError = errorCalls.some(function (msg) {
+            return msg.indexOf("not found on the instance") !== -1;
+        });
+        expect(hasInvalidScopeError).toBe(false);
+    });
+});