@envodium/envodium-cli 0.1.0

package/dist/browser.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.capturePageErrors = capturePageErrors;
+const puppeteer_1 = __importDefault(require("puppeteer"));
+/**
+ * Opens a URL in a visible Chrome window. The user can interact with the page.
+ * All JS errors/console output are captured in the background.
+ * When the user closes the browser window, results are returned.
+ */
+async function capturePageErrors(url, opts) {
+    const isHeadless = opts?.headless ?? false;
+    const consoleLogs = [];
+    const errors = [];
+    const browser = await puppeteer_1.default.launch({
+        headless: isHeadless,
+        defaultViewport: isHeadless ? { width: 1920, height: 1080 } : null,
+        args: ["--no-sandbox", "--disable-setuid-sandbox", ...(isHeadless ? [] : ["--start-maximized"])]
+    });
+    try {
+        const page = await browser.newPage();
+        // Auto-dismiss alert/confirm/prompt dialogs so they don't block
+        page.on("dialog", async (dialog) => {
+            consoleLogs.push({ type: "dialog", text: `${dialog.type()}: ${dialog.message()}` });
+            await dialog.dismiss();
+        });
+        // Capture console.log / console.error / console.warn etc.
+        page.on("console", (msg) => {
+            consoleLogs.push({ type: msg.type(), text: msg.text() });
+        });
+        // Capture uncaught exceptions
+        page.on("pageerror", (err) => {
+            errors.push(err.message || String(err));
+        });
+        // Capture failed requests (like 404 scripts)
+        page.on("requestfailed", (req) => {
+            errors.push(`Request failed: ${req.url()} (${req.failure()?.errorText ?? "unknown"})`);
+        });
+        await page.goto(url, { waitUntil: "domcontentloaded", timeout: 15000 });
+        if (isHeadless) {
+            // In headless mode, wait a few seconds for deferred JS then close
+            await new Promise((r) => setTimeout(r, 3000));
+            await browser.close();
+        }
+        else {
+            // In visible mode, wait until the user closes the browser
+            await new Promise((resolve) => {
+                browser.on("disconnected", () => resolve());
+            });
+        }
+    }
+    catch (err) {
+        // If browser was closed during goto, that's fine
+        if (!String(err).includes("Target closed") && !String(err).includes("Protocol error")) {
+            throw err;
+        }
+    }
+    return { consoleLogs, errors };
+}

package/dist/cli.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("./core");
+async function main() {
+    const cmd = (process.argv[2] || "").toLowerCase();
+    const cwd = process.cwd();
+    if (cmd === "-v" || cmd === "--version" || cmd === "-version") {
+        const pkg = require("../package.json");
+        console.log(pkg.version);
+        return;
+    }
+    try {
+        if (cmd === "build") {
+            await (0, core_1.build)({ cwd, addTestParam: false, headless: false });
+            return;
+        }
+        if (cmd === "test") {
+            const headless = process.argv.includes("-headless") || process.argv.includes("--headless");
+            const noBrowser = process.argv.includes("-no") || process.argv.includes("--no");
+            await (0, core_1.build)({ cwd, addTestParam: true, headless, noBrowser });
+            return;
+        }
+        if (cmd === "meta") {
+            const input = process.argv[3] || "";
+            if (!input) {
+                console.log("Usage: envodium meta <input>");
+                return;
+            }
+            await (0, core_1.meta)({ cwd, input });
+            return;
+        }
+        if (cmd === "sync") {
+            await (0, core_1.sync)({ cwd });
+            return;
+        }
+        console.log("Usage: envodium build | test | sync | meta <input>");
+    }
+    catch (err) {
+        const e = err;
+        console.error("Fel:", e?.message ?? String(err));
+        process.exit(1);
+    }
+}
+main();

package/dist/config.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readProjectConfig = readProjectConfig;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+async function readProjectConfig(cwd) {
+    const vscodePath = path_1.default.join(cwd, "vscode.js");
+    let endpoint;
+    let bearer;
+    if (fs_1.default.existsSync(vscodePath)) {
+        // CommonJS require
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const mod = require(vscodePath);
+        endpoint = mod.endpoint;
+        bearer = mod.bearer;
+    }
+    // env vars override (nice for CI/Claude/Codex)
+    endpoint = process.env.ENVODIUM_ENDPOINT || endpoint;
+    bearer = process.env.ENVODIUM_BEARER || bearer;
+    return { endpoint, bearer };
+}

package/dist/core.js

@@ -0,0 +1,238 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.build = build;
+exports.meta = meta;
+exports.sync = sync;
+const path_1 = __importDefault(require("path"));
+const url_1 = require("url");
+const config_1 = require("./config");
+const http_1 = require("./http");
+const files_1 = require("./files");
+const util_1 = require("./util");
+const browser_1 = require("./browser");
+async function build(opts) {
+    const { cwd, addTestParam, headless, noBrowser } = opts;
+    const cfg = await (0, config_1.readProjectConfig)(cwd);
+    if (!cfg.endpoint)
+        throw new Error("Ingen endpoint hittad (vscode.js saknas eller saknar endpoint).");
+    let endpoint = cfg.endpoint;
+    if (addTestParam) {
+        endpoint = (0, util_1.addOrReplaceQueryParam)(endpoint, "test", (0, util_1.newGuid)());
+    }
+    const files = await (0, files_1.collectFiles)(cwd);
+    const items = [];
+    for (const abs of files) {
+        const title = path_1.default.basename(abs);
+        const value = await files_1.writeFileUtf8.read(abs);
+        items.push({ title, value, lang: getLangFromFileName(title), openintab: false, deleted: false });
+    }
+    const body = JSON.stringify(items);
+    const headers = {
+        "Content-Type": "application/json",
+        "Content-Length": String(Buffer.byteLength(body, "utf8"))
+    };
+    if (cfg.bearer)
+        headers["Authorization"] = `Bearer ${cfg.bearer}`;
+    const res = await (0, http_1.httpSend)(endpoint, "POST", headers, body);
+    console.log("Status:", res.statusCode);
+    if (res.statusCode < 200 || res.statusCode >= 300) {
+        console.log(res.body);
+        throw new Error(`HTTP ${res.statusCode}`);
+    }
+    // Print preview URL (same logic as VS Code extension's buildPreviewUrlFromEndpoint)
+    const previewUrl = buildPreviewUrl(endpoint, cfg.bearer);
+    if (previewUrl) {
+        console.log(previewUrl);
+    }
+    // If test mode, open Chrome to capture JS errors
+    if (addTestParam && previewUrl && !noBrowser) {
+        if (headless) {
+            console.log("\nOpening headless Chrome to capture JS errors...");
+        }
+        else {
+            console.log("\nOpening Chrome — close the browser window when done testing...");
+        }
+        const result = await (0, browser_1.capturePageErrors)(previewUrl, { headless: !!headless });
+        if (result.errors.length > 0) {
+            console.log(`\n--- JS Errors (${result.errors.length}) ---`);
+            for (const err of result.errors) {
+                console.error("  ERROR:", err);
+            }
+        }
+        const consoleErrors = result.consoleLogs.filter((l) => l.type === "error");
+        const consoleWarnings = result.consoleLogs.filter((l) => l.type === "warning");
+        const consoleMsgs = result.consoleLogs.filter((l) => l.type !== "error" && l.type !== "warning");
+        if (consoleErrors.length > 0) {
+            console.log(`\n--- Console Errors (${consoleErrors.length}) ---`);
+            for (const l of consoleErrors)
+                console.error("  console.error:", l.text);
+        }
+        if (consoleWarnings.length > 0) {
+            console.log(`\n--- Console Warnings (${consoleWarnings.length}) ---`);
+            for (const l of consoleWarnings)
+                console.warn("  console.warn:", l.text);
+        }
+        if (consoleMsgs.length > 0) {
+            console.log(`\n--- Console Output (${consoleMsgs.length}) ---`);
+            for (const l of consoleMsgs)
+                console.log(`  console.${l.type}:`, l.text);
+        }
+        const totalIssues = result.errors.length + consoleErrors.length;
+        if (totalIssues === 0) {
+            console.log("\nNo JS errors detected.");
+        }
+        else {
+            console.log(`\nTotal issues: ${totalIssues}`);
+        }
+    }
+}
+function buildPreviewUrl(endpoint, bearer) {
+    try {
+        const u = new url_1.URL(endpoint);
+        const guid = u.searchParams.get("guid");
+        if (!guid)
+            return null;
+        u.pathname = u.pathname.replace(/vscode\.aspx$/i, "vscode_view.aspx");
+        const params = new URLSearchParams();
+        params.set("guid", guid);
+        const test = u.searchParams.get("test");
+        if (test)
+            params.set("test", test);
+        if (bearer)
+            params.set("bearer", bearer);
+        u.search = `?${params.toString()}`;
+        return u.toString();
+    }
+    catch {
+        return null;
+    }
+}
+async function meta(opts) {
+    const { cwd, input } = opts;
+    const cfg = await (0, config_1.readProjectConfig)(cwd);
+    if (!cfg.endpoint)
+        throw new Error("Ingen endpoint hittad (vscode.js saknas eller saknar endpoint).");
+    // Replace vscode.aspx with meta.aspx
+    let endpoint = cfg.endpoint.replace(/vscode\.aspx/i, "meta.aspx");
+    endpoint = (0, util_1.addOrReplaceQueryParam)(endpoint, "input", input);
+    if (cfg.bearer)
+        endpoint = (0, util_1.addOrReplaceQueryParam)(endpoint, "bearer", cfg.bearer);
+    const headers = {};
+    if (cfg.bearer)
+        headers["Authorization"] = `Bearer ${cfg.bearer}`;
+    const res = await (0, http_1.httpSend)(endpoint, "POST", headers, "");
+    console.log("Status:", res.statusCode);
+    if (res.body)
+        console.log(res.body);
+    if (res.statusCode < 200 || res.statusCode >= 300) {
+        throw new Error(`HTTP ${res.statusCode}`);
+    }
+}
+function getLangFromFileName(name) {
+    const lower = name.toLowerCase();
+    if (lower.endsWith(".html") || lower.endsWith(".htm"))
+        return "html";
+    if (lower.endsWith(".js"))
+        return "javascript";
+    if (lower.endsWith(".css"))
+        return "css";
+    return "text";
+}
+function buildSyncUrl(endpoint, bearer) {
+    try {
+        const u = new url_1.URL(endpoint);
+        const guid = u.searchParams.get("guid");
+        if (!guid)
+            return null;
+        u.pathname = u.pathname.replace(/vscode\.aspx$/i, "vscode_sync.aspx");
+        const params = new URLSearchParams();
+        params.set("guid", guid);
+        if (bearer)
+            params.set("bearer", bearer);
+        u.search = `?${params.toString()}`;
+        return u.toString();
+    }
+    catch {
+        return null;
+    }
+}
+function ensureExtension(name, fallbackExt = ".html") {
+    if (!name)
+        return "untitled" + fallbackExt;
+    if (/\.[a-z0-9]+$/i.test(name))
+        return name;
+    return name + (fallbackExt.startsWith(".") ? fallbackExt : "." + fallbackExt);
+}
+async function sync(opts) {
+    const { cwd } = opts;
+    const cfg = await (0, config_1.readProjectConfig)(cwd);
+    if (!cfg.endpoint)
+        throw new Error("Ingen endpoint hittad (vscode.js saknas eller saknar endpoint).");
+    // Build sync URL: vscode.aspx -> vscode_sync.aspx, add guid + bearer as query params
+    const syncUrl = buildSyncUrl(cfg.endpoint, cfg.bearer);
+    if (!syncUrl)
+        throw new Error("Kunde inte bygga sync-URL (saknar guid i endpoint?).");
+    const headers = {};
+    if (cfg.bearer)
+        headers["Authorization"] = `Bearer ${cfg.bearer}`;
+    console.log("Syncing from server...");
+    const res = await (0, http_1.httpSend)(syncUrl, "GET", headers, "");
+    if (res.statusCode < 200 || res.statusCode >= 300) {
+        console.log(res.body);
+        throw new Error(`Sync misslyckades: HTTP ${res.statusCode}`);
+    }
+    let payload;
+    try {
+        payload = JSON.parse(res.body);
+    }
+    catch {
+        throw new Error("Svar var inte giltig JSON-array.");
+    }
+    if (!Array.isArray(payload))
+        throw new Error("Svar är inte en array.");
+    // Build a map of existing local files by basename
+    const existingFiles = await (0, files_1.collectFiles)(cwd);
+    const byBase = new Map();
+    for (const abs of existingFiles) {
+        const base = path_1.default.basename(abs).toLowerCase();
+        const list = byBase.get(base) ?? [];
+        list.push(abs);
+        byBase.set(base, list);
+    }
+    let updated = 0;
+    let created = 0;
+    for (const item of payload) {
+        if (!item?.title)
+            continue;
+        // Ensure file has an extension
+        const desiredTitle = ensureExtension(item.title, ".html");
+        const baseKey = desiredTitle.toLowerCase();
+        // Skip vscode.js
+        if (baseKey === "vscode.js")
+            continue;
+        let targetPath;
+        const candidates = byBase.get(baseKey);
+        if (candidates && candidates.length > 0) {
+            // Pick the one with the shortest relative path
+            targetPath = candidates.sort((a, b) => {
+                const ra = path_1.default.relative(cwd, a);
+                const rb = path_1.default.relative(cwd, b);
+                if (ra.length !== rb.length)
+                    return ra.length - rb.length;
+                return ra.localeCompare(rb);
+            })[0];
+            updated++;
+        }
+        else {
+            // Create in project root
+            targetPath = path_1.default.join(cwd, desiredTitle);
+            created++;
+        }
+        await files_1.writeFileUtf8.write(targetPath, item.value ?? "");
+        console.log(`  ${candidates ? "Updated" : "Created"}: ${path_1.default.relative(cwd, targetPath)}`);
+    }
+    console.log(`\nSync klar – uppdaterade ${updated}, skapade ${created}.`);
+}

package/dist/files.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeFileUtf8 = void 0;
+exports.collectFiles = collectFiles;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+async function collectFiles(cwd) {
+    const result = [];
+    // If a dist/ folder exists, only collect files from there
+    const distDir = path_1.default.join(cwd, "dist");
+    let useDistOnly = false;
+    try {
+        const stat = await promises_1.default.stat(distDir);
+        useDistOnly = stat.isDirectory();
+    }
+    catch {
+        // dist doesn't exist, collect from cwd as normal
+    }
+    const rootDir = useDistOnly ? distDir : cwd;
+    async function walk(dir) {
+        const entries = await promises_1.default.readdir(dir, { withFileTypes: true });
+        for (const e of entries) {
+            const abs = path_1.default.join(dir, e.name);
+            if (e.isDirectory()) {
+                if (["node_modules", ".git", "dist", "out", "bin", "obj", "coverage"].includes(e.name))
+                    continue;
+                await walk(abs);
+            }
+            else if (e.isFile()) {
+                const lower = e.name.toLowerCase();
+                // Skip vscode.js (config file, not part of the project payload)
+                if (lower === "vscode.js")
+                    continue;
+                if (lower.endsWith(".html") || lower.endsWith(".htm") || lower.endsWith(".js") || lower.endsWith(".css")) {
+                    result.push(abs);
+                }
+            }
+        }
+    }
+    await walk(rootDir);
+    return result;
+}
+exports.writeFileUtf8 = {
+    async read(abs) {
+        const buf = await promises_1.default.readFile(abs);
+        return buf.toString("utf8");
+    },
+    async write(abs, content) {
+        await promises_1.default.writeFile(abs, content, "utf8");
+    }
+};

package/dist/http.js

@@ -0,0 +1,67 @@
+"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.httpSend = httpSend;
+const http = __importStar(require("http"));
+const https = __importStar(require("https"));
+const dns = __importStar(require("dns"));
+const url_1 = require("url");
+function httpSend(endpoint, method, headers, body) {
+    return new Promise((resolve, reject) => {
+        const url = new url_1.URL(endpoint);
+        const lib = url.protocol === "https:" ? https : http;
+        const req = lib.request({
+            method,
+            hostname: url.hostname,
+            port: url.port ? Number(url.port) : undefined,
+            path: url.pathname + url.search,
+            headers,
+            // Force IPv4 for localhost to avoid ECONNREFUSED on ::1
+            lookup: (hostname, options, callback) => {
+                dns.lookup(hostname, { ...options, family: 4 }, callback);
+            }
+        }, (res) => {
+            let data = "";
+            res.setEncoding("utf8");
+            res.on("data", (chunk) => (data += chunk));
+            res.on("end", () => resolve({ statusCode: res.statusCode || 0, body: data }));
+        });
+        req.on("error", reject);
+        req.setTimeout(30000, () => req.destroy(new Error("Timeout (30s)")));
+        if (method !== "GET" && body)
+            req.write(body);
+        req.end();
+    });
+}

package/dist/util.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addOrReplaceQueryParam = addOrReplaceQueryParam;
+exports.newGuid = newGuid;
+const crypto_1 = __importDefault(require("crypto"));
+const url_1 = require("url");
+function addOrReplaceQueryParam(urlStr, key, value) {
+    const u = new url_1.URL(urlStr);
+    u.searchParams.set(key, value);
+    return u.toString();
+}
+function newGuid() {
+    const anyCrypto = crypto_1.default;
+    if (typeof anyCrypto.randomUUID === "function")
+        return anyCrypto.randomUUID();
+    const b = crypto_1.default.randomBytes(16);
+    b[6] = (b[6] & 0x0f) | 0x40;
+    b[8] = (b[8] & 0x3f) | 0x80;
+    const hex = [...b].map((n) => n.toString(16).padStart(2, "0"));
+    return `${hex.slice(0, 4).join("")}-${hex.slice(4, 6).join("")}-${hex.slice(6, 8).join("")}-${hex
+        .slice(8, 10)
+        .join("")}-${hex.slice(10).join("")}`;
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@envodium/envodium-cli",
+  "version": "0.1.0",
+  "description": "CLI for Envodium build, test, sync and meta commands",
+  "type": "commonjs",
+  "bin": {
+    "envodium": "dist/cli.js"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "envodium",
+    "cli",
+    "build",
+    "deploy"
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^25.3.0",
+    "typescript": "^5.5.4"
+  },
+  "dependencies": {
+    "puppeteer": "^24.37.4"
+  }
+}