create-yeow 0.1.0

package/bin/index.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+import { mkdirSync, writeFileSync, readFileSync, existsSync, cpSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const argv = process.argv.slice(2);
+const _flag = (f) => argv.includes(f);
+const _val = (f) => argv.find(a => a.startsWith(f))?.split('=').slice(1).join('=');
+
+const yes = _flag('-y') || process.env.CI === 'true';
+const useTs = _flag('--ts');
+const name = yes ? (_val('--name=') || 'my-yeow-plugin') : (argv[0] || 'my-yeow-plugin');
+const author = yes ? (_val('--author=') || '') : '';
+
+const c = { r:'\x1b[0m',b:'\x1b[1m',d:'\x1b[2m',g:'\x1b[32m',y:'\x1b[33m',B:'\x1b[34m',C:'\x1b[36m' };
+const _ = (m) => process.stdout.write(m);
+const ok = (m) => _(`  ${c.g}✓${c.r} ${m}\n`);
+const step = (m) => _(`  ${c.C}→${c.r} ${m}... `);
+
+const tpl = resolve(__dirname, '..', 'templates', 'default');
+const dir = resolve(process.cwd(), name);
+
+_(`\n  ${c.b}${c.B}Yeow v0${c.r}  ${c.d}— plugin scaffolding${c.r}\n\n`);
+if (yes) _(`  ${c.d}non-interactive mode${c.r}\n`);
+_(`  project   ${c.b}${name}${c.r}\n`);
+if (author) _(`  author    ${author}\n`);
+_(`  language  ${useTs ? 'TypeScript' : 'JavaScript'}\n\n`);
+
+if (existsSync(dir)) { console.error(`  ${c.y}⚠ ${name} already exists${c.r}\n`); process.exit(1); }
+
+step('Creating project'); mkdirSync(dir, { recursive: true }); ok('done');
+
+step('Copying template'); cpSync(tpl, dir, { recursive: true }); ok('done');
+
+// Write .gitignore
+const gitignore = `node_modules/\ndist/\n.yeow/dev/\n*.log\n`;
+writeFileSync(resolve(dir, '.gitignore'), gitignore);
+
+// Update package.json
+const pkg = JSON.parse(readFileSync(resolve(dir, 'package.json'), 'utf-8'));
+pkg.name = name.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '');
+if (author) pkg.author = author;
+writeFileSync(resolve(dir, 'package.json'), JSON.stringify(pkg, null, 2) + '\n');
+
+// Update yeow.config.json
+const cfg = JSON.parse(readFileSync(resolve(dir, 'yeow.config.json'), 'utf-8'));
+cfg.name = name; if (author) cfg.author = author;
+writeFileSync(resolve(dir, 'yeow.config.json'), JSON.stringify(cfg, null, 4) + '\n');
+
+// If JS, rename index.ts → index.js and update build.js
+if (!useTs) {
+    const tsFile = resolve(dir, 'src', 'index.ts');
+    const jsFile = resolve(dir, 'src', 'index.js');
+    if (existsSync(tsFile) && !existsSync(jsFile)) {
+        copy(tsFile, jsFile);
+        writeFileSync(jsFile, readFileSync(tsFile, 'utf-8').replace(/(:\s*\w+(\[\])?)\s*(?=,|\)|\n|;)/g, ''));
+    }
+    // Update build.js to use .js entry
+    const buildJs = readFileSync(resolve(dir, '.yeow', 'build.js'), 'utf-8')
+        .replace("src/index.ts", "src/index.js");
+    writeFileSync(resolve(dir, '.yeow', 'build.js'), buildJs);
+}
+
+_(`\n  ${c.g}✓${c.r} ${c.b}Done!${c.r}\n\n`);
+_(`    cd ${name}\n`);
+_(`    npm install\n`);
+_(`    npm run dev${c.d}       # start dev server${c.r}\n`);
+_(_`    npm run build${c.d}     # build plugin JAR${c.r}\n\n`);
+
+function copy(src, dest) { writeFileSync(dest, readFileSync(src)); }

package/package.json

@@ -0,0 +1,9 @@
+{
+    "name": "create-yeow",
+    "version": "0.1.0",
+    "description": "Scaffold a Yeow plugin project",
+    "type": "module",
+    "bin": { "create-yeow": "./bin/index.js" },
+    "files": ["bin/", "templates/"],
+    "license": "MIT"
+}

package/templates/default/.yeow/build.js

@@ -0,0 +1,39 @@
+import * as esbuild from 'esbuild';
+import { readFileSync, mkdirSync, existsSync, statSync } from 'fs';
+import { resolve } from 'path';
+import { fileURLToPath } from 'url';
+import AdmZip from 'adm-zip';
+
+const root = resolve(fileURLToPath(import.meta.url), '..', '..');
+const cfg = JSON.parse(readFileSync(resolve(root, 'yeow.config.json'), 'utf-8'));
+const { name, version } = cfg;
+const entry = existsSync(resolve(root, 'src', 'index.ts')) ? 'src/index.ts' : 'src/index.js';
+
+async function build() {
+    console.log(`\n  Building ${name} v${version}...\n`);
+
+    const outDir = resolve(root, 'dist', '.yeow');
+    mkdirSync(outDir, { recursive: true });
+
+    await esbuild.build({
+        entryPoints: [resolve(root, entry)],
+        outfile: resolve(outDir, 'main.js'),
+        bundle: true, format: 'iife', target: 'es2023', platform: 'neutral', treeShaking: true, minify: true,
+    });
+
+    const size = statSync(resolve(outDir, 'main.js')).size;
+    console.log(`  ✓ Bundled (${(size/1024).toFixed(1)} KB)`);
+
+    const tmplJar = resolve(root, '.yeow', 'assets', 'yeow-template-0.1.0.jar');
+    if (!existsSync(tmplJar)) { console.error('  ✗ Template JAR not found'); process.exit(1); }
+
+    const zip = new AdmZip(tmplJar);
+    zip.updateFile('plugin.yml', Buffer.from(`name: ${name}\nversion: ${version}\nmain: yeow.template.Bootstrap\napi-version: '1.21'\ndepend:\n  - Yeow-Runtime\n`));
+    zip.addFile('.yeow/main.js', readFileSync(resolve(outDir, 'main.js')));
+
+    const outJar = resolve(root, 'dist', `${name}-${version}.jar`);
+    zip.writeZip(outJar);
+    console.log(`  ✓ Packaged ${outJar}\n`);
+}
+
+build().catch(e => { console.error(e); process.exit(1); });

package/templates/default/.yeow/dev-server.js

@@ -0,0 +1,122 @@
+import { existsSync, mkdirSync, copyFileSync, writeFileSync, readFileSync, createWriteStream, statSync } from 'fs';
+import { resolve, dirname, join, basename } from 'path';
+import { spawn, execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+import https from 'https';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = resolve(__dirname, '..');
+const DEVDIR = resolve(ROOT, '.yeow', 'dev');
+const CACHE = resolve(DEVDIR, 'cache');
+const SERVER = resolve(DEVDIR, 'server');
+const PAPER = '1.21.4';
+const BUILD = '232';
+const JAR = `paper-${PAPER}-${BUILD}.jar`;
+const URL = `https://api.papermc.io/v2/projects/paper/versions/${PAPER}/builds/${BUILD}/downloads/${JAR}`;
+const CACHEJAR = resolve(CACHE, JAR);
+
+const YES = process.argv.includes('-y') || process.env.CI === 'true';
+const PROXY = process.argv.find(a => a.startsWith('--proxy='))?.split('=').slice(1).join('=');
+const STOP = (() => { const a = process.argv.find(a => a.startsWith('--stop=')); if (!a) return null; const m = a.split('=')[1].match(/^(\d+)(s|m|h)?$/); return m ? parseInt(m[1]) * (m[2]==='m'?60:m[2]==='h'?3600:1) : null; })();
+
+const cfg = JSON.parse(readFileSync(resolve(ROOT, 'yeow.config.json'), 'utf-8'));
+const RUNTIME = resolve(ROOT, '.yeow', 'assets', 'yeow-runtime-0.1.0.jar');
+
+const c = { r:'\x1b[0m',b:'\x1b[1m',d:'\x1b[2m',g:'\x1b[32m',y:'\x1b[33m',B:'\x1b[34m',C:'\x1b[36m',R:'\x1b[31m', ok: '\x1b[32m✓\x1b[0m', fail: '\x1b[31m✗\x1b[0m', info: '\x1b[36mⓘ\x1b[0m', warn: '\x1b[33m⚠\x1b[0m' };
+const log = (msg, color = '') => console.log(`${c.d}[${new Date().toLocaleTimeString()}]${c.r} ${color}${msg}${c.r}`);
+const ok = msg => log(`${c.ok} ${msg}`, c.g);
+const fail = msg => log(`${c.fail} ${msg}`, c.R);
+const info = msg => log(`${c.info} ${msg}`, c.C);
+const warn = msg => log(`${c.warn} ${msg}`, c.y);
+
+function download(url, dest, agent) {
+    return new Promise((resolve, reject) => {
+        const f = createWriteStream(dest);
+        const o = agent ? { agent } : {};
+        https.get(url, o, res => {
+            if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) { f.close(); download(res.headers.location, dest, agent).then(resolve).catch(reject); return; }
+            if (res.statusCode !== 200) { f.close(); reject(new Error(`HTTP ${res.statusCode}`)); return; }
+            const total = parseInt(res.headers['content-length'], 10);
+            let dl = 0;
+            res.on('data', c => { dl += c.length; if (total) process.stdout.write(`\r   ${c.B}Downloading...${c.r} ${(dl/1024/1024).toFixed(1)}MB / ${(total/1024/1024).toFixed(1)}MB`); });
+            res.pipe(f);
+            f.on('finish', () => { f.close(); process.stdout.write('\n'); resolve(); });
+        }).on('error', e => { f.close(); reject(e); });
+    });
+}
+
+async function ensurePaper() {
+    if (existsSync(CACHEJAR) && statSync(CACHEJAR).size > 1_000_000) { ok('Paper found in cache'); return; }
+    mkdirSync(CACHE, { recursive: true });
+    let agent = null;
+    if (PROXY) { info(`Proxy: ${PROXY}`); try { const { HttpsProxyAgent } = await import('https-proxy-agent'); agent = new HttpsProxyAgent(PROXY); } catch {} }
+    info('Downloading Paper...');
+    try { await download(URL, CACHEJAR, agent); ok('Paper downloaded'); }
+    catch (e) { fail('Download failed: ' + e.message); console.log('  Manually: ' + CACHEJAR); process.exit(1); }
+}
+
+function buildPlugin() {
+    info('Building plugin...');
+    try { execSync('node .yeow/build.js', { cwd: ROOT, stdio: 'inherit' }); ok('Plugin built'); }
+    catch (e) { fail('Build failed: ' + e.message); process.exit(1); }
+}
+
+function copyToPlugins(src, label) {
+    const d = resolve(SERVER, 'plugins'); mkdirSync(d, { recursive: true });
+    copyFileSync(src, resolve(d, basename(src))); ok(`${label} copied`);
+}
+
+async function initServer() {
+    const jar = resolve(SERVER, JAR);
+    if (!existsSync(jar)) copyFileSync(CACHEJAR, jar);
+    const eula = resolve(SERVER, 'eula.txt');
+    if (existsSync(eula) && readFileSync(eula, 'utf-8').includes('eula=true')) return;
+
+    if (YES) {
+        if (!existsSync(resolve(SERVER, 'server.properties'))) {
+            info('Initializing...');
+            await new Promise(r => { const p = spawn('java', ['-Xmx4G','-Xms4G','-jar',jar,'--nogui'], { cwd: SERVER, stdio: ['pipe','inherit','inherit'] }); setTimeout(() => { p.kill(); r(); }, 120000); p.on('exit', r); p.on('error', r); });
+        }
+        writeFileSync(eula, 'eula=true\n'); ok('EULA auto-accepted');
+    } else {
+        console.log(`   Press Enter to accept EULA...`);
+        await new Promise(r => process.stdin.once('data', () => { writeFileSync(eula, 'eula=true\n'); ok('EULA accepted'); r(); }));
+    }
+}
+
+function serverProps(port) {
+    const f = resolve(SERVER, 'server.properties');
+    const m = { 'server-port': String(port), 'online-mode': 'false', 'spawn-protection': '0', 'enable-command-block': 'true', 'max-players': '10', 'difficulty': 'easy', 'motd': cfg.name || 'Yeow Dev' };
+    if (existsSync(f)) {
+        for (const l of readFileSync(f, 'utf-8').split('\n')) { const eq = l.indexOf('='); if (eq > 0 && !l.startsWith('#')) { const k = l.substring(0, eq).trim(); if (!m[k]) m[k] = l.substring(eq + 1).trim(); } }
+    }
+    let out = ''; for (const [k, v] of Object.entries(m)) out += `${k}=${v}\n`;
+    writeFileSync(f, out);
+}
+
+let proc = null;
+function startServer() {
+    info(`\nStarting Paper ${PAPER} server...`);
+    proc = spawn('java', ['-Xmx4G', '-Xms4G', '-jar', resolve(SERVER, JAR), '--nogui'], { cwd: SERVER, stdio: ['pipe', 'inherit', 'inherit'] });
+    proc.on('exit', code => { warn(`Server exited (${code})`); process.exit(0); });
+    process.stdin.on('data', d => { if (proc && !proc.killed) proc.stdin.write(d); });
+    if (STOP) { info(`Auto-stop in ${STOP}s`); setTimeout(() => { warn('Auto-stop'); if (proc && !proc.killed) proc.stdin.write('stop\n'); setTimeout(() => { if (proc && !proc.killed) proc.kill(); process.exit(0); }, 10000); }, STOP * 1000); }
+}
+
+async function main() {
+    console.log(`\n${c.b}${c.B}  Yeow Dev Server${c.r}\n`);
+    if (!existsSync(RUNTIME)) { fail(`Runtime JAR not found: ${RUNTIME}`); process.exit(1); }
+
+    await ensurePaper();
+    mkdirSync(SERVER, { recursive: true });
+    await initServer();
+    serverProps(cfg.dev?.port || 17367);
+    buildPlugin();
+    copyToPlugins(resolve(ROOT, 'dist', `${cfg.name}-${cfg.version}.jar`), 'Plugin');
+    copyToPlugins(RUNTIME, 'Runtime');
+
+    startServer();
+}
+
+process.on('SIGINT', () => { if (proc) { proc.stdin.write('stop\n'); setTimeout(() => { if (proc && !proc.killed) proc.kill(); process.exit(0); }, 5000); } });
+main().catch(e => { fail(e.message); process.exit(1); });

package/templates/default/package.json

@@ -0,0 +1,16 @@
+{
+    "name": "my-yeow-plugin",
+    "version": "1.0.0",
+    "scripts": {
+        "build": "node .yeow/build.js",
+        "dev": "node .yeow/dev-server.js"
+    },
+    "dependencies": {
+        "yeow-api": "^0.1.0"
+    },
+    "devDependencies": {
+        "esbuild": "^0.25.0",
+        "adm-zip": "^0.5.0",
+        "https-proxy-agent": "^9.0.0"
+    }
+}

package/templates/default/src/index.ts

@@ -0,0 +1,32 @@
+import { Player, World, registerCommand, eventOn, broadcastSync, fs, path } from 'yeow-api';
+
+// ── Commands ────────────────────────
+registerCommand('hello', {
+    description: 'Say hello',
+    executor: (p) => p.sender.sendMessage(`Hello, ${p.args[0] || 'World'}!`),
+});
+
+registerCommand('ping', {
+    description: 'Check your ping',
+    executor: (p) => {
+        const player = Player.get(p.sender.uuid);
+        if (player) p.sender.sendMessage(`Ping: ${player.ping}ms`);
+    },
+});
+
+// ── Events ──────────────────────────
+eventOn('playerJoin', (e) => {
+    const player = Player.get(e.player);
+    if (player) player.sendMessageSync(`Welcome, ${player.displayName}!`);
+});
+
+eventOn('blockBreak', (e) => {
+    if (e.block === 'minecraft:bedrock') e.cancelled = true;
+});
+
+// ── Startup ─────────────────────────
+const world = World.get('world');
+if (world) {
+    console.log(`[init] World: ${world.name} | Time: ${world.time} | Difficulty: ${world.difficulty}`);
+    console.log(`[init] Plugin ready`);
+}

package/templates/default/tsconfig.json

@@ -0,0 +1,12 @@
+{
+    "compilerOptions": {
+        "target": "ES2023",
+        "module": "ES2022",
+        "moduleResolution": "bundler",
+        "strict": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "noEmit": true
+    },
+    "include": ["src/**/*.ts"]
+}

package/templates/default/yeow.config.json

@@ -0,0 +1,10 @@
+{
+    "name": "my-yeow-plugin",
+    "version": "1.0.0",
+    "author": "Unknown",
+    "description": "A Yeow plugin",
+    "dev": {
+        "port": 17367,
+        "memory": "4G"
+    }
+}