@waelio/cli 0.1.1

package/dist/server.js

@@ -0,0 +1,366 @@
+import { createServer } from "node:http";
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { DEFAULT_SITEFORGE_REPO, formatBuildPlan, getDoctorReport, prepareBuildPlan, runBuild, } from "./siteforge.js";
+import { DEFAULT_LOCAL_REPOS_ROOT, listLocalRepositoryDirectory, scanLocalRepositories, } from "./localRepos.js";
+const helperRepositories = [
+    {
+        name: "waelio/ustore",
+        url: "https://github.com/waelio/ustore",
+        description: "Universal storage adapters with a clean CRUD-style API.",
+        suggestedUse: "Great for caching UI state, history, and future build session persistence.",
+    },
+    {
+        name: "waelio/utils",
+        url: "https://github.com/waelio/utils",
+        description: "Shared utilities for config, storage, and UI-friendly helpers.",
+        suggestedUse: "A good future home for reusable notifications, config helpers, or shared browser utilities.",
+    },
+    {
+        name: "waelio/waelio-messaging",
+        url: "https://github.com/waelio/waelio-messaging",
+        description: "Realtime messaging and event distribution with FeathersJS and Socket.io.",
+        suggestedUse: "Useful later if you want shared build dashboards, collaboration, or remote build notifications.",
+    },
+];
+const recommendedStack = {
+    name: "Vite + TypeScript + Vue",
+    reasons: [
+        "Vite keeps the UI extremely fast during local development.",
+        "TypeScript matches the existing CLI and build code.",
+        "Vue fits well with the broader waelio ecosystem and is quick to iterate on.",
+    ],
+};
+const projectRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const uiDistDir = path.join(projectRoot, "ui", "dist");
+let buildInProgress = false;
+export async function startServer(options = {}) {
+    const port = options.port ?? Number(process.env.PORT ?? 3000);
+    const server = createServer((request, response) => {
+        void handleRequest(request, response);
+    });
+    await new Promise((resolve, reject) => {
+        const onError = (error) => {
+            server.off("listening", onListening);
+            reject(error);
+        };
+        const onListening = () => {
+            server.off("error", onError);
+            resolve();
+        };
+        server.once("error", onError);
+        server.once("listening", onListening);
+        server.listen(port);
+    });
+    console.log(`waelio UI server ready on http://localhost:${port}`);
+    return server;
+}
+async function handleRequest(request, response) {
+    const requestUrl = new URL(request.url ?? "/", "http://localhost");
+    try {
+        if (request.method === "OPTIONS") {
+            sendNoContent(response);
+            return;
+        }
+        if (requestUrl.pathname.startsWith("/api/")) {
+            await handleApiRequest(request, response, requestUrl);
+            return;
+        }
+        await handleUiRequest(response, requestUrl.pathname);
+    }
+    catch (error) {
+        sendJson(response, 500, {
+            error: toErrorMessage(error),
+        });
+    }
+}
+async function handleApiRequest(request, response, requestUrl) {
+    if (request.method === "GET" && requestUrl.pathname === "/api/health") {
+        sendJson(response, 200, {
+            defaultRepoUrl: DEFAULT_SITEFORGE_REPO,
+            localReposRoot: DEFAULT_LOCAL_REPOS_ROOT,
+            recommendedStack,
+            helperRepositories,
+        });
+        return;
+    }
+    if (request.method === "GET" && requestUrl.pathname === "/api/local-repos") {
+        const snapshot = await scanLocalRepositories();
+        sendJson(response, 200, {
+            root: snapshot.root,
+            count: snapshot.repositories.length,
+            repositories: snapshot.repositories,
+        });
+        return;
+    }
+    if (request.method === "GET" && requestUrl.pathname === "/api/local-repos/tree") {
+        const repositoryId = requestUrl.searchParams.get("repoId")?.trim();
+        if (!repositoryId) {
+            sendJson(response, 400, {
+                error: "Missing repoId query parameter.",
+            });
+            return;
+        }
+        const snapshot = await scanLocalRepositories();
+        try {
+            const listing = await listLocalRepositoryDirectory(snapshot, repositoryId, requestUrl.searchParams.get("path") ?? undefined);
+            sendJson(response, 200, listing);
+        }
+        catch (error) {
+            const message = toErrorMessage(error);
+            sendJson(response, message.includes("Unknown local repository id") ? 404 : 400, {
+                error: message,
+            });
+        }
+        return;
+    }
+    if (request.method === "GET" && requestUrl.pathname === "/api/doctor") {
+        const checks = await getDoctorReport();
+        sendJson(response, 200, { checks });
+        return;
+    }
+    if (request.method === "POST" && requestUrl.pathname === "/api/plan") {
+        const payload = await readJsonBody(request);
+        const options = normalizeBuildOptions(payload);
+        const plan = await prepareBuildPlan(options);
+        sendJson(response, 200, {
+            plan,
+            formatted: formatBuildPlan(plan),
+        });
+        return;
+    }
+    if (request.method === "GET" && requestUrl.pathname === "/api/build/stream") {
+        await handleBuildStream(response, buildOptionsFromSearchParams(requestUrl.searchParams));
+        return;
+    }
+    sendJson(response, 404, {
+        error: `Unknown API route: ${requestUrl.pathname}`,
+    });
+}
+async function handleBuildStream(response, options) {
+    if (buildInProgress) {
+        sendJson(response, 409, {
+            error: "A build is already running. Please wait for it to finish.",
+        });
+        return;
+    }
+    buildInProgress = true;
+    response.writeHead(200, {
+        "Access-Control-Allow-Origin": "*",
+        "Cache-Control": "no-cache, no-transform",
+        Connection: "keep-alive",
+        "Content-Type": "text/event-stream; charset=utf-8",
+    });
+    let clientClosed = false;
+    response.on("close", () => {
+        clientClosed = true;
+    });
+    sendSseEvent(response, "ready", {
+        message: "Build stream connected.",
+    });
+    try {
+        const plan = await runBuild(options, {
+            onPlan: (nextPlan) => {
+                sendSseEvent(response, "plan", { plan: nextPlan }, clientClosed);
+            },
+            onInfo: (message) => {
+                sendSseEvent(response, "info", { message }, clientClosed);
+            },
+            onStepStart: (step, context) => {
+                sendSseEvent(response, "step", {
+                    step,
+                    index: context.index,
+                    total: context.total,
+                }, clientClosed);
+            },
+            onStdout: (chunk) => {
+                sendSseEvent(response, "stdout", { chunk }, clientClosed);
+            },
+            onStderr: (chunk) => {
+                sendSseEvent(response, "stderr", { chunk }, clientClosed);
+            },
+        });
+        sendSseEvent(response, "complete", { plan }, clientClosed);
+    }
+    catch (error) {
+        sendSseEvent(response, "failure", {
+            message: toErrorMessage(error),
+        }, clientClosed);
+    }
+    finally {
+        buildInProgress = false;
+        if (!clientClosed && !response.writableEnded) {
+            response.end();
+        }
+    }
+}
+async function handleUiRequest(response, pathname) {
+    const uiExists = await pathExists(uiDistDir);
+    if (!uiExists) {
+        sendHtml(response, 503, `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>waelio UI not built yet</title>
+    <style>
+      body { font-family: Inter, ui-sans-serif, system-ui, sans-serif; background: #08111f; color: #e2e8f0; display: grid; place-items: center; min-height: 100vh; margin: 0; }
+      main { max-width: 720px; padding: 32px; border-radius: 24px; background: rgba(15, 23, 42, 0.92); box-shadow: 0 24px 80px rgba(0, 0, 0, 0.35); }
+      code { background: rgba(148, 163, 184, 0.15); padding: 2px 8px; border-radius: 8px; }
+      a { color: #8b5cf6; }
+    </style>
+  </head>
+  <body>
+    <main>
+      <h1>UI build not found</h1>
+      <p>Run <code>npm run dev</code> for development or <code>npm run build</code> followed by <code>npm start</code> for the compiled UI.</p>
+      <p>The API is still available at <code>/api/*</code>.</p>
+    </main>
+  </body>
+</html>`);
+        return;
+    }
+    const assetPath = await resolveUiAssetPath(pathname);
+    if (!assetPath) {
+        sendJson(response, 404, {
+            error: `UI asset not found: ${pathname}`,
+        });
+        return;
+    }
+    const fileContents = await readFile(assetPath);
+    response.writeHead(200, {
+        "Content-Type": getContentType(assetPath),
+    });
+    response.end(fileContents);
+}
+async function resolveUiAssetPath(pathname) {
+    const normalizedPath = pathname === "/" ? "index.html" : pathname.replace(/^\/+/, "");
+    const candidate = path.normalize(path.join(uiDistDir, normalizedPath));
+    if (!candidate.startsWith(uiDistDir)) {
+        return null;
+    }
+    if (await pathExists(candidate)) {
+        const details = await stat(candidate);
+        if (details.isFile()) {
+            return candidate;
+        }
+    }
+    if (path.extname(normalizedPath) !== "") {
+        return null;
+    }
+    const indexFile = path.join(uiDistDir, "index.html");
+    return (await pathExists(indexFile)) ? indexFile : null;
+}
+function buildOptionsFromSearchParams(searchParams) {
+    const dryRunValue = normalizeString(searchParams.get("dryRun"));
+    return {
+        repoUrl: normalizeString(searchParams.get("repo") ?? searchParams.get("repoUrl")),
+        ref: normalizeString(searchParams.get("ref")),
+        source: normalizeString(searchParams.get("source")),
+        workdir: normalizeString(searchParams.get("workdir")),
+        dryRun: dryRunValue === "true",
+    };
+}
+function normalizeBuildOptions(value) {
+    if (!isRecord(value)) {
+        return {};
+    }
+    return {
+        repoUrl: normalizeString(value.repoUrl ?? value.repo),
+        ref: normalizeString(value.ref),
+        source: normalizeString(value.source),
+        workdir: normalizeString(value.workdir),
+        dryRun: value.dryRun === true,
+    };
+}
+async function readJsonBody(request) {
+    const chunks = [];
+    for await (const chunk of request) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    if (chunks.length === 0) {
+        return {};
+    }
+    return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+}
+function sendSseEvent(response, event, data, clientClosed = false) {
+    if (clientClosed || response.writableEnded || response.destroyed) {
+        return;
+    }
+    response.write(`event: ${event}\n`);
+    response.write(`data: ${JSON.stringify(data)}\n\n`);
+}
+function sendJson(response, statusCode, payload) {
+    response.writeHead(statusCode, {
+        "Access-Control-Allow-Origin": "*",
+        "Content-Type": "application/json; charset=utf-8",
+    });
+    response.end(JSON.stringify(payload));
+}
+function sendHtml(response, statusCode, html) {
+    response.writeHead(statusCode, {
+        "Content-Type": "text/html; charset=utf-8",
+    });
+    response.end(html);
+}
+function sendNoContent(response) {
+    response.writeHead(204, {
+        "Access-Control-Allow-Headers": "Content-Type",
+        "Access-Control-Allow-Methods": "GET,POST,OPTIONS",
+        "Access-Control-Allow-Origin": "*",
+    });
+    response.end();
+}
+function getContentType(filePath) {
+    switch (path.extname(filePath)) {
+        case ".css":
+            return "text/css; charset=utf-8";
+        case ".html":
+            return "text/html; charset=utf-8";
+        case ".js":
+            return "text/javascript; charset=utf-8";
+        case ".json":
+            return "application/json; charset=utf-8";
+        case ".svg":
+            return "image/svg+xml";
+        case ".png":
+            return "image/png";
+        case ".ico":
+            return "image/x-icon";
+        default:
+            return "text/plain; charset=utf-8";
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function normalizeString(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+async function pathExists(targetPath) {
+    try {
+        await stat(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function toErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function isDirectRun() {
+    const entryPoint = process.argv[1];
+    return Boolean(entryPoint) && path.resolve(entryPoint) === fileURLToPath(import.meta.url);
+}
+if (isDirectRun()) {
+    startServer().catch((error) => {
+        console.error(`\nError: ${toErrorMessage(error)}`);
+        process.exitCode = 1;
+    });
+}

package/dist/siteforge.d.ts

@@ -0,0 +1,44 @@
+export declare const DEFAULT_SITEFORGE_REPO = "https://github.com/waelio/siteforge.git";
+export interface BuildSiteforgeOptions {
+    repoUrl?: string;
+    ref?: string;
+    source?: string;
+    workdir?: string;
+    dryRun?: boolean;
+}
+export interface BuildStep {
+    title: string;
+    command: string;
+    args: string[];
+    cwd?: string;
+}
+export interface BuildPlan {
+    projectDir: string;
+    usesExistingSource: boolean;
+    requiredTools: string[];
+    steps: BuildStep[];
+}
+export interface ToolCheckResult {
+    tool: string;
+    ok: boolean;
+    details: string;
+}
+export interface BuildExecutionHooks {
+    onPlan?: (plan: BuildPlan) => void;
+    onInfo?: (message: string) => void;
+    onStepStart?: (step: BuildStep, context: {
+        index: number;
+        total: number;
+    }) => void;
+    onStdout?: (chunk: string, step: BuildStep) => void;
+    onStderr?: (chunk: string, step: BuildStep) => void;
+}
+export declare function createBuildPlan(options: Omit<BuildSiteforgeOptions, "workdir" | "dryRun"> & {
+    projectDir: string;
+}): BuildPlan;
+export declare function getDoctorReport(): Promise<ToolCheckResult[]>;
+export declare function formatDoctorReport(checks: ToolCheckResult[]): string;
+export declare function runDoctor(): Promise<ToolCheckResult[]>;
+export declare function prepareBuildPlan(options: BuildSiteforgeOptions): Promise<BuildPlan>;
+export declare function runBuild(options: BuildSiteforgeOptions, hooks?: BuildExecutionHooks): Promise<BuildPlan>;
+export declare function formatBuildPlan(plan: BuildPlan): string;

package/dist/siteforge.js

@@ -0,0 +1,281 @@
+import { spawn } from "node:child_process";
+import { mkdtemp, readdir, stat } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+export const DEFAULT_SITEFORGE_REPO = "https://github.com/waelio/siteforge.git";
+const TOOL_VERSION_ARGS = {
+    git: ["--version"],
+    npm: ["--version"],
+    go: ["version"],
+};
+export function createBuildPlan(options) {
+    const repoUrl = options.repoUrl ?? DEFAULT_SITEFORGE_REPO;
+    const usesExistingSource = Boolean(options.source);
+    const requiredTools = new Set(["npm", "go"]);
+    const steps = [];
+    if (!usesExistingSource) {
+        requiredTools.add("git");
+        steps.push({
+            title: "Clone siteforge",
+            command: "git",
+            args: ["clone", repoUrl, options.projectDir],
+        });
+    }
+    if (options.ref) {
+        requiredTools.add("git");
+        steps.push({
+            title: `Checkout ${options.ref}`,
+            command: "git",
+            args: ["checkout", options.ref],
+            cwd: options.projectDir,
+        });
+    }
+    steps.push({
+        title: "Install dependencies",
+        command: "npm",
+        args: ["ci"],
+        cwd: options.projectDir,
+    }, {
+        title: "Build website",
+        command: "npm",
+        args: ["run", "build"],
+        cwd: options.projectDir,
+    });
+    return {
+        projectDir: options.projectDir,
+        usesExistingSource,
+        requiredTools: [...requiredTools],
+        steps,
+    };
+}
+export async function getDoctorReport() {
+    return Promise.all(["git", "npm", "go"].map((tool) => checkTool(tool)));
+}
+export function formatDoctorReport(checks) {
+    return checks
+        .map((check) => `${check.ok ? "✔" : "✘"} ${check.tool}: ${check.details}`)
+        .join("\n");
+}
+export async function runDoctor() {
+    const checks = await getDoctorReport();
+    let hasFailure = false;
+    for (const check of checks) {
+        if (check.ok) {
+            console.log(`✔ ${check.tool}: ${check.details}`);
+            continue;
+        }
+        hasFailure = true;
+        console.error(`✘ ${check.tool}: ${check.details}`);
+    }
+    if (hasFailure) {
+        throw new Error("One or more required tools are missing.");
+    }
+    return checks;
+}
+export async function prepareBuildPlan(options) {
+    const location = await resolveProjectDir(options);
+    return createBuildPlan({
+        repoUrl: options.repoUrl,
+        ref: options.ref,
+        source: options.source,
+        projectDir: location.projectDir,
+    });
+}
+export async function runBuild(options, hooks) {
+    const plan = await prepareBuildPlan(options);
+    hooks?.onPlan?.(plan);
+    if (options.dryRun) {
+        writeInfo("Dry run: planned build steps", hooks);
+        writeInfo(formatBuildPlan(plan), hooks);
+        return plan;
+    }
+    await assertRequiredTools(plan.requiredTools);
+    for (const [index, step] of plan.steps.entries()) {
+        hooks?.onStepStart?.(step, { index: index + 1, total: plan.steps.length });
+        writeInfo(`==> ${step.title}`, hooks);
+        await runProcess(step.command, step.args, {
+            cwd: step.cwd,
+            stdio: hooks ? ["ignore", "pipe", "pipe"] : "inherit",
+            onStdout: (chunk) => {
+                hooks?.onStdout?.(chunk, step);
+            },
+            onStderr: (chunk) => {
+                hooks?.onStderr?.(chunk, step);
+            },
+        });
+    }
+    writeInfo("Build completed successfully.", hooks);
+    writeInfo(`Working directory: ${plan.projectDir}`, hooks);
+    return plan;
+}
+export function formatBuildPlan(plan) {
+    return [
+        `Repository directory: ${plan.projectDir}`,
+        `Using existing source: ${plan.usesExistingSource ? "yes" : "no"}`,
+        `Required tools: ${plan.requiredTools.join(", ")}`,
+        ...plan.steps.map((step, index) => `${index + 1}. ${step.title}\n   ${formatStep(step)}`),
+    ].join("\n");
+}
+async function resolveProjectDir(options) {
+    if (options.source) {
+        const projectDir = path.resolve(options.source);
+        await assertExistingDirectory(projectDir, "source");
+        return {
+            projectDir,
+            usesExistingSource: true,
+        };
+    }
+    if (options.workdir) {
+        const projectDir = path.resolve(options.workdir);
+        await assertCloneTargetIsReady(projectDir);
+        return {
+            projectDir,
+            usesExistingSource: false,
+        };
+    }
+    const projectDir = await mkdtemp(path.join(os.tmpdir(), "waelio-siteforge-"));
+    return {
+        projectDir,
+        usesExistingSource: false,
+    };
+}
+async function assertRequiredTools(tools) {
+    const failures = [];
+    for (const tool of tools) {
+        const result = await checkTool(tool);
+        if (!result.ok) {
+            failures.push(`${tool}: ${result.details}`);
+        }
+    }
+    if (failures.length > 0) {
+        throw new Error(`Missing required tools:\n- ${failures.join("\n- ")}`);
+    }
+}
+async function checkTool(tool) {
+    const args = TOOL_VERSION_ARGS[tool] ?? ["--version"];
+    try {
+        const output = await captureProcess(tool, args);
+        return {
+            tool,
+            ok: true,
+            details: output.split(/\r?\n/)[0]?.trim() || "available",
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            tool,
+            ok: false,
+            details: message,
+        };
+    }
+}
+async function assertExistingDirectory(targetPath, label) {
+    let details;
+    try {
+        details = await stat(targetPath);
+    }
+    catch (error) {
+        if (isMissingPathError(error)) {
+            throw new Error(`The ${label} path does not exist: ${targetPath}`);
+        }
+        throw error;
+    }
+    if (!details.isDirectory()) {
+        throw new Error(`The ${label} path is not a directory: ${targetPath}`);
+    }
+}
+async function assertCloneTargetIsReady(targetPath) {
+    try {
+        const details = await stat(targetPath);
+        if (!details.isDirectory()) {
+            throw new Error(`The workdir path exists but is not a directory: ${targetPath}`);
+        }
+        const entries = await readdir(targetPath);
+        if (entries.length > 0) {
+            throw new Error(`The workdir path must be empty before cloning: ${targetPath}`);
+        }
+    }
+    catch (error) {
+        if (isMissingPathError(error)) {
+            return;
+        }
+        throw error;
+    }
+}
+function formatStep(step) {
+    const command = [step.command, ...step.args].map(quoteArgument).join(" ");
+    if (!step.cwd) {
+        return command;
+    }
+    return `${command} (cwd: ${step.cwd})`;
+}
+function quoteArgument(value) {
+    if (/^[a-zA-Z0-9_./:=@-]+$/.test(value)) {
+        return value;
+    }
+    return JSON.stringify(value);
+}
+function writeInfo(message, hooks) {
+    if (hooks?.onInfo) {
+        hooks.onInfo(message);
+        return;
+    }
+    console.log(message);
+}
+async function captureProcess(command, args) {
+    let stdout = "";
+    let stderr = "";
+    await runProcess(command, args, {
+        stdio: ["ignore", "pipe", "pipe"],
+        onStdout: (chunk) => {
+            stdout += chunk;
+        },
+        onStderr: (chunk) => {
+            stderr += chunk;
+        },
+    });
+    return `${stdout}${stderr}`.trim();
+}
+function runProcess(command, args, options) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(resolveCommand(command), args, {
+            cwd: options.cwd,
+            stdio: options.stdio ?? "inherit",
+        });
+        child.stdout?.setEncoding("utf8");
+        child.stdout?.on("data", (chunk) => {
+            options.onStdout?.(chunk);
+        });
+        child.stderr?.setEncoding("utf8");
+        child.stderr?.on("data", (chunk) => {
+            options.onStderr?.(chunk);
+        });
+        child.on("error", (error) => {
+            if (error.code === "ENOENT") {
+                reject(new Error(`Command not found: ${command}`));
+                return;
+            }
+            reject(error);
+        });
+        child.on("close", (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(`Command failed with exit code ${code}: ${formatCommand(command, args)}`));
+        });
+    });
+}
+function resolveCommand(command) {
+    if (process.platform === "win32" && command === "npm") {
+        return "npm.cmd";
+    }
+    return command;
+}
+function formatCommand(command, args) {
+    return [command, ...args].map(quoteArgument).join(" ");
+}
+function isMissingPathError(error) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}

package/dist/siteforge.test.d.ts

@@ -0,0 +1 @@
+export {};