@tenonhq/dovetail-core 0.0.85

package/dist/initSystem/corePlugin.js

@@ -0,0 +1,344 @@
+"use strict";
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.corePlugin = void 0;
+exports.validateCoreLogin = validateCoreLogin;
+exports.normalizeInstance = normalizeInstance;
+const snClient_1 = require("../snClient");
+const Logger_1 = require("../Logger");
+const ConfigManager = __importStar(require("../config"));
+const allScopesCommands_1 = require("../allScopesCommands");
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+// Read whichever project config exists (dove.config.js preferred, sinc.config.js as legacy fallback).
+// Returns the parsed module or null if neither exists / cannot be required.
+function readExistingProjectConfig(rootDir) {
+    var names = ["dove.config.js", "sinc.config.js"];
+    for (var i = 0; i < names.length; i++) {
+        var p = path_1.default.join(rootDir, names[i]);
+        if (fs_1.default.existsSync(p)) {
+            try {
+                return require(p);
+            }
+            catch (e) {
+                return null;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * @description Core init plugin — handles ServiceNow authentication, app selection, and file download.
+ * This plugin is always included in `dove init` and `dove login`.
+ */
+exports.corePlugin = {
+    name: "core",
+    displayName: "ServiceNow",
+    description: "Connect to a ServiceNow instance and sync application files",
+    login: [
+        {
+            envKey: "SN_INSTANCE",
+            prompt: {
+                type: "input",
+                message: "ServiceNow instance (e.g. mycompany.service-now.com):",
+            },
+            required: true,
+        },
+        {
+            envKey: "SN_USER",
+            prompt: {
+                type: "input",
+                message: "Username:",
+            },
+            required: true,
+        },
+        {
+            envKey: "SN_PASSWORD",
+            prompt: {
+                type: "password",
+                message: "Password:",
+                mask: "*",
+            },
+            required: true,
+        },
+    ],
+    configure: [
+        {
+            key: "apps",
+            label: "Selecting ServiceNow applications",
+            run: async (context) => {
+                var baseUrl = instanceBaseUrl(context.env.SN_INSTANCE);
+                var client = (0, snClient_1.snClient)(baseUrl, context.env.SN_USER, context.env.SN_PASSWORD);
+                Logger_1.logger.info("Fetching application list...");
+                var apps = await (0, snClient_1.unwrapSNResponse)(client.getAppList());
+                if (apps.length === 0) {
+                    Logger_1.logger.warn("No applications found on this instance.");
+                    return null;
+                }
+                // Pre-check scopes that exist in the current config
+                var existingScopes = new Set();
+                if (context.hasConfig) {
+                    var existingConfig = readExistingProjectConfig(context.rootDir);
+                    if (existingConfig && existingConfig.scopes) {
+                        Object.keys(existingConfig.scopes).forEach(function (s) {
+                            existingScopes.add(s);
+                        });
+                    }
+                }
+                var choices = apps.map(function (app) {
+                    return {
+                        name: app.displayName + " (" + app.scope + ")",
+                        value: app.scope,
+                        short: app.displayName,
+                        checked: existingScopes.has(app.scope),
+                    };
+                });
+                var answer = await inquirer_1.default.prompt([{
+                        type: "checkbox",
+                        name: "apps",
+                        message: "Which apps would you like to work with? (space to select, enter to confirm)",
+                        choices: choices,
+                        validate: function (input) {
+                            if (input.length === 0)
+                                return "Select at least one application.";
+                            return true;
+                        },
+                    }]);
+                var selectedScopes = answer.apps;
+                context.answers.selectedScopes = selectedScopes;
+                context.answers.selectedScope = selectedScopes[0]; // backward compat
+                context.answers.apps = apps;
+                // Prompt for source directory per selected scope
+                var scopeDirectories = {};
+                Logger_1.logger.info("");
+                Logger_1.logger.info(chalk_1.default.bold("  Source directories:"));
+                for (var i = 0; i < selectedScopes.length; i++) {
+                    var scope = selectedScopes[i];
+                    var app = apps.find(function (a) { return a.scope === scope; });
+                    var displayName = app ? app.displayName : scope;
+                    // Check if existing config already has a sourceDirectory for this scope
+                    var existingDir = "";
+                    if (existingScopes.has(scope)) {
+                        var existingCfg = readExistingProjectConfig(context.rootDir);
+                        var cfgScopes = existingCfg && existingCfg.scopes;
+                        if (cfgScopes && cfgScopes[scope] && cfgScopes[scope].sourceDirectory) {
+                            existingDir = cfgScopes[scope].sourceDirectory;
+                        }
+                    }
+                    // Suggest a friendly name from displayName, or use existing
+                    var suggestedDir = existingDir || ("src/" + displayName.replace(/\s+/g, ""));
+                    var dirAnswer = await inquirer_1.default.prompt([{
+                            type: "input",
+                            name: "dir",
+                            message: scope + ":",
+                            default: suggestedDir,
+                        }]);
+                    scopeDirectories[scope] = dirAnswer.dir;
+                }
+                context.answers.scopeDirectories = scopeDirectories;
+                return selectedScopes;
+            },
+        },
+    ],
+    initialize: async (context) => {
+        var selectedScopes = context.answers.selectedScopes || [];
+        if (selectedScopes.length === 0) {
+            // Backward compat: single scope from old flow
+            if (context.answers.selectedScope) {
+                selectedScopes = [context.answers.selectedScope];
+            }
+            else {
+                Logger_1.logger.warn("No applications selected — skipping initialization.");
+                return;
+            }
+        }
+        var rootDir = context.rootDir;
+        var doveConfigPath = path_1.default.join(rootDir, "dove.config.js");
+        var sincConfigPath = path_1.default.join(rootDir, "sinc.config.js");
+        var scopeDirectories = context.answers.scopeDirectories || {};
+        // Write or preserve config. New configs are always written as dove.config.js;
+        // existing sinc.config.js files are honored as legacy until the user runs `dove migrate`.
+        var configAction = context.answers.configAction || "keep";
+        var existingConfigPath = null;
+        if (fs_1.default.existsSync(doveConfigPath))
+            existingConfigPath = doveConfigPath;
+        else if (fs_1.default.existsSync(sincConfigPath))
+            existingConfigPath = sincConfigPath;
+        if (!existingConfigPath || configAction === "replace") {
+            Logger_1.logger.info("Generating dove.config.js...");
+            var scopeEntries = selectedScopes.map(function (scope) {
+                return {
+                    scope: scope,
+                    sourceDirectory: scopeDirectories[scope] || ("src/" + scope),
+                };
+            });
+            fs_1.default.writeFileSync(doveConfigPath, ConfigManager.generateConfigFile({ scopes: scopeEntries }), "utf8");
+            Logger_1.logger.success(chalk_1.default.green("✓ Generated dove.config.js with " + selectedScopes.length + " scope(s)"));
+            if (existingConfigPath === sincConfigPath) {
+                Logger_1.logger.warn("Legacy sinc.config.js still present alongside new dove.config.js. Run 'dove migrate' or delete sinc.config.js once you're satisfied.");
+            }
+        }
+        else {
+            var configFileName = path_1.default.basename(existingConfigPath);
+            Logger_1.logger.info(configFileName + " already exists — preserving configuration.");
+        }
+        // Reload configs so ConfigManager picks up the new/existing config
+        try {
+            await ConfigManager.loadConfigs();
+        }
+        catch (e) {
+            Logger_1.logger.warn("Config reload incomplete — this is expected during first-time init.");
+        }
+        // Check which scopes already have manifests
+        var scopesWithManifests = [];
+        var scopesToDownload = [];
+        for (var i = 0; i < selectedScopes.length; i++) {
+            var scope = selectedScopes[i];
+            var doveManifestPath = path_1.default.join(rootDir, "dove.manifest." + scope + ".json");
+            var sincManifestPath = path_1.default.join(rootDir, "dove.manifest." + scope + ".json");
+            var hasManifest = fs_1.default.existsSync(doveManifestPath) || fs_1.default.existsSync(sincManifestPath);
+            if (hasManifest) {
+                scopesWithManifests.push(scope);
+            }
+            else {
+                scopesToDownload.push(scope);
+            }
+        }
+        // Batch prompt for scopes that already have manifests
+        if (scopesWithManifests.length > 0) {
+            var redownload = await inquirer_1.default.prompt([{
+                    type: "confirm",
+                    name: "confirmed",
+                    message: scopesWithManifests.length + " scope(s) already have manifests (" + scopesWithManifests.join(", ") + "). Re-download?",
+                    default: false,
+                }]);
+            if (redownload.confirmed) {
+                scopesToDownload = scopesToDownload.concat(scopesWithManifests);
+            }
+        }
+        if (scopesToDownload.length === 0) {
+            Logger_1.logger.info("No scopes to download — all manifests up to date.");
+            return;
+        }
+        // Download all scopes using the battle-tested processScope pipeline
+        Logger_1.logger.info("Downloading " + scopesToDownload.length + " scope(s)...");
+        var config = ConfigManager.getConfig();
+        var scopePromises = scopesToDownload.map(function (scopeName) {
+            var scopeConfig = (config.scopes && config.scopes[scopeName]) || {};
+            return (0, allScopesCommands_1.processScope)(scopeName, scopeConfig, 0);
+        });
+        var results = await Promise.allSettled(scopePromises);
+        // Write per-scope manifest files and tally results
+        var successCount = 0;
+        var failCount = 0;
+        for (var r = 0; r < results.length; r++) {
+            var result = results[r];
+            var scopeName = scopesToDownload[r];
+            if (result.status === "fulfilled" && result.value.success) {
+                successCount++;
+                // Write per-scope manifest
+                if (result.value.manifest) {
+                    var scopeManifestPath = ConfigManager.getScopeManifestPath(scopeName);
+                    fs_1.default.writeFileSync(scopeManifestPath, JSON.stringify(result.value.manifest, null, 2), "utf8");
+                }
+            }
+            else {
+                failCount++;
+                var error = result.status === "rejected" ? result.reason : (result.value && result.value.error);
+                Logger_1.logger.error("Failed to initialize " + scopeName + ": " + (error && error.message ? error.message : "Unknown error"));
+            }
+        }
+        // Summary
+        Logger_1.logger.info("");
+        if (failCount === 0) {
+            Logger_1.logger.success(chalk_1.default.green("✓ ServiceNow configured — " + successCount + " scope(s) initialized"));
+        }
+        else {
+            Logger_1.logger.warn(successCount + "/" + scopesToDownload.length + " scopes initialized, " + failCount + " failed");
+        }
+    },
+};
+/**
+ * @description Validates ServiceNow credentials by testing the connection.
+ * Called by the orchestrator after all core login hooks are collected.
+ */
+async function validateCoreLogin(context) {
+    const instance = context.env.SN_INSTANCE;
+    const user = context.env.SN_USER;
+    const password = context.env.SN_PASSWORD;
+    if (!instance || !user || !password) {
+        return "Missing required credentials";
+    }
+    const instanceUrl = normalizeInstance(instance);
+    const baseUrl = instanceBaseUrl(instance);
+    try {
+        const client = (0, snClient_1.snClient)(baseUrl, user, password);
+        await (0, snClient_1.unwrapSNResponse)(client.getAppList());
+        context.env.SN_INSTANCE = instanceUrl;
+        return true;
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        const status = e && e.response && e.response.status;
+        if (msg.includes("Invalid URL") || msg.includes("ENOTFOUND") || msg.includes("getaddrinfo")) {
+            return "Instance not found — check the URL (got: " + instanceUrl + ")";
+        }
+        if (status === 401 || msg.includes("401")) {
+            return "Invalid username or password.";
+        }
+        if (status === 403 || msg.includes("403")) {
+            return "Access denied — user may lack required roles.";
+        }
+        if (msg.includes("ECONNREFUSED") || msg.includes("ETIMEDOUT") || msg.includes("ECONNRESET")) {
+            return "Could not reach " + instanceUrl + " — check network connectivity.";
+        }
+        return "Connection failed: " + msg;
+    }
+}
+function normalizeInstance(instance) {
+    let url = instance.trim().replace("https://", "").replace("http://", "");
+    if (url.endsWith("/")) {
+        url = url.slice(0, -1);
+    }
+    return url;
+}
+function instanceBaseUrl(instance) {
+    return "https://" + normalizeInstance(instance) + "/";
+}

package/dist/initSystem/discovery.js

@@ -0,0 +1,107 @@
+"use strict";
+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 });
+exports.discoverPlugins = discoverPlugins;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const Logger_1 = require("../Logger");
+// Skip packages that are not init plugins:
+// - core/types: the discovery system itself
+// - dashboard: starts Express server on require (side effect)
+// - schema: library imported directly by schemaCommand, not a plugin
+// Both new (dovetail-*) and legacy (sincronia-*) names are listed so the deprecation
+// shim packages on npm are also skipped during the rebrand transition window.
+const SKIP_PACKAGES = new Set([
+    "dovetail-core",
+    "dovetail-types",
+    "dovetail-dashboard",
+    "dovetail-schema",
+    "sincronia-core",
+    "sincronia-types",
+    "sincronia-dashboard",
+    "sincronia-schema",
+]);
+const PLUGIN_PACKAGE_PREFIXES = ["dovetail-", "sincronia-"];
+const MAX_PARENT_DEPTH = 3;
+/**
+ * @description Scans node_modules for @tenonhq/dovetail-* (and legacy @tenonhq/sincronia-*) packages that export a sincPlugin.
+ * @returns {Sinc.InitPlugin[]} Array of discovered init plugins.
+ */
+function discoverPlugins() {
+    const plugins = [];
+    const seen = new Set();
+    const searchPaths = [
+        path.resolve(process.cwd(), "node_modules", "@tenonhq"),
+        path.resolve(__dirname, "..", "..", "..", "@tenonhq"),
+    ];
+    // Check parent directories for monorepo hoisted node_modules (capped depth)
+    let current = process.cwd();
+    for (let depth = 0; depth < MAX_PARENT_DEPTH; depth++) {
+        const parent = path.dirname(current);
+        if (parent === current)
+            break;
+        const hoisted = path.join(parent, "node_modules", "@tenonhq");
+        if (!searchPaths.includes(hoisted)) {
+            searchPaths.push(hoisted);
+        }
+        current = parent;
+    }
+    for (const searchPath of searchPaths) {
+        let dirs;
+        try {
+            dirs = fs.readdirSync(searchPath);
+        }
+        catch (e) {
+            continue;
+        }
+        dirs
+            .filter(name => PLUGIN_PACKAGE_PREFIXES.some(p => name.startsWith(p)) && !SKIP_PACKAGES.has(name) && !seen.has(name))
+            .forEach(dirName => {
+            seen.add(dirName);
+            try {
+                const pkg = require("@tenonhq/" + dirName);
+                if (pkg && pkg.sincPlugin && pkg.sincPlugin.name && pkg.sincPlugin.displayName) {
+                    plugins.push(pkg.sincPlugin);
+                    Logger_1.logger.debug("Discovered init plugin: " + pkg.sincPlugin.displayName + " (" + dirName + ")");
+                }
+            }
+            catch (e) {
+                const message = e instanceof Error ? e.message : String(e);
+                Logger_1.logger.warn("Failed to load plugin " + dirName + ": " + message);
+            }
+        });
+    }
+    return plugins;
+}