@alcedocore/cli 0.0.1-rc.0

package/dist/commands/compile-pages.js

@@ -0,0 +1,120 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compilePagesCommand = void 0;
+const esbuild_1 = __importDefault(require("esbuild"));
+// @ts-ignore - unplugin-vue exports ./esbuild but types are not fully resolved
+const esbuild_2 = __importDefault(require("unplugin-vue/esbuild"));
+const esbuild_plugin_postcss_1 = __importDefault(require("@chialab/esbuild-plugin-postcss"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const path_1 = __importDefault(require("path"));
+const node_url_1 = require("node:url");
+const node_process_1 = require("node:process");
+const commander_1 = require("commander");
+exports.compilePagesCommand = new commander_1.Command("compile-pages")
+    .description("Compile all pages into a dist directory")
+    .action(async (opts, cmd) => {
+    renderPages().catch((err) => {
+        console.error(`[page-compiler] Failed:`, err);
+        process.exit(1);
+    });
+});
+const compilerDir = path_1.default.dirname((0, node_url_1.fileURLToPath)((0, node_process_1.cwd)()));
+const compilerRootDir = path_1.default.join(compilerDir, "..");
+const compilerNodeModules = path_1.default.join(compilerRootDir, "node_modules");
+function parseArgs() {
+    let plugin = "./pages";
+    let output = "./pages/dist";
+    for (let i = 0; i < process.argv.length; i++) {
+        const arg = process.argv[i];
+        if (arg === "--plugin" && i + 1 < process.argv.length) {
+            plugin = process.argv[i + 1];
+        }
+        else if (arg.startsWith("--plugin=")) {
+            plugin = arg.split("=")[1];
+        }
+        if (arg === "--output" && i + 1 < process.argv.length) {
+            output = process.argv[i + 1];
+        }
+        else if (arg.startsWith("--output=")) {
+            output = arg.split("=")[1];
+        }
+    }
+    return { plugin, output };
+}
+let currentImportsGlobalVue = new Set();
+let importingModules = "createTextVNode,defineComponent,toDisplayString,createElementVNode,openBlock,createElementBlock,Fragment,renderSlot,createCommentVNode,useModel,vModelText,vModelSelect,withDirectives,withKeys,normalizeClass,renderList,computed,ref,onMounted,normalizeStyle,createComment,resolveComponent,resolveDirective,withCtx,toHandlers,mergeProps,createSlots,withScopeId,createStaticVNode,createBlock,popScopeId,pushScopeId,isRef,unref,isReactive,toRef,toRefs,isProxy,isReadonly,shallowRef,triggerRef,customRef,markRaw,toRaw,reactive,readonly,watch,watchEffect,watchPostEffect,watchSyncEffect,provide,inject,getCurrentInstance,h,nextTick,onBeforeMount,onBeforeUpdate,onBeforeUnmount,onUpdated,onUnmounted,onActivated,onDeactivated,onErrorCaptured,onRenderTracked,onRenderTriggered,isVNode,cloneVNode,createVNode,Transition,TransitionGroup,Teleport,Suspense,KeepAlive,defineAsyncComponent,defineEmits,defineExpose,defineProps,withDefaults,useAttrs,useSlots,useCssModule,useCssVars,EffectScope,effectScope,getCurrentScope,onScopeDispose,useId,resolveDynamicComponent,normalizeProps,withModifiers,vShow";
+currentImportsGlobalVue = new Set(importingModules.split(","));
+const vueGlobalPlugin = {
+    name: "vue-global",
+    setup(build) {
+        build.onResolve({ filter: /^vue$/ }, async (args) => {
+            let source = await node_fs_1.default.promises.readFile(args.importer, "utf8");
+            const matchingImports = source.match(/import\s*{\s*([^}]*)\s*}\s*from\s*["']vue["']/) ||
+                [];
+            // console.log(matchingImports);
+            if (matchingImports[1]) {
+                importingModules = matchingImports[1] + "," + importingModules;
+                for (const imp of importingModules.split(",")) {
+                    currentImportsGlobalVue.add(imp.trim());
+                }
+            }
+            return {
+                path: args.path,
+                namespace: "vue-global",
+            };
+        });
+        build.onLoad({ filter: /.*/, namespace: "vue-global" }, () => {
+            return {
+                contents: `
+            export const { ${[...currentImportsGlobalVue].join(",")} } = window.vue;
+            export default window.vue;
+            `,
+                loader: "js",
+            };
+        });
+    },
+};
+async function renderPages() {
+    const args = parseArgs();
+    const pluginPath = path_1.default.resolve(process.cwd(), args.plugin);
+    const outputDir = path_1.default.resolve(process.cwd(), args.output);
+    const mainPath = path_1.default.join(pluginPath, "main.ts");
+    console.log(`[page-compiler] Compiling pages from: ${pluginPath}`);
+    console.log(`[page-compiler] Output directory: ${outputDir}`);
+    if (!node_fs_1.default.existsSync(mainPath)) {
+        console.error(`[page-compiler] Entry point not found: ${mainPath}`);
+        process.exit(1);
+    }
+    await node_fs_1.default.promises.mkdir(outputDir, { recursive: true });
+    const buildOptions = {
+        entryPoints: [mainPath],
+        bundle: true,
+        format: "esm",
+        target: "es2020",
+        platform: "browser",
+        sourcemap: false,
+        minify: false,
+        outdir: outputDir,
+        plugins: [(0, esbuild_plugin_postcss_1.default)(), vueGlobalPlugin, (0, esbuild_2.default)({ sourceMap: false })],
+        alias: {
+            vue: path_1.default.join(compilerNodeModules, "vue", "dist", "vue.esm-bundler.js"),
+        },
+        loader: {
+            ".css": "css",
+        },
+        write: true,
+        external: ["vue"],
+    };
+    await esbuild_1.default.build(buildOptions);
+    const mainJsPath = path_1.default.join(outputDir, "main.js");
+    const pluginPagesJsPath = path_1.default.join(outputDir, "plugin-pages.js");
+    if (node_fs_1.default.existsSync(mainJsPath)) {
+        await node_fs_1.default.promises.rename(mainJsPath, pluginPagesJsPath);
+        console.log(`[page-compiler] Renamed main.js -> plugin-pages.js`);
+    }
+    console.log(`[page-compiler] Build complete`);
+}
+//# sourceMappingURL=compile-pages.js.map

package/dist/commands/connect.js

@@ -0,0 +1,122 @@
+"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.connectCommand = void 0;
+const commander_1 = require("commander");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const config_1 = require("../config");
+const logger_1 = require("../utils/logger");
+exports.connectCommand = new commander_1.Command("connect")
+    .description("Connect to a core instance and save credentials")
+    .option("-u, --url <url>", "Core URL")
+    .option("-k, --api-key <key>", "API key")
+    .action(async (opts, cmd) => {
+    const config = (0, config_1.loadConfig)(cmd.optsWithGlobals());
+    let coreUrl = opts.url || config.coreUrl || "http://localhost:8080";
+    let apiKey = opts.apiKey || "";
+    // If no flags, prompt interactively
+    if (!opts.url || !opts.apiKey) {
+        const inquirer = (await Promise.resolve().then(() => __importStar(require("inquirer")))).default;
+        const prompts = [];
+        if (!opts.url) {
+            prompts.push({
+                type: "input",
+                name: "coreUrl",
+                message: "Core URL:",
+                default: coreUrl,
+            });
+        }
+        if (!opts.apiKey) {
+            prompts.push({
+                type: "password",
+                name: "apiKey",
+                message: "API Key:",
+                mask: "*",
+            });
+        }
+        const answers = await inquirer.prompt(prompts);
+        if (answers.coreUrl)
+            coreUrl = answers.coreUrl;
+        if (answers.apiKey)
+            apiKey = answers.apiKey;
+    }
+    if (!coreUrl) {
+        (0, logger_1.error)("Core URL is required");
+        process.exit(1);
+    }
+    if (!apiKey) {
+        (0, logger_1.error)("API key is required");
+        process.exit(1);
+    }
+    // Validate by registering a test request ID
+    const validateSpinner = (0, logger_1.createSpinner)("Validating connection...");
+    try {
+        const res = await fetch(`${coreUrl.replace(/\/$/, "")}/api/dev/request-id`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${apiKey}`,
+            },
+            body: JSON.stringify({ slug: "alcedo-connect" }),
+        });
+        if (!res.ok) {
+            let errMsg = `HTTP ${res.status}`;
+            try {
+                const errBody = (await res.json());
+                if (errBody.error)
+                    errMsg = errBody.error;
+            }
+            catch { }
+            throw new Error(errMsg);
+        }
+        validateSpinner.succeed();
+    }
+    catch (err) {
+        validateSpinner.fail();
+        (0, logger_1.error)(`Failed to connect: ${err.message}`);
+        process.exit(1);
+    }
+    // Write to .alcedocore.dev.env
+    const envPath = node_path_1.default.join(process.cwd(), ".alcedocore.dev.env");
+    node_fs_1.default.writeFileSync(envPath, `CORE_URL=${coreUrl}\nAPI_KEY=${apiKey}\n`);
+    (0, logger_1.success)(`Credentials saved to ${envPath}`);
+    (0, logger_1.info)(`  CORE_URL=${coreUrl}`);
+    (0, logger_1.info)("  API_KEY=********");
+});
+//# sourceMappingURL=connect.js.map

package/dist/commands/deploy.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployCommand = void 0;
+const commander_1 = require("commander");
+const logger_1 = require("../utils/logger");
+const config_1 = require("../config");
+function parseEnvVars(env = []) {
+    const result = {};
+    for (const e of env) {
+        const eqIdx = e.indexOf("=");
+        if (eqIdx === -1) {
+            result[e] = "";
+        }
+        else {
+            result[e.slice(0, eqIdx)] = e.slice(eqIdx + 1);
+        }
+    }
+    return result;
+}
+exports.deployCommand = new commander_1.Command("deploy")
+    .argument("<slug>", "Plugin slug (e.g., my-plugin)")
+    .option("-t, --tag <version>", "Plugin version tag", "1.0.0")
+    .option("-i, --image <image>", "Docker image (default: {registry}/{slug}:{tag})")
+    .option("--no-start", "Register only, don't start the container")
+    .option("-e, --env <key=value>", "Environment variables (repeatable)", collectEnv, [])
+    .description("Deploy a plugin to Alcedo Core")
+    .action(async (slug, options, cmd) => {
+    const config = (0, config_1.loadConfig)(cmd.optsWithGlobals());
+    const registryUrl = (config.registryUrl || "localhost:5000").replace(/^https?:\/\//, "");
+    const coreUrl = config.coreUrl;
+    const tag = options.tag || "1.0.0";
+    const image = options.image || `${registryUrl}/${slug}:${tag}`;
+    const spinner = (0, logger_1.createSpinner)(`Deploying plugin: ${slug} v${tag}`);
+    try {
+        const body = JSON.stringify({
+            slug,
+            version: tag,
+            image,
+            env: parseEnvVars(options.env),
+            start_container: options.start !== false,
+        });
+        const res = await fetch(`${coreUrl}/api/plugins/deploy`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body,
+        });
+        if (!res.ok) {
+            const errBody = await res.text().catch(() => "Unknown error");
+            throw new Error(`Deploy failed (${res.status}): ${errBody}`);
+        }
+        const contentType = res.headers.get("content-type") || "";
+        if (!contentType.includes("json")) {
+            const text = await res.text();
+            throw new Error(`Expected JSON but got ${contentType}: ${text.slice(0, 200)}`);
+        }
+        const result = await res.json();
+        const data = result.data || result;
+        spinner.succeed();
+        (0, logger_1.success)(`Plugin "${slug}" v${tag} deployed`);
+        if (data.container_id) {
+            (0, logger_1.info)(`Container: ${data.container_id}`);
+        }
+    }
+    catch (err) {
+        spinner.fail();
+        (0, logger_1.error)(`Failed to deploy: ${err.message}`);
+        process.exit(1);
+    }
+});
+function collectEnv(val, prev) {
+    prev.push(val);
+    return prev;
+}
+//# sourceMappingURL=deploy.js.map

package/dist/commands/dev.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.devCommand = void 0;
+const commander_1 = require("commander");
+const proxy_1 = require("./proxy");
+const build_frontend_1 = require("./build-frontend");
+const serve_frontend_1 = require("./serve-frontend");
+exports.devCommand = new commander_1.Command("dev")
+    .description("Plugin development commands (use 'alcedo dev proxy' to start the dev proxy)")
+    .addCommand(proxy_1.proxyCommand)
+    .addCommand(build_frontend_1.buildFrontendCommand)
+    .addCommand(serve_frontend_1.serveFrontendCommand);
+//# sourceMappingURL=dev.js.map