@tenonhq/sincronia-core 0.0.67 → 0.0.69

package/dist/initSystem/orchestrator.js

@@ -0,0 +1,312 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInit = runInit;
+exports.runLogin = runLogin;
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const dotenv_1 = __importDefault(require("dotenv"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const Logger_1 = require("../Logger");
+const FileUtils_1 = require("../FileUtils");
+const discovery_1 = require("./discovery");
+const corePlugin_1 = require("./corePlugin");
+// ============================================================================
+// Init Context
+// ============================================================================
+/**
+ * @description Builds an InitContext from the current environment.
+ * Reads existing .env if present. Pulls process.env fallbacks only for
+ * env keys declared by the provided plugins (no hardcoded allowlist).
+ */
+function buildInitContext(plugins) {
+    const rootDir = process.cwd();
+    const envPath = path_1.default.resolve(rootDir, ".env");
+    const env = {};
+    // Load existing .env values
+    try {
+        const parsed = dotenv_1.default.parse(fs_1.default.readFileSync(envPath, "utf8"));
+        Object.assign(env, parsed);
+    }
+    catch (e) {
+        // No .env yet — starting fresh
+    }
+    // Pull from process.env for keys declared by plugins but missing from .env
+    const pluginEnvKeys = plugins.flatMap(p => [
+        ...(p.login || []).map(h => h.envKey),
+        ...(p.configure || []).map(h => h.key),
+    ]);
+    pluginEnvKeys.forEach(key => {
+        if (process.env[key] && !env[key]) {
+            env[key] = process.env[key];
+        }
+    });
+    let hasConfig = false;
+    try {
+        fs_1.default.accessSync(path_1.default.join(rootDir, "sinc.config.js"), fs_1.default.constants.F_OK);
+        hasConfig = true;
+    }
+    catch (e) {
+        // No config yet
+    }
+    return { env, answers: {}, rootDir, hasConfig, inquirer: inquirer_1.default, chalk: chalk_1.default };
+}
+// ============================================================================
+// Plugin Selection
+// ============================================================================
+async function promptPluginSelection(externalPlugins) {
+    if (externalPlugins.length === 0) {
+        return [corePlugin_1.corePlugin];
+    }
+    const choices = externalPlugins.map(plugin => ({
+        name: plugin.displayName + " — " + plugin.description,
+        value: plugin.name,
+        checked: false,
+    }));
+    const answer = await inquirer_1.default.prompt([{
+            type: "checkbox",
+            name: "plugins",
+            message: "Which integrations would you like to configure?",
+            choices,
+        }]);
+    const selectedNames = new Set(answer.plugins);
+    const selected = externalPlugins.filter(p => selectedNames.has(p.name));
+    return [corePlugin_1.corePlugin, ...selected];
+}
+async function runLoginPhase(plugin, context) {
+    const hooks = plugin.login;
+    if (!hooks || hooks.length === 0)
+        return;
+    for (const hook of hooks) {
+        const existingValue = context.env[hook.envKey] || "";
+        // Show instructions if provided
+        if (hook.instructions && hook.instructions.length > 0) {
+            Logger_1.logger.info("");
+            hook.instructions.forEach(line => Logger_1.logger.info(line));
+            Logger_1.logger.info("");
+        }
+        // Build the prompt
+        const promptConfig = {
+            type: hook.prompt.type,
+            name: "value",
+            message: hook.prompt.message,
+        };
+        if (hook.prompt.mask) {
+            promptConfig.mask = hook.prompt.mask;
+        }
+        // Show existing value as default for non-password fields
+        if (existingValue && hook.prompt.type !== "password") {
+            promptConfig.default = existingValue;
+        }
+        // Add basic validation for required fields
+        if (hook.required !== false) {
+            promptConfig.validate = (input) => {
+                if (!input || input.trim() === "")
+                    return "This field is required";
+                return true;
+            };
+        }
+        const answer = await inquirer_1.default.prompt([promptConfig]);
+        context.env[hook.envKey] = answer.value.trim();
+    }
+    // Run per-hook validation if defined
+    for (const hook of hooks) {
+        if (hook.validate) {
+            const result = await hook.validate(context.env[hook.envKey], context);
+            if (result !== true) {
+                Logger_1.logger.error(chalk_1.default.red("✗ " + result));
+                throw new Error("Validation failed for " + hook.envKey);
+            }
+        }
+    }
+    // Core plugin gets special post-login validation (all 3 credentials at once)
+    if (plugin.name === "core") {
+        Logger_1.logger.info("Validating credentials...");
+        const coreResult = await (0, corePlugin_1.validateCoreLogin)(context);
+        if (coreResult !== true) {
+            Logger_1.logger.error(chalk_1.default.red("✗ " + coreResult));
+            throw new Error("ServiceNow login failed");
+        }
+        Logger_1.logger.success(chalk_1.default.green("✓ Connected to " + context.env.SN_INSTANCE));
+    }
+}
+async function runConfigurePhase(plugin, context) {
+    const hooks = plugin.configure;
+    if (!hooks || hooks.length === 0)
+        return;
+    for (const hook of hooks) {
+        Logger_1.logger.debug("Running configure hook: " + hook.label);
+        const result = await hook.run(context);
+        if (result !== null && result !== undefined) {
+            context.answers[hook.key] = result;
+        }
+    }
+}
+/**
+ * @description Saves env vars declared by plugins to .env (merge-style).
+ * Only writes keys that plugins explicitly declared via login hooks or
+ * configure hooks — never writes transient context values.
+ */
+function saveEnvVars(context, plugins) {
+    const pluginKeys = new Set();
+    plugins.forEach(plugin => {
+        (plugin.login || []).forEach(hook => pluginKeys.add(hook.envKey));
+        (plugin.configure || []).forEach(hook => {
+            if (context.env[hook.key])
+                pluginKeys.add(hook.key);
+        });
+    });
+    const vars = Array.from(pluginKeys)
+        .filter(key => context.env[key])
+        .map(key => ({ key, value: context.env[key] }));
+    if (vars.length > 0) {
+        (0, FileUtils_1.writeEnvVars)({ vars });
+        // Also set on process.env for immediate use
+        vars.forEach(({ key, value }) => { process.env[key] = value; });
+        Logger_1.logger.success(chalk_1.default.green("✓ Saved to .env (existing values preserved)"));
+    }
+}
+async function runInit(options) {
+    let failed = false;
+    try {
+        Logger_1.logger.info("");
+        Logger_1.logger.info(chalk_1.default.bold("  Sincronia Setup"));
+        Logger_1.logger.info("  " + "═".repeat(40));
+        Logger_1.logger.info("");
+        // 1. Discover plugins
+        const externalPlugins = (0, discovery_1.discoverPlugins)();
+        if (externalPlugins.length > 0) {
+            Logger_1.logger.info("  Detected packages:");
+            Logger_1.logger.info("    ● sincronia-core (" + chalk_1.default.cyan("ServiceNow") + ")");
+            externalPlugins.forEach(p => {
+                Logger_1.logger.info("    ● sincronia-" + p.name + " (" + chalk_1.default.cyan(p.displayName) + ")");
+            });
+            Logger_1.logger.info("");
+        }
+        // 2. Select plugins
+        const selectedPlugins = await promptPluginSelection(externalPlugins);
+        // 3. Build context (passes plugins so env fallback uses their declared keys)
+        const context = buildInitContext(selectedPlugins);
+        // 4. Login phase
+        Logger_1.logger.info("");
+        Logger_1.logger.info(chalk_1.default.bold("  ── Login " + "─".repeat(30)));
+        Logger_1.logger.info("");
+        for (const plugin of selectedPlugins) {
+            await runLoginPhase(plugin, context);
+        }
+        // 5. Save env vars after login
+        saveEnvVars(context, selectedPlugins);
+        // 6. Configure phase
+        Logger_1.logger.info("");
+        Logger_1.logger.info(chalk_1.default.bold("  ── Configure " + "─".repeat(26)));
+        Logger_1.logger.info("");
+        for (const plugin of selectedPlugins) {
+            await runConfigurePhase(plugin, context);
+        }
+        // 7. Initialize phase
+        Logger_1.logger.info("");
+        Logger_1.logger.info(chalk_1.default.bold("  ── Initialize " + "─".repeat(25)));
+        Logger_1.logger.info("");
+        for (const plugin of selectedPlugins) {
+            if (plugin.initialize) {
+                try {
+                    await plugin.initialize(context);
+                }
+                catch (e) {
+                    const msg = e instanceof Error ? e.message : String(e);
+                    Logger_1.logger.error("Initialization failed for " + plugin.displayName + ": " + msg);
+                    failed = true;
+                }
+            }
+        }
+        // 8. Summary
+        Logger_1.logger.info("");
+        Logger_1.logger.info("  " + "═".repeat(40));
+        if (failed) {
+            Logger_1.logger.warn("  Setup completed with errors. Review the output above.");
+        }
+        else {
+            Logger_1.logger.success(chalk_1.default.green("  Setup complete!") + " Run " + chalk_1.default.cyan("sinc watch") + " to start.");
+        }
+        Logger_1.logger.info("");
+    }
+    catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        Logger_1.logger.error("Init failed: " + message);
+    }
+}
+async function runLogin(options) {
+    try {
+        const opts = options || {};
+        // Determine which plugins to log in to
+        let pluginsToLogin;
+        const coreAliases = new Set(["core", "servicenow", "sn"]);
+        if (opts.pluginName) {
+            if (coreAliases.has(opts.pluginName)) {
+                pluginsToLogin = [corePlugin_1.corePlugin];
+            }
+            else {
+                const externalPlugins = (0, discovery_1.discoverPlugins)();
+                const match = externalPlugins.find(p => p.name === opts.pluginName);
+                if (!match) {
+                    Logger_1.logger.error("Plugin '" + opts.pluginName + "' not found. Available plugins:");
+                    externalPlugins.forEach(p => Logger_1.logger.info("  - " + p.name + " (" + p.displayName + ")"));
+                    return;
+                }
+                pluginsToLogin = [match];
+            }
+        }
+        else if (opts.all) {
+            pluginsToLogin = [corePlugin_1.corePlugin, ...(0, discovery_1.discoverPlugins)()];
+        }
+        else {
+            pluginsToLogin = [corePlugin_1.corePlugin];
+        }
+        // Build context with discovered plugins for env key resolution
+        const context = buildInitContext(pluginsToLogin);
+        // Apply CLI flag overrides for non-interactive mode
+        if (opts.instance)
+            context.env.SN_INSTANCE = opts.instance;
+        if (opts.user)
+            context.env.SN_USER = opts.user;
+        if (opts.password)
+            context.env.SN_PASSWORD = opts.password;
+        // Dynamic header based on which plugins are being logged in
+        const pluginNames = pluginsToLogin.map(p => p.displayName).join(" + ");
+        Logger_1.logger.info("");
+        Logger_1.logger.info(chalk_1.default.bold("  " + pluginNames + " Login"));
+        Logger_1.logger.info("  " + "─".repeat(40));
+        Logger_1.logger.info("");
+        // Check if all core credentials provided via flags (non-interactive mode)
+        const hasAllCoreFlags = opts.instance && opts.user && opts.password;
+        if (hasAllCoreFlags && pluginsToLogin.length === 1 && pluginsToLogin[0].name === "core") {
+            Logger_1.logger.info("Validating credentials...");
+            const result = await (0, corePlugin_1.validateCoreLogin)(context);
+            if (result !== true) {
+                Logger_1.logger.error(chalk_1.default.red("✗ " + result));
+                return;
+            }
+            Logger_1.logger.success(chalk_1.default.green("✓ Connected to " + context.env.SN_INSTANCE));
+        }
+        else {
+            for (const plugin of pluginsToLogin) {
+                await runLoginPhase(plugin, context);
+            }
+        }
+        // Save env vars
+        saveEnvVars(context, pluginsToLogin);
+        Logger_1.logger.info("");
+        Logger_1.logger.info("You can now use:");
+        Logger_1.logger.info("  sinc init              — Initialize a new project");
+        Logger_1.logger.info("  sinc watch             — Watch for changes");
+        Logger_1.logger.info("  sinc status            — Check instance connection");
+        Logger_1.logger.info("");
+    }
+    catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        Logger_1.logger.error("Login failed: " + message);
+    }
+}

package/dist/loginCommand.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loginCommand = loginCommand;
+const commands_1 = require("./commands");
+const orchestrator_1 = require("./initSystem/orchestrator");
+/**
+ * @description Command handler for `sinc login`.
+ * Authenticates with ServiceNow and other integrations, saves credentials to .env.
+ */
+async function loginCommand(args) {
+    (0, commands_1.setLogLevel)(args);
+    await (0, orchestrator_1.runLogin)({
+        logLevel: args.logLevel,
+        pluginName: args.plugin || undefined,
+        all: args.all || false,
+        instance: args.instance || undefined,
+        user: args.user || undefined,
+        password: args.password || undefined,
+    });
+}

package/dist/tests/clickupCommands.test.js

@@ -71,7 +71,15 @@ jest.mock("chalk", function () {
         bold: identity,
     };
 });
-jest.mock("fs");
+jest.mock("fs", function () {
+    var actual = jest.requireActual("fs");
+    return Object.assign({}, actual, {
+        readFileSync: jest.fn(),
+        writeFileSync: jest.fn(),
+        existsSync: jest.fn(),
+        promises: actual.promises,
+    });
+});
 jest.mock("child_process");
 // --- Imports (after mocks) ---
 const clickupCommands_1 = require("../clickupCommands");

package/dist/tests/discovery.test.js

@@ -0,0 +1,56 @@
+"use strict";
+// --- Mock setup (must be before imports) ---
+Object.defineProperty(exports, "__esModule", { value: true });
+var mockReaddirSync = jest.fn();
+jest.mock("fs", function () {
+    var actual = jest.requireActual("fs");
+    return Object.assign({}, actual, {
+        readdirSync: mockReaddirSync,
+    });
+});
+jest.mock("../Logger", function () {
+    return {
+        logger: {
+            info: jest.fn(),
+            error: jest.fn(),
+            warn: jest.fn(),
+            debug: jest.fn(),
+            success: jest.fn(),
+        },
+    };
+});
+const discovery_1 = require("../initSystem/discovery");
+const Logger_1 = require("../Logger");
+describe("discoverPlugins", function () {
+    beforeEach(function () {
+        mockReaddirSync.mockReset();
+        // Default: no directories found
+        mockReaddirSync.mockImplementation(function () {
+            throw new Error("ENOENT");
+        });
+    });
+    it("returns empty array when no node_modules found", function () {
+        const plugins = (0, discovery_1.discoverPlugins)();
+        expect(plugins).toEqual([]);
+    });
+    it("skips sincronia-core and sincronia-types", function () {
+        mockReaddirSync.mockReturnValue([
+            "sincronia-core",
+            "sincronia-types",
+        ]);
+        const plugins = (0, discovery_1.discoverPlugins)();
+        expect(plugins).toEqual([]);
+    });
+    it("warns on plugin load failure", function () {
+        mockReaddirSync.mockReturnValue(["sincronia-nonexistent"]);
+        (0, discovery_1.discoverPlugins)();
+        expect(Logger_1.logger.warn).toHaveBeenCalled();
+    });
+    it("skips packages without sincPlugin export", function () {
+        mockReaddirSync.mockReturnValue(["sincronia-sass-plugin"]);
+        // sass-plugin exists but doesn't export sincPlugin — it just won't be added
+        const plugins = (0, discovery_1.discoverPlugins)();
+        const names = plugins.map(function (p) { return p.name; });
+        expect(names).not.toContain("sass-plugin");
+    });
+});

package/dist/tests/orchestrator.test.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const corePlugin_1 = require("../initSystem/corePlugin");
+describe("normalizeInstance", function () {
+    it("strips https:// prefix", function () {
+        expect((0, corePlugin_1.normalizeInstance)("https://mycompany.service-now.com")).toBe("mycompany.service-now.com/");
+    });
+    it("strips http:// prefix", function () {
+        expect((0, corePlugin_1.normalizeInstance)("http://mycompany.service-now.com")).toBe("mycompany.service-now.com/");
+    });
+    it("adds trailing slash if missing", function () {
+        expect((0, corePlugin_1.normalizeInstance)("mycompany.service-now.com")).toBe("mycompany.service-now.com/");
+    });
+    it("preserves trailing slash if present", function () {
+        expect((0, corePlugin_1.normalizeInstance)("mycompany.service-now.com/")).toBe("mycompany.service-now.com/");
+    });
+    it("trims whitespace", function () {
+        expect((0, corePlugin_1.normalizeInstance)("  mycompany.service-now.com  ")).toBe("mycompany.service-now.com/");
+    });
+    it("handles full URL with protocol and trailing slash", function () {
+        expect((0, corePlugin_1.normalizeInstance)("https://mycompany.service-now.com/")).toBe("mycompany.service-now.com/");
+    });
+});

package/dist/tests/writeEnvVar.test.js

@@ -0,0 +1,119 @@
+"use strict";
+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 path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const FileUtils_1 = require("../FileUtils");
+describe("writeEnvVar", function () {
+    let tmpDir;
+    let envPath;
+    beforeEach(function () {
+        tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "sinc-test-"));
+        envPath = path_1.default.join(tmpDir, ".env");
+    });
+    afterEach(function () {
+        try {
+            fs_1.default.rmSync(tmpDir, { recursive: true });
+        }
+        catch (e) {
+            // cleanup best-effort
+        }
+    });
+    it("creates a new .env file from scratch", function () {
+        (0, FileUtils_1.writeEnvVar)({ key: "FOO", value: "bar", envPath });
+        const content = fs_1.default.readFileSync(envPath, "utf8");
+        expect(content).toBe("FOO=bar\n");
+    });
+    it("replaces an existing key", function () {
+        fs_1.default.writeFileSync(envPath, "FOO=old\nBAR=keep\n", "utf8");
+        (0, FileUtils_1.writeEnvVar)({ key: "FOO", value: "new", envPath });
+        const content = fs_1.default.readFileSync(envPath, "utf8");
+        expect(content).toContain("FOO=new");
+        expect(content).toContain("BAR=keep");
+        expect(content).not.toContain("FOO=old");
+    });
+    it("appends a new key without clobbering existing ones", function () {
+        fs_1.default.writeFileSync(envPath, "EXISTING=value\n", "utf8");
+        (0, FileUtils_1.writeEnvVar)({ key: "NEW_KEY", value: "new_value", envPath });
+        const content = fs_1.default.readFileSync(envPath, "utf8");
+        expect(content).toContain("EXISTING=value");
+        expect(content).toContain("NEW_KEY=new_value");
+    });
+    it("handles file with no trailing newline", function () {
+        fs_1.default.writeFileSync(envPath, "A=1", "utf8");
+        (0, FileUtils_1.writeEnvVar)({ key: "B", value: "2", envPath });
+        const content = fs_1.default.readFileSync(envPath, "utf8");
+        expect(content).toContain("A=1");
+        expect(content).toContain("B=2");
+        // Should not produce "A=1B=2" on one line
+        const lines = content.trim().split("\n");
+        expect(lines.length).toBe(2);
+    });
+    it("handles keys with regex metacharacters", function () {
+        fs_1.default.writeFileSync(envPath, "MY.KEY[0]=old\n", "utf8");
+        (0, FileUtils_1.writeEnvVar)({ key: "MY.KEY[0]", value: "new", envPath });
+        const content = fs_1.default.readFileSync(envPath, "utf8");
+        expect(content).toContain("MY.KEY[0]=new");
+        expect(content).not.toContain("MY.KEY[0]=old");
+        // Should not have duplicates
+        const matches = content.match(/MY\.KEY\[0\]/g);
+        expect(matches).toHaveLength(1);
+    });
+});
+describe("writeEnvVars", function () {
+    let tmpDir;
+    let envPath;
+    beforeEach(function () {
+        tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "sinc-test-"));
+        envPath = path_1.default.join(tmpDir, ".env");
+    });
+    afterEach(function () {
+        try {
+            fs_1.default.rmSync(tmpDir, { recursive: true });
+        }
+        catch (e) {
+            // cleanup best-effort
+        }
+    });
+    it("writes multiple vars in a single call", function () {
+        (0, FileUtils_1.writeEnvVars)({
+            vars: [
+                { key: "A", value: "1" },
+                { key: "B", value: "2" },
+                { key: "C", value: "3" },
+            ],
+            envPath,
+        });
+        const content = fs_1.default.readFileSync(envPath, "utf8");
+        expect(content).toContain("A=1");
+        expect(content).toContain("B=2");
+        expect(content).toContain("C=3");
+    });
+    it("merges into existing file preserving unrelated keys", function () {
+        fs_1.default.writeFileSync(envPath, "KEEP=yes\nUPDATE=old\n", "utf8");
+        (0, FileUtils_1.writeEnvVars)({
+            vars: [
+                { key: "UPDATE", value: "new" },
+                { key: "ADDED", value: "fresh" },
+            ],
+            envPath,
+        });
+        const content = fs_1.default.readFileSync(envPath, "utf8");
+        expect(content).toContain("KEEP=yes");
+        expect(content).toContain("UPDATE=new");
+        expect(content).toContain("ADDED=fresh");
+        expect(content).not.toContain("UPDATE=old");
+    });
+    it("handles empty file", function () {
+        fs_1.default.writeFileSync(envPath, "", "utf8");
+        (0, FileUtils_1.writeEnvVars)({
+            vars: [{ key: "X", value: "y" }],
+            envPath,
+        });
+        const content = fs_1.default.readFileSync(envPath, "utf8");
+        expect(content).toBe("X=y\n");
+    });
+});