@openvcs/sdk 0.2.0 → 0.2.2

package/lib/init.js

@@ -0,0 +1,307 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__private = void 0;
+exports.initUsage = initUsage;
+exports.runInitCommand = runInitCommand;
+exports.isUsageError = isUsageError;
+const fs = require("node:fs");
+const path = require("node:path");
+const readline = require("node:readline/promises");
+const node_process_1 = require("node:process");
+const node_child_process_1 = require("node:child_process");
+const packageJson = require("../package.json");
+function npmExecutable() {
+    return process.platform === "win32" ? "npm.cmd" : "npm";
+}
+function initUsage(commandName = "openvcs") {
+    return `Usage: ${commandName} init [--theme] [target-dir]\n\nOptions:\n  --theme                Start with a theme-only plugin template\n`;
+}
+function sanitizeIdToken(raw) {
+    let output = "";
+    let lastWasSeparator = false;
+    for (const char of raw) {
+        const isValid = /[a-zA-Z0-9._-]/.test(char);
+        if (isValid) {
+            output += char.toLowerCase();
+            lastWasSeparator = false;
+            continue;
+        }
+        if (!lastWasSeparator) {
+            output += "-";
+            lastWasSeparator = true;
+        }
+    }
+    return output.replace(/^-+|-+$/g, "");
+}
+function defaultPluginIdFromDir(targetDir) {
+    const name = path.basename(targetDir) || "openvcs-plugin";
+    const token = sanitizeIdToken(name);
+    return token || "openvcs.plugin";
+}
+function defaultPluginNameFromId(pluginId) {
+    const words = pluginId
+        .split(/[._-]+/)
+        .map((word) => word.trim())
+        .filter(Boolean)
+        .map((word) => word[0].toUpperCase() + word.slice(1));
+    return words.length > 0 ? words.join(" ") : "OpenVCS Plugin";
+}
+function validatePluginId(pluginId) {
+    if (!pluginId) {
+        return "Plugin id is required.";
+    }
+    if (pluginId === "." || pluginId === "..") {
+        return "Plugin id must not be '.' or '..'.";
+    }
+    if (pluginId.includes("/") || pluginId.includes("\\")) {
+        return "Plugin id must not contain path separators (/ or \\).";
+    }
+    return undefined;
+}
+function createReadlinePromptDriver(output = process.stderr) {
+    const rl = readline.createInterface({ input: node_process_1.stdin, output: node_process_1.stdout });
+    return {
+        async promptText(label, defaultValue = "") {
+            const suffix = defaultValue ? ` [${defaultValue}]` : "";
+            const answer = await rl.question(`${label}${suffix}: `);
+            const trimmed = answer.trim();
+            return trimmed || defaultValue;
+        },
+        async promptBoolean(label, defaultValue) {
+            const suffix = defaultValue ? "Y/n" : "y/N";
+            while (true) {
+                const answer = await rl.question(`${label} (${suffix}): `);
+                const normalized = answer.trim().toLowerCase();
+                if (!normalized) {
+                    return defaultValue;
+                }
+                if (normalized === "y" || normalized === "yes") {
+                    return true;
+                }
+                if (normalized === "n" || normalized === "no") {
+                    return false;
+                }
+                output.write("Please answer yes or no.\n");
+            }
+        },
+        close() {
+            rl.close();
+        },
+    };
+}
+function writeJson(filePath, value) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+function writeText(filePath, content) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, content, "utf8");
+}
+function directoryHasEntries(targetDir) {
+    const entries = fs.readdirSync(targetDir);
+    return entries.length > 0;
+}
+async function collectAnswers({ forceTheme, targetHint }, promptDriver = createReadlinePromptDriver(), output = process.stderr) {
+    const defaultTarget = targetHint || path.join(process.cwd(), "openvcs-plugin");
+    try {
+        const targetText = await promptDriver.promptText("Target directory", defaultTarget);
+        const targetDir = path.resolve(targetText);
+        let kind = "module";
+        if (forceTheme) {
+            kind = "theme";
+        }
+        else {
+            while (true) {
+                const value = (await promptDriver.promptText("Template type (module/theme)", "module"))
+                    .trim()
+                    .toLowerCase();
+                if (value === "module" || value === "m") {
+                    kind = "module";
+                    break;
+                }
+                if (value === "theme" || value === "t") {
+                    kind = "theme";
+                    break;
+                }
+                output.write("Please choose 'module' or 'theme'.\n");
+            }
+        }
+        const defaultId = defaultPluginIdFromDir(targetDir);
+        let pluginId;
+        while (!pluginId) {
+            const candidateId = (await promptDriver.promptText("Plugin id", defaultId)).trim();
+            const validationError = validatePluginId(candidateId);
+            if (!validationError) {
+                pluginId = candidateId;
+                break;
+            }
+            output.write(`${validationError}\n`);
+        }
+        const defaultName = defaultPluginNameFromId(pluginId);
+        let pluginName = "";
+        while (!pluginName) {
+            pluginName = (await promptDriver.promptText("Plugin name", defaultName)).trim();
+        }
+        let pluginVersion = "";
+        while (!pluginVersion) {
+            pluginVersion = (await promptDriver.promptText("Version", "0.1.0")).trim();
+        }
+        const defaultEnabled = await promptDriver.promptBoolean("Default enabled", true);
+        const runNpmInstall = await promptDriver.promptBoolean("Run npm install now", true);
+        return {
+            targetDir,
+            kind,
+            pluginId,
+            pluginName,
+            pluginVersion,
+            defaultEnabled,
+            runNpmInstall,
+        };
+    }
+    finally {
+        promptDriver.close();
+    }
+}
+function runNpmInstall(targetDir) {
+    const result = (0, node_child_process_1.spawnSync)(npmExecutable(), ["install"], {
+        cwd: targetDir,
+        stdio: "inherit",
+    });
+    if (result.error) {
+        throw new Error(`failed to spawn npm install in ${targetDir}: ${result.error.message}`);
+    }
+    if (result.status !== 0) {
+        throw new Error(`npm install failed in ${targetDir} (code ${result.status})`);
+    }
+}
+function writeCommonFiles(answers) {
+    writeJson(path.join(answers.targetDir, "openvcs.plugin.json"), {
+        id: answers.pluginId,
+        name: answers.pluginName,
+        version: answers.pluginVersion,
+        default_enabled: answers.defaultEnabled,
+        ...(answers.kind === "module" ? { module: { exec: "plugin.js" } } : {}),
+    });
+    writeText(path.join(answers.targetDir, ".gitignore"), "node_modules/\ndist/\n");
+}
+function writeModuleTemplate(answers) {
+    writeCommonFiles(answers);
+    writeJson(path.join(answers.targetDir, "package.json"), {
+        name: answers.pluginId,
+        version: answers.pluginVersion,
+        private: true,
+        type: "module",
+        scripts: {
+            "build:ts": "tsc -p tsconfig.json",
+            build: "npm run build:ts && openvcs dist --plugin-dir . --out dist",
+            test: "openvcs dist --plugin-dir . --out dist --no-npm-deps",
+        },
+        devDependencies: {
+            "@openvcs/sdk": `^${packageJson.version}`,
+            "@types/node": "^22.0.0",
+            typescript: "^5.8.2",
+        },
+    });
+    writeJson(path.join(answers.targetDir, "tsconfig.json"), {
+        compilerOptions: {
+            target: "ES2022",
+            module: "NodeNext",
+            moduleResolution: "NodeNext",
+            types: ["node"],
+            strict: true,
+            skipLibCheck: true,
+            outDir: "bin",
+            rootDir: "src",
+        },
+        include: ["src/**/*.ts"],
+    });
+    writeText(path.join(answers.targetDir, "src", "plugin.ts"), "const message = \"OpenVCS plugin started\";\nprocess.stderr.write(`${message}\\n`);\n");
+}
+function writeThemeTemplate(answers) {
+    writeCommonFiles(answers);
+    writeJson(path.join(answers.targetDir, "package.json"), {
+        name: answers.pluginId,
+        version: answers.pluginVersion,
+        private: true,
+        scripts: {
+            build: "openvcs dist --plugin-dir . --out dist",
+            test: "openvcs dist --plugin-dir . --out dist --no-npm-deps",
+        },
+        devDependencies: {
+            "@openvcs/sdk": `^${packageJson.version}`,
+        },
+    });
+    writeJson(path.join(answers.targetDir, "themes", "default", "theme.json"), {
+        name: answers.pluginName || "Default Theme",
+        description: "Starter OpenVCS theme generated by @openvcs/sdk",
+        tokens: {
+            accent: "#2a7fff",
+            background: "#0f172a",
+            foreground: "#e2e8f0",
+        },
+    });
+}
+async function runInitCommand(args) {
+    let forceTheme = false;
+    let targetHint;
+    for (const arg of args) {
+        if (arg === "--theme") {
+            forceTheme = true;
+            continue;
+        }
+        if (arg === "--help") {
+            const error = new Error(initUsage());
+            error.code = "USAGE";
+            throw error;
+        }
+        if (arg.startsWith("-")) {
+            throw new Error(`unknown argument for init: ${arg}`);
+        }
+        if (targetHint) {
+            throw new Error("init accepts at most one target directory");
+        }
+        targetHint = arg;
+    }
+    const answers = await collectAnswers({ forceTheme, targetHint });
+    if (!fs.existsSync(answers.targetDir)) {
+        fs.mkdirSync(answers.targetDir, { recursive: true });
+    }
+    else if (!fs.lstatSync(answers.targetDir).isDirectory()) {
+        throw new Error(`target path exists but is not a directory: ${answers.targetDir}`);
+    }
+    else if (directoryHasEntries(answers.targetDir)) {
+        const promptDriver = createReadlinePromptDriver();
+        try {
+            const proceed = await promptDriver.promptBoolean(`Directory ${answers.targetDir} is not empty. Continue and overwrite known files`, false);
+            if (!proceed) {
+                throw new Error("aborted by user");
+            }
+        }
+        finally {
+            promptDriver.close();
+        }
+    }
+    if (answers.kind === "module") {
+        writeModuleTemplate(answers);
+    }
+    else {
+        writeThemeTemplate(answers);
+    }
+    if (answers.runNpmInstall) {
+        runNpmInstall(answers.targetDir);
+    }
+    return answers.targetDir;
+}
+function isUsageError(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        typeof error.code === "string");
+}
+exports.__private = {
+    collectAnswers,
+    createReadlinePromptDriver,
+    defaultPluginIdFromDir,
+    sanitizeIdToken,
+    validatePluginId,
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@openvcs/sdk",
-  "version": "0.2.0",
-  "description": "OpenVCS SDK CLI for plugin scaffolding and .ovcsp packaging",
+  "version": "0.2.2",
+  "description": "OpenVCS SDK CLI for plugin scaffolding and .ovcsp tar.gz packaging",
   "license": "GPL-3.0-or-later",
   "homepage": "https://bbgames.dev/",
   "repository": {
@@ -15,16 +15,27 @@
     "node": ">=18"
   },
   "bin": {
-    "openvcs-sdk": "bin/openvcs-sdk.js"
+    "openvcs": "bin/openvcs.js"
   },
   "scripts": {
-    "postinstall": "node scripts/postinstall.js"
+    "build": "node scripts/build-sdk.js",
+    "test": "npm run build && node --test test/*.test.js",
+    "prepack": "npm run build",
+    "preopenvcs": "npm run build",
+    "openvcs": "node bin/openvcs.js"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.21",
+    "typescript": "^5.8.2"
+  },
+  "dependencies": {
+    "tar": "^7.4.3"
   },
   "files": [
+    "src/",
     "bin/",
     "lib/",
-    "scripts/",
-    "vendor/",
+    "test/",
     "README.md",
     "LICENSE"
   ]

package/src/bin/openvcs.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+import { runCli } from "../lib/cli";
+
+runCli(process.argv.slice(2)).catch((error: unknown) => {
+  const detail = error instanceof Error ? error.message : String(error);
+  process.stderr.write(`${detail}\n`);
+  process.exit(1);
+});

package/src/lib/cli.ts

@@ -0,0 +1,77 @@
+import { bundlePlugin, distUsage, parseDistArgs } from "./dist";
+import { initUsage, runInitCommand } from "./init";
+
+const packageJson: { version: string } = require("../package.json");
+
+interface CodedError {
+  code?: string;
+}
+
+function hasCode(error: unknown, code: string): boolean {
+  return (
+    typeof error === "object" &&
+    error !== null &&
+    "code" in error &&
+    (error as CodedError).code === code
+  );
+}
+
+function usage(): string {
+  return "Usage: openvcs <command> [options]\n\nCommands:\n  dist [args]            Package plugin into .ovcsp\n  init [--theme] [dir]   Interactively scaffold a plugin project\n  -v, --version          Show version information\n\nDist args:\n  --plugin-dir <path>    Plugin root containing openvcs.plugin.json\n  --out <path>           Output directory (default: ./dist)\n  --no-npm-deps          Skip npm dependency bundling\n  -V, --verbose          Verbose output\n";
+}
+
+export async function runCli(args: string[]): Promise<void> {
+  if (args.length === 0) {
+    process.stderr.write(usage());
+    process.exitCode = 1;
+    return;
+  }
+
+  if (args.includes("-v") || args.includes("--version")) {
+    process.stdout.write(`openvcs ${packageJson.version}\n`);
+    return;
+  }
+
+  const [command, ...rest] = args;
+  if (command === "help" || command === "--help" || command === "-h") {
+    process.stdout.write(usage());
+    return;
+  }
+
+  if (command === "dist") {
+    if (rest.includes("--help")) {
+      process.stdout.write(distUsage());
+      return;
+    }
+    try {
+      const parsed = parseDistArgs(rest);
+      const outPath = await bundlePlugin(parsed);
+      process.stdout.write(`${outPath}\n`);
+      return;
+    } catch (error: unknown) {
+      if (hasCode(error, "USAGE")) {
+        throw new Error(distUsage());
+      }
+      throw error;
+    }
+  }
+
+  if (command === "init") {
+    if (rest.includes("--help")) {
+      process.stdout.write(initUsage());
+      return;
+    }
+    try {
+      const targetDir = await runInitCommand(rest);
+      process.stdout.write(`Initialized plugin at ${targetDir}\n`);
+      return;
+    } catch (error: unknown) {
+      if (hasCode(error, "USAGE")) {
+        throw new Error(initUsage());
+      }
+      throw error;
+    }
+  }
+
+  throw new Error(`unknown command: ${command}`);
+}