@alcedocore/cli 0.0.1-rc.0

package/src/commands/build-frontend.ts

@@ -0,0 +1,148 @@
+import esbuild from "esbuild";
+// @ts-ignore - unplugin-vue exports ./esbuild but types are not fully resolved
+import Vue from "unplugin-vue/esbuild";
+import postcssPlugin from "@chialab/esbuild-plugin-postcss";
+import fs from "node:fs";
+import path from "path";
+import { Command } from "commander";
+
+export const buildFrontendCommand = new Command("build-frontend")
+    .description("Compile the frontend code into a dist directory")
+    .action(async (opts: null, cmd: Command) => {
+        buildProdFiles().catch((err) => {
+            console.error(`[page-compiler] Failed:`, err);
+            process.exit(1);
+        });
+    });
+
+const compilerDir = path.dirname(process.cwd());
+const compilerRootDir = path.join(compilerDir, "..");
+const compilerNodeModules = path.join(compilerRootDir, "node_modules");
+
+interface CliArgs {
+    plugin: string;
+    output: string;
+}
+
+function parseArgs(): CliArgs {
+    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 };
+}
+
+export let currentImportsGlobalVue = new Set<string>();
+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: any) {
+        build.onResolve({ filter: /^vue$/ }, async (args: any) => {
+            let source = await fs.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 buildProdFiles(): Promise<void> {
+    const args = parseArgs();
+    const outputDir = path.resolve(process.cwd(), args.output);
+    const pluginPath = path.resolve(process.cwd(), args.plugin);
+    const mainPath = path.join(pluginPath, "main.ts");
+
+    await buildFrontendFiles(outputDir);
+
+    console.log(`[page-compiler] Compiling pages from: ${pluginPath}`);
+    console.log(`[page-compiler] Output directory: ${outputDir}`);
+
+    if (!fs.existsSync(mainPath)) {
+        console.error(`[page-compiler] Entry point not found: ${mainPath}`);
+        process.exit(1);
+    }
+
+    await fs.promises.mkdir(outputDir, { recursive: true });
+
+    const mainJsPath = path.join(outputDir, "main.js");
+    const pluginPagesJsPath = path.join(outputDir, "plugin-pages.js");
+
+    if (fs.existsSync(mainJsPath)) {
+        await fs.promises.rename(mainJsPath, pluginPagesJsPath);
+        console.log(`[page-compiler] Renamed main.js -> plugin-pages.js`);
+    }
+
+    console.log(`[page-compiler] Build complete`);
+}
+
+export async function buildFrontendFiles(outputDir: string | boolean) {
+    const args = parseArgs();
+    const pluginPath = path.resolve(process.cwd(), args.plugin);
+    const mainPath = path.join(pluginPath, "main.ts");
+
+    const buildOptions: esbuild.BuildOptions = {
+        entryPoints: [mainPath],
+        bundle: true,
+        format: "esm",
+        target: "es2020",
+        platform: "browser",
+        sourcemap: outputDir == false ? undefined : false,
+        minify: outputDir == false ? false : true,
+        write: outputDir == false ? false : undefined,
+        outfile: outputDir == false ? ".temp/bundle.js" : undefined,
+        outdir: typeof outputDir == "string" ? outputDir : undefined,
+        plugins: [postcssPlugin(), vueGlobalPlugin, Vue({ sourceMap: false })],
+        alias: {
+            vue: path.join(
+                compilerNodeModules,
+                "vue",
+                "dist",
+                "vue.esm-bundler.js",
+            ),
+        },
+        loader: {
+            ".css": "css",
+        },
+        external: ["vue"],
+    };
+
+    return await esbuild.build(buildOptions);
+}

package/src/commands/connect.ts

@@ -0,0 +1,98 @@
+import { Command } from "commander";
+import fs from "node:fs";
+import path from "node:path";
+import { loadConfig } from "../config";
+import {
+    success,
+    error as logError,
+    info,
+    createSpinner,
+} from "../utils/logger";
+
+interface ConnectOptions {
+    url?: string;
+    apiKey?: string;
+}
+
+export const connectCommand = new 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: ConnectOptions, cmd: Command) => {
+        const config = loadConfig(cmd.optsWithGlobals() as any);
+
+        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 import("inquirer")).default;
+            const prompts: any[] = [];
+
+            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) {
+            logError("Core URL is required");
+            process.exit(1);
+        }
+        if (!apiKey) {
+            logError("API key is required");
+            process.exit(1);
+        }
+
+        // Validate by registering a test request ID
+        const validateSpinner = 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()) as { error?: string };
+                    if (errBody.error) errMsg = errBody.error;
+                } catch {}
+                throw new Error(errMsg);
+            }
+            validateSpinner.succeed();
+        } catch (err: any) {
+            validateSpinner.fail();
+            logError(`Failed to connect: ${err.message}`);
+            process.exit(1);
+        }
+
+        // Write to .alcedocore.dev.env
+        const envPath = path.join(process.cwd(), ".alcedocore.dev.env");
+        fs.writeFileSync(envPath, `CORE_URL=${coreUrl}\nAPI_KEY=${apiKey}\n`);
+        success(`Credentials saved to ${envPath}`);
+        info(`  CORE_URL=${coreUrl}`);
+        info("  API_KEY=********");
+    });

package/src/commands/deploy.ts

@@ -0,0 +1,85 @@
+import { Command } from "commander";
+import { createSpinner, success, error as logError, info } from "../utils/logger";
+import { loadConfig } from "../config";
+
+interface DeployOptions {
+  tag?: string;
+  image?: string;
+  start?: boolean;
+  env?: string[];
+}
+
+function parseEnvVars(env: string[] = []): Record<string, string> {
+  const result: Record<string, string> = {};
+  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;
+}
+
+export const deployCommand = new 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: string, options: DeployOptions, cmd: Command) => {
+    const config = loadConfig(cmd.optsWithGlobals() as any);
+    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 = 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: any = await res.json();
+      const data = result.data || result;
+
+      spinner.succeed();
+      success(`Plugin "${slug}" v${tag} deployed`);
+      if (data.container_id) {
+        info(`Container: ${data.container_id}`);
+      }
+    } catch (err: any) {
+      spinner.fail();
+      logError(`Failed to deploy: ${err.message}`);
+      process.exit(1);
+    }
+  });
+
+function collectEnv(val: string, prev: string[]): string[] {
+  prev.push(val);
+  return prev;
+}

package/src/commands/dev.ts

@@ -0,0 +1,12 @@
+import { Command } from "commander";
+import { proxyCommand } from "./proxy";
+import { buildFrontendCommand } from "./build-frontend";
+import { serveFrontendCommand } from "./serve-frontend";
+
+export const devCommand = new Command("dev")
+    .description(
+        "Plugin development commands (use 'alcedo dev proxy' to start the dev proxy)",
+    )
+    .addCommand(proxyCommand)
+    .addCommand(buildFrontendCommand)
+    .addCommand(serveFrontendCommand);