create-yeow 0.2.64 → 0.2.65

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "create-yeow",
-    "version": "0.2.64",
+    "version": "0.2.65",
     "description": "Scaffold a Yeow plugin project",
     "type": "module",
     "bin": {

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

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, copyFileSync, writeFileSync, readFileSync, createWriteStream, statSync, watch, readdirSync } from 'fs';
+import { existsSync, mkdirSync, copyFileSync, writeFileSync, readFileSync, createWriteStream, statSync, watch, readdirSync, rmSync } from 'fs';
 import { resolve, dirname, basename } from 'path';
 import { spawn, execSync } from 'child_process';
 import { fileURLToPath } from 'url';
@@ -12,11 +12,6 @@ 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://fill-data.papermc.io/v1/objects/5ee4f542f628a14c644410b08c94ea42e772ef4d29fe92973636b6813d4eaffc/paper-1.21.4-232.jar`;
-const CACHEJAR = resolve(CACHE, JAR);
 const WS_PORT = 17368;
 
 const YES = process.argv.includes('-y') || process.env.CI === 'true';
@@ -26,6 +21,50 @@ const STOP = (() => { const a = process.argv.find(a => a.startsWith('--stop='));
 const cfg = JSON.parse(readFileSync(resolve(ROOT, 'yeow.config.json'), 'utf-8'));
 const RUNTIME = resolve(ROOT, '.yeow', 'assets', 'yeow-runtime-0.1.0.jar');
 
+// Dev server config (optional, from yeow.config.json)
+const devCfg = cfg.dev || {};
+const PAPER_VERSION = devCfg.paperVersion || '1.21.4';
+const PAPER_URL = devCfg.paperJar || null;
+let PAPER_PATH = null;
+let PAPER_JAR = null;
+
+if (PAPER_URL) {
+  if (PAPER_URL.startsWith('http://') || PAPER_URL.startsWith('https://')) {
+    PAPER_PATH = resolve(CACHE, basename(new URL(PAPER_URL).pathname));
+    PAPER_JAR  = basename(new URL(PAPER_URL).pathname);
+  } else {
+    PAPER_PATH = PAPER_URL;
+    PAPER_JAR  = basename(PAPER_URL);
+  }
+} else {
+  PAPER_JAR  = `paper-${PAPER_VERSION}.jar`;
+  PAPER_PATH = resolve(CACHE, PAPER_JAR);
+}
+
+// Config hash — detect changes and recreate dev server
+const CONFIG_HASH_FILE = resolve(DEVDIR, '.config-hash');
+function configHash() { return JSON.stringify({ paperUrl: PAPER_URL, paperVersion: PAPER_VERSION }); }
+
+function checkConfigChanged() {
+  if (!existsSync(CONFIG_HASH_FILE)) return true;
+  try {
+    return readFileSync(CONFIG_HASH_FILE, 'utf-8').trim() !== configHash();
+  } catch { return true; }
+}
+
+function saveConfigHash() {
+  mkdirSync(DEVDIR, { recursive: true });
+  writeFileSync(CONFIG_HASH_FILE, configHash());
+}
+
+if (checkConfigChanged()) {
+  if (existsSync(SERVER)) {
+    console.log('  Paper config changed — recreating dev server...');
+    rmSync(SERVER, { recursive: true, force: true });
+  }
+  saveConfigHash();
+}
+
 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);
@@ -36,6 +75,29 @@ const warn = msg => log(`${c.warn} ${msg}`, c.y);
 let proc = null;
 let wss = null;
 
+// ── Graceful shutdown ────────────────────────────────────────────
+function cleanup() {
+  if (proc && !proc.killed) {
+    try { proc.stdin.write('stop\n'); } catch {}
+    setTimeout(() => { if (proc && !proc.killed) try { proc.kill(); } catch {} }, 5000);
+  }
+  if (wss) { try { wss.close(); } catch {} }
+  process.exit(0);
+}
+process.on('SIGINT', cleanup);
+process.on('SIGTERM', cleanup);
+process.on('exit', () => { if (proc && !proc.killed) try { proc.kill(); } catch {} });
+// Windows Ctrl+C in terminal
+if (process.platform === 'win32') {
+  import('readline').then(rl => {
+    rl.emitKeypressEvents(process.stdin);
+    if (process.stdin.isTTY) process.stdin.setRawMode(true);
+    process.stdin.on('keypress', (str, key) => {
+      if ((key.ctrl && key.name === 'c') || key.name === 'escape') cleanup();
+    });
+  });
+}
+
 // ── WebSocket Server ────────────────────────────────────────────
 function startWebSocket() {
     const server = createServer();
@@ -83,13 +145,38 @@ function download(url, dest, agent) {
 }
 
 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); }
+    if (PAPER_URL) {
+        // User-specified URL or file path
+        if (PAPER_URL.startsWith('http://') || PAPER_URL.startsWith('https://')) {
+            if (existsSync(PAPER_PATH) && statSync(PAPER_PATH).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(PAPER_URL, PAPER_PATH, agent); ok('Paper downloaded'); }
+            catch (e) { fail('Download failed: ' + e.message); console.log('  Manually: ' + PAPER_PATH); process.exit(1); }
+        } else {
+            if (!existsSync(PAPER_PATH)) { fail(`Paper JAR not found: ${PAPER_PATH}`); process.exit(1); }
+            ok('Paper found at specified path');
+        }
+    } else {
+        if (existsSync(PAPER_PATH) && statSync(PAPER_PATH).size > 1_000_000) { ok('Paper found in cache'); return; }
+        mkdirSync(CACHE, { recursive: true });
+        info('Downloading Paper...');
+        try {
+            const apiUrl = `https://api.papermc.io/v2/projects/paper/versions/${PAPER_VERSION}`;
+            const versions = await fetch(apiUrl).then(r => r.json());
+            const latestBuild = versions.builds[versions.builds.length - 1];
+            const dlUrl = `https://api.papermc.io/v2/projects/paper/versions/${PAPER_VERSION}/builds/${latestBuild}/downloads/paper-${PAPER_VERSION}-${latestBuild}.jar`;
+            await download(dlUrl, PAPER_PATH, null);
+            ok('Paper downloaded');
+        } catch (e) {
+            fail('Download failed: ' + e.message);
+            console.log('  Manually download to: ' + PAPER_PATH);
+            console.log('  Or set "paperJar" in yeow.config.json dev section');
+            process.exit(1);
+        }
+    }
 }
 
 function buildPlugin() {
@@ -104,8 +191,8 @@ function copyToPlugins(src, label) {
 }
 
 async function initServer() {
-    const jar = resolve(SERVER, JAR);
-    if (!existsSync(jar)) copyFileSync(CACHEJAR, jar);
+    const jar = resolve(SERVER, PAPER_JAR);
+    if (!existsSync(jar)) copyFileSync(PAPER_PATH, jar);
     const eula = resolve(SERVER, 'eula.txt');
     if (existsSync(eula) && readFileSync(eula, 'utf-8').includes('eula=true')) return;
 
@@ -157,7 +244,7 @@ function startHotReload() {
                         codeFile: compiled.replace(/\\/g, '/'),
                         assetsDir: existsSync(assetsDir) ? assetsDir.replace(/\\/g, '/') : null,
                     });
-                    _consumer = null; // invalidate stale source-map cache
+                    _consumer = null;
                     ok('Hot reload sent via WebSocket');
                 }
             } catch (e) {
@@ -168,13 +255,11 @@ function startHotReload() {
         }, 300);
     };
 
-    // Watch src/ for changes
     watch(srcDir, { recursive: true }, (event, file) => {
         if (!file || !file.endsWith('.' + ext)) return;
         rebuildAndNotify();
     });
 
-    // Watch assets/ for changes
     if (existsSync(assetsDir)) {
         watch(assetsDir, { recursive: true }, (event, file) => {
             rebuildAndNotify();
@@ -203,7 +288,6 @@ async function printFormattedError(err) {
     if (err.context) out += `  ${c.D}context: ${err.context}${c.r}\n`;
     out += `  ${c.Y}${err.message}${c.r}\n`;
 
-    // Check if stack contains any main.js frames — if so, load source-map consumer
     const hasMainJs = err.stack?.match(/main\.js:\d+:\d+/) || err.fileName === 'main.js';
     let consumer = null;
     if (hasMainJs) {
@@ -214,7 +298,6 @@ async function printFormattedError(err) {
         out += `  ${c.D}(source-map not found: ${existsSync(mapFile) ? 'exists but failed to parse' : 'missing at ' + mapFile})${c.r}\n`;
     }
 
-    // Resolve all stack frames
     const frames = [];
     if (err.stack) {
         for (const rawLine of err.stack.split('\n')) {
@@ -222,7 +305,6 @@ async function printFormattedError(err) {
             if (m && consumer) {
                 const orig = consumer.originalPositionFor({ line: parseInt(m[1]), column: parseInt(m[2]) });
                 if (!orig?.source) {
-                    // Try adjusted column
                     const orig2 = consumer.originalPositionFor({ line: parseInt(m[1]), column: parseInt(m[2]) - 1 });
                     if (orig2?.source) { orig.source = orig2.source; orig.line = orig2.line; orig.column = orig2.column; }
                 }
@@ -233,13 +315,10 @@ async function printFormattedError(err) {
         }
     }
 
-    // Find first frame from user's src/ directory (not node_modules)
     let ctxFrame = frames.find(f => f.orig?.source?.match(/[\\/]src[\\/]/) && !f.orig.source.includes('node_modules'))?.orig || null;
 
-    // Show context for the chosen frame
     if (ctxFrame?.source && ctxFrame.line && consumer) {
         const srcPath = ctxFrame.source.replace(/^\.\.\/\.\.\//, '');
-        // Preserve function name
         const ctxRaw = frames.find(f => f.orig === ctxFrame)?.raw || '';
         const fnM = ctxRaw.match(/at\s+(\S+)\s+\(/);
         const fnS = fnM ? fnM[1] + ' ' : '';
@@ -262,7 +341,6 @@ async function printFormattedError(err) {
         }
     }
 
-    // Print resolved stack (all frames)
     if (frames.length > 0) {
         out += `  ${c.D}Stack:${c.r}\n`;
         for (const f of frames) {
@@ -284,11 +362,10 @@ async function printFormattedError(err) {
 
 function startServer() {
     const jvmArgs = ['-Xmx4G', '-Xms4G', '-Dyeow.dev=true', '-Dyeow.ws.port=' + WS_PORT];
-    info(`\nStarting Paper ${PAPER} server...`);
-    proc = spawn('java', [...jvmArgs, '-jar', resolve(SERVER, JAR), '--nogui'], { cwd: SERVER, stdio: ['pipe', 'inherit', 'inherit'] });
+    info(`\nStarting Paper ${PAPER_VERSION} server...`);
+    proc = spawn('java', [...jvmArgs, '-jar', resolve(SERVER, PAPER_JAR), '--nogui'], { cwd: SERVER, stdio: ['pipe', 'inherit', 'inherit'] });
     proc.on('exit', code => { warn(`Server exited (${code})`); if (wss) wss.close(); 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); }
+    if (STOP) { info(`Auto-stop in ${STOP}s`); setTimeout(() => { warn('Auto-stop'); cleanup(); }, STOP * 1000); }
 }
 
 async function main() {
@@ -308,5 +385,4 @@ async function main() {
     startServer();
 }
 
-process.on('SIGINT', () => { if (proc) { proc.stdin.write('stop\n'); setTimeout(() => { if (proc && !proc.killed) proc.kill(); if (wss) wss.close(); process.exit(0); }, 5000); } });
 main().catch(e => { fail(e.message); process.exit(1); });

package/templates/default/package.json

@@ -7,7 +7,7 @@
         "dev": "node .yeow/dev-server.js"
     },
     "dependencies": {
-        "yeow-api": "^0.2.48",
+        "yeow-api": "^0.2.51",
         "yeow-utils": "^0.1.13"
     },
     "devDependencies": {

package/templates/default/src/index.js

@@ -1,27 +1,55 @@
-import { onInit, onLoad, registerCommand, broadcast, eventOn, Player } from 'yeow-api';
+import {
+  onInit, onLoad, onUnload, registerCommand, eventOn,
+  Player, Location, pdcSet, pdcGet, log,
+} from 'yeow-api';
 
-onInit(() => { console.log('[init] Plugin loaded'); });
-onLoad(() => { console.log('[load] Ready'); });
+onInit(() => { log.info('Init'); });
+onLoad(() => { log.info('Ready'); });
 
 onLoad(() => {
-    registerCommand('hello', {
-        executor: async (p) => {
-            p.sender.sendMessage(`Hello, ${p.args[0] || 'World'}!`);
-        },
-    });
-
-    registerCommand('ping', {
-        executor: async (p) => {
-            const player = Player.get(p.sender.uuid);
-            if (player) p.sender.sendMessage(`Ping: ${player.ping}ms`);
-        },
-    });
-
-    eventOn('playerJoin', (e) => {
-        broadcast(e.joinMessage);
-    });
-
-    eventOn('blockBreak', (e) => {
-        if (e.block === 'minecraft:bedrock') e.cancelled = true;
-    });
+  // ── /back: 返回死亡位置 ──
+  eventOn('playerDeath', async (e) => {
+    const loc = e.player.location;
+    if (!loc) return;
+    const data = JSON.stringify({ x: loc.x, y: loc.y, z: loc.z, world: loc.world || e.player.world });
+    pdcSet(e.player.uuid, 'back.deathLocation', data);
+    await e.player.sendMessage(
+      '<red>You died!</red> <gray>Use</gray> <click:run_command:/back><aqua><u>/back</u></aqua></click> <gray>to return</gray>',
+    );
+  });
+
+  registerCommand('back', {
+    description: 'Teleport to your death location',
+    executor: async (p) => {
+      const raw = await pdcGet(p.sender.uuid, 'back.deathLocation');
+      if (!raw) return p.sender.sendMessage('<red>No death location recorded</red>');
+
+      const loc = JSON.parse(raw);
+      const player = await Player.get(p.sender.uuid);
+      if (!player) return;
+      await player.teleport(new Location(loc.x, loc.y, loc.z, 0, 0, loc.world));
+      p.sender.sendMessage('<green>Teleported to death location</green>');
+    },
+  });
+
+  // ── /ping ──
+  registerCommand('ping', {
+    executor: async (p) => {
+      const player = await Player.get(p.sender.uuid);
+      if (player) p.sender.sendMessage(`Ping: ${player.ping}ms`);
+    },
+  });
+
+  // ── 事件 ──
+  eventOn('playerJoin', (e) => {
+    log.info(`${e.player.name} joined`);
+  });
+
+  eventOn('blockBreak', (e) => {
+    if (e.block === 'minecraft:bedrock') e.cancelled = true;
+  });
+});
+
+onUnload(() => {
+  log.info('Unloaded');
 });

package/templates/default/src/index.ts

@@ -1,28 +1,56 @@
-import { onInit, onLoad, registerCommand, broadcast, eventOn, Player } from 'yeow-api';
-import type { PlayerJoinEvent, BlockBreakEvent } from 'yeow-api';
+import {
+  onInit, onLoad, onUnload, registerCommand, eventOn,
+  Player, Location, pdcSet, pdcGet, log,
+} from 'yeow-api';
+import type { PlayerDeathEvent } from 'yeow-api';
 
-onInit(() => { console.log('[init] Plugin loaded'); });
-onLoad(() => { console.log('[load] Ready'); });
+onInit(() => { log.info('Init'); });
+onLoad(() => { log.info('Ready'); });
 
 onLoad(() => {
-    registerCommand('hello', {
-        executor: async (p) => {
-            p.sender.sendMessage(`Hello, ${p.args[0] || 'World'}!`);
-        },
-    });
-
-    registerCommand('ping', {
-        executor: async (p) => {
-            const player = Player.get(p.sender.uuid);
-            if (player) p.sender.sendMessage(`Ping: ${player.ping}ms`);
-        },
-    });
-
-    eventOn('playerJoin', (e: PlayerJoinEvent) => {
-        broadcast(e.joinMessage);
-    });
-
-    eventOn('blockBreak', (e: BlockBreakEvent) => {
-        if (e.block === 'minecraft:bedrock') e.cancelled = true;
-    });
+  // ── /back: 返回死亡位置 ──
+  eventOn('playerDeath', async (e: PlayerDeathEvent) => {
+    const loc = e.player.location;
+    if (!loc) return;
+    const data = JSON.stringify({ x: loc.x, y: loc.y, z: loc.z, world: loc.world || e.player.world });
+    pdcSet(e.player.uuid, 'back.deathLocation', data);
+    await e.player.sendMessage(
+      '<red>You died!</red> <gray>Use</gray> <click:run_command:/back><aqua><u>/back</u></aqua></click> <gray>to return</gray>',
+    );
+  });
+
+  registerCommand('back', {
+    description: 'Teleport to your death location',
+    executor: async (p) => {
+      const raw = await pdcGet(p.sender.uuid, 'back.deathLocation');
+      if (!raw) return p.sender.sendMessage('<red>No death location recorded</red>');
+
+      const loc = JSON.parse(raw);
+      const player = await Player.get(p.sender.uuid);
+      if (!player) return;
+      await player.teleport(new Location(loc.x, loc.y, loc.z, 0, 0, loc.world));
+      p.sender.sendMessage('<green>Teleported to death location</green>');
+    },
+  });
+
+  // ── /ping ──
+  registerCommand('ping', {
+    executor: async (p) => {
+      const player = await Player.get(p.sender.uuid);
+      if (player) p.sender.sendMessage(`Ping: ${player.ping}ms`);
+    },
+  });
+
+  // ── 事件 ──
+  eventOn('playerJoin', (e) => {
+    log.info(`${e.player.name} joined`);
+  });
+
+  eventOn('blockBreak', (e) => {
+    if (e.block === 'minecraft:bedrock') e.cancelled = true;
+  });
+});
+
+onUnload(() => {
+  log.info('Unloaded');
 });