creepercli 1.0.0

package/src/commands/index.js

@@ -0,0 +1,139 @@
+/*
+ * Copyright 2026 DemonZDevelopment
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+'use strict';
+
+const fsCmds = require('./fs');
+const searchCmds = require('./search');
+const execCmds = require('./exec');
+const monitorCmds = require('./monitor');
+const authCmds = require('./auth');
+const { cpush, cpull, csync } = require('../transfer');
+const { friendly } = require('../protocol');
+
+const COMMANDS = [
+  { name: 'pwd', run: fsCmds.pwd, desc: 'Print working directory' },
+  { name: 'ls', run: fsCmds.ls, desc: 'List directory (flags: -l, -a)' },
+  { name: 'cd', run: fsCmds.cd, desc: 'Change directory' },
+  { name: 'tree', run: fsCmds.tree, desc: 'Show directory tree (flag: --depth N)' },
+  { name: 'cat', run: fsCmds.cat, desc: 'Print file contents' },
+  { name: 'head', run: fsCmds.head, desc: 'Print first lines of a file (-n N)' },
+  { name: 'tail', run: fsCmds.tail, desc: 'Print last lines of a file (-n N)' },
+  { name: 'wc', run: fsCmds.wc, desc: 'Count lines/words/chars of a file' },
+  { name: 'touch', run: fsCmds.touch, desc: 'Create or update a file' },
+  { name: 'mkdir', run: fsCmds.mkdir, desc: 'Create directory (flag: -p)' },
+  { name: 'rm', run: fsCmds.rm, desc: 'Remove file/directory (flag: -r)' },
+  { name: 'cp', run: fsCmds.cp, desc: 'Copy file/directory (flag: -r)' },
+  { name: 'mv', run: fsCmds.mv, desc: 'Move/rename a file' },
+  { name: 'info', run: fsCmds.info, desc: 'Show file info (perms, size, mtime)' },
+  { name: 'edit', run: fsCmds.edit, desc: 'Edit a remote file in your local $EDITOR' },
+  { name: 'grep', run: searchCmds.grep, desc: 'Search file contents (flags: -i, --max-depth N)' },
+  { name: 'find', run: searchCmds.find, desc: 'Find files by glob (flag: --glob "**/*.jar")' },
+  { name: 'exec', run: execCmds.exec, desc: 'Run a Minecraft console command (allowlisted)' },
+  { name: 'say', run: execCmds.say, desc: 'Shortcut for "exec say ..."' },
+  { name: 'restart', run: execCmds.restart, desc: 'Shortcut for "exec restart"' },
+  { name: 'stats', run: monitorCmds.stats, desc: 'Server CPU/RAM/disk stats' },
+  { name: 'tps', run: monitorCmds.tps, desc: 'Server TPS (1m/5m/15m)' },
+  { name: 'log', run: monitorCmds.log, desc: 'Follow the server console (flag: --grep <regex>)' },
+  { name: 'top', run: monitorCmds.top, desc: 'Live dashboard (q to quit)' },
+  { name: 'cpush', run: cpush, desc: 'Upload a local file to the server' },
+  { name: 'cpull', run: cpull, desc: 'Download a server file locally' },
+  { name: 'csync', run: csync, desc: 'Synchronize local/remote directories (flag: --yes)' },
+  { name: 'login', run: authCmds.login, desc: 'Authenticate and store a session token' },
+  { name: 'logout', run: authCmds.logout, desc: 'Invalidate session and clear local credentials' },
+  { name: 'passwd', run: authCmds.passwd, desc: 'Change your password' },
+  { name: 'totp', run: authCmds.totp, desc: 'Manage 2FA: totp setup | totp disable' },
+  { name: 'whoami', run: authCmds.whoami, desc: 'Show current session info' },
+  { name: 'ping', run: authCmds.ping, desc: 'Check server connectivity' },
+  { name: 'help', run: help, desc: 'Show this help' },
+  { name: 'exit', run: exitCmd, desc: 'Leave the REPL' },
+  { name: 'quit', run: exitCmd, desc: 'Leave the REPL' },
+  { name: 'q', run: exitCmd, desc: 'Leave the REPL' },
+];
+
+function find(name) {
+  return COMMANDS.find((c) => c.name === name);
+}
+
+function splitArgs(input) {
+  const args = [];
+  let cur = '';
+  let quote = null;
+  let escaped = false;
+  for (const ch of input) {
+    if (escaped) {
+      cur += ch;
+      escaped = false;
+    } else if (ch === '\\') {
+      escaped = true;
+    } else if (quote) {
+      if (ch === quote) quote = null;
+      else cur += ch;
+    } else if (ch === '"' || ch === "'") {
+      quote = ch;
+    } else if (/\s/.test(ch)) {
+      if (cur) {
+        args.push(cur);
+        cur = '';
+      }
+    } else {
+      cur += ch;
+    }
+  }
+  if (escaped) cur += '\\';
+  if (cur) args.push(cur);
+  return args;
+}
+
+async function runCommand(ctx, input) {
+  let trimmed = input.trim();
+  if (!trimmed || trimmed.startsWith('#')) return 0;
+  
+  // Automatically strip redundant "creepercli" or "creepercli.exe" prefix if typed inside the REPL
+  if (trimmed.startsWith('creepercli.exe ')) {
+    trimmed = trimmed.slice(15).trim();
+  } else if (trimmed.startsWith('creepercli ')) {
+    trimmed = trimmed.slice(11).trim();
+  }
+
+  const args = splitArgs(trimmed);
+  const cmd = find(args[0]);
+  if (!cmd) {
+    console.error(`Unknown command: ${args[0]} (try "help")`);
+    return 1;
+  }
+  try {
+    const rc = await cmd.run(ctx, args.slice(1));
+    return rc == null ? 0 : rc;
+  } catch (err) {
+    console.error(`Error: ${friendly(err)}`);
+    return 1;
+  }
+}
+
+function help() {
+  const width = Math.max(...COMMANDS.map((c) => c.name.length)) + 2;
+  for (const c of COMMANDS) {
+    console.log(c.name.padEnd(width) + c.desc);
+  }
+}
+
+function exitCmd(ctx) {
+  ctx.exit = true;
+  return 0;
+}
+
+module.exports = { COMMANDS, find, splitArgs, runCommand, help };

package/src/commands/monitor.js

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2026 DemonZDevelopment
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+'use strict';
+
+const { formatStats, formatTps } = require('../formatters');
+const { runTop } = require('../top');
+const { EVENT_LOG_LINE } = require('../protocol');
+
+async function stats(ctx) {
+  const res = await ctx.client.request('monitor.stats');
+  console.log(formatStats(res));
+}
+
+async function tps(ctx) {
+  const res = await ctx.client.request('monitor.tps');
+  console.log(formatTps(res));
+}
+
+async function top(ctx) {
+  await runTop(ctx.client, ctx.cfg.topRefreshMs);
+}
+
+async function log(ctx, args) {
+  let grep = null;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--grep') grep = args[++i];
+    else if (args[i].startsWith('--grep=')) grep = args[i].slice(7);
+  }
+  const res = await ctx.client.request('monitor.log.start', { grep });
+  console.log(`Streaming console log (Ctrl+C to stop)${res.grep ? ' filtered by "' + res.grep + '"' : ''}`);
+  if (res.buffer && res.buffer.length) console.log(res.buffer.join('\n'));
+  let stop = null;
+  try {
+    await new Promise((resolve) => {
+      const onLine = (event, data) => {
+        if (event === EVENT_LOG_LINE) console.log(data.message);
+      };
+      ctx.client.on('event', onLine);
+      stop = () => {
+        ctx.client.removeListener('event', onLine);
+        ctx.client.request('monitor.log.stop').catch(() => {});
+        resolve();
+      };
+      process.once('SIGINT', stop);
+      ctx.interruptHandler = stop;
+    });
+  } finally {
+    if (stop) {
+      process.removeListener('SIGINT', stop);
+      if (ctx.interruptHandler === stop) ctx.interruptHandler = null;
+    }
+  }
+}
+
+module.exports = { stats, tps, top, log };

package/src/commands/search.js

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2026 DemonZDevelopment
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+'use strict';
+
+const { formatMatches } = require('../formatters');
+
+async function grep(ctx, args) {
+  const opts = {
+    caseInsensitive: false,
+    recursive: true,
+    lineNumbers: true,
+    maxDepth: 6,
+    maxResults: 1000,
+  };
+  const rest = [];
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === '-i' || a === '--ignore-case') opts.caseInsensitive = true;
+    else if (a === '-r' || a === '-R' || a === '--recursive') opts.recursive = true;
+    else if (a === '-n' || a === '--line-number') opts.lineNumbers = true;
+    else if (a === '--max-depth') opts.maxDepth = parseInt(args[++i], 10) || 6;
+    else if (a === '--max-results') opts.maxResults = parseInt(args[++i], 10) || 1000;
+    else rest.push(a);
+  }
+  const pattern = rest[0];
+  const path = rest[1] || '.';
+  if (!pattern) throw new Error('Usage: grep [options] <pattern> [path]');
+  const res = await ctx.client.request('fs.grep', { path, pattern, ...opts });
+  if (!res.matches.length) {
+    console.log('No matches');
+    return;
+  }
+  console.log(formatMatches(res.matches));
+  if (res.truncated) console.error(`(truncated at ${res.matches.length} matches)`);
+}
+
+async function find(ctx, args) {
+  let glob = '*';
+  let path = '.';
+  let maxDepth = 12;
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === '--glob' || a === '-g') glob = args[++i] || '*';
+    else if (a === '--max-depth') maxDepth = parseInt(args[++i], 10) || 12;
+    else path = a;
+  }
+  const res = await ctx.client.request('fs.find', { path, glob, maxDepth });
+  if (!res.results.length) {
+    console.log('No matches');
+    return;
+  }
+  console.log(res.results.join('\n'));
+  if (res.truncated) console.error('(truncated)');
+}
+
+module.exports = { grep, find };

package/src/config.js

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2026 DemonZDevelopment
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { DIR, HISTORY_FILE } = require('./session');
+
+const CONFIG_FILE = path.join(DIR, 'config.json');
+
+const DEFAULTS = {
+  host: '127.0.0.1',
+  port: 45678,
+  editor: process.env.EDITOR || 'vi',
+  topRefreshMs: 2000,
+};
+
+function load() {
+  let file = {};
+  try {
+    file = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+  } catch {
+  }
+  const cfg = { ...DEFAULTS, ...file };
+  cfg.historyFile = HISTORY_FILE;
+  return cfg;
+}
+
+function save(newConfig) {
+  try {
+    fs.mkdirSync(DIR, { recursive: true, mode: 0o700 });
+    const existing = load();
+    const updated = { ...existing, ...newConfig };
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(updated, null, 2), { mode: 0o600 });
+  } catch {
+  }
+}
+
+function applyFlags(cfg, flags) {
+  if (flags.host) cfg.host = flags.host;
+  if (flags.port) cfg.port = flags.port;
+  if (flags.editor) cfg.editor = flags.editor;
+  if (flags.refresh) cfg.topRefreshMs = flags.refresh;
+  return cfg;
+}
+
+module.exports = { load, save, applyFlags, CONFIG_FILE, DEFAULTS };

package/src/editor.js

@@ -0,0 +1,98 @@
+/*
+ * Copyright 2026 DemonZDevelopment
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { spawn } = require('child_process');
+const { DIR } = require('./session');
+
+function sha256(content) {
+  return crypto.createHash('sha256').update(content).digest('hex');
+}
+
+async function editFile(ctx, remotePath) {
+  if (!remotePath) throw new Error('Usage: edit <path>');
+  const tmpRoot = path.join(DIR, 'tmp');
+  fs.mkdirSync(tmpRoot, { recursive: true, mode: 0o700 });
+  const tmpDir = fs.mkdtempSync(path.join(tmpRoot, 'edit-'));
+  const localName = remotePath.split('/').pop() || 'file';
+  const tmpFile = path.join(tmpDir, localName);
+
+  try {
+    await ctx.client.request('fs.edit.lock', { path: remotePath });
+  } catch (err) {
+    if (err.code === 'E_LOCKED') {
+      console.error(`Locked: ${err.message}`);
+      return 1;
+    }
+    throw err;
+  }
+
+  try {
+    const cat = await ctx.client.request('fs.cat', { path: remotePath });
+    fs.writeFileSync(tmpFile, cat.content, { mode: 0o600 });
+
+    const editor = ctx.cfg.editor;
+    const parts = (editor.match(/"[^"]+"|'[^']+'|\S+/g) || []).map((p) => {
+      if ((p.startsWith('"') && p.endsWith('"')) || (p.startsWith("'") && p.endsWith("'"))) {
+        return p.slice(1, -1);
+      }
+      return p;
+    });
+    const execName = parts[0] || editor;
+    const args = parts.slice(1);
+    await new Promise((resolve, reject) => {
+      const child = spawn(execName, [...args, tmpFile], { stdio: 'inherit' });
+      child.on('error', (err) => reject(new Error(`Could not start editor "${editor}": ${err.message}`)));
+      child.on('close', (code) => (code === 0 ? resolve() : reject(new Error(`Editor exited with code ${code}`))));
+    });
+
+    const newContent = fs.readFileSync(tmpFile, 'utf8');
+    if (newContent === cat.content) {
+      console.log('No changes.');
+      return 0;
+    }
+    const res = await ctx.client.request('fs.edit.push', {
+      path: remotePath,
+      content: newContent,
+      sha256: sha256(newContent),
+    });
+    const diff = summarizeDiff(cat.content.split('\n'), newContent.split('\n'));
+    console.log(`Pushed ${res.bytes} bytes to ${res.path} (+${diff.added}/-${diff.removed} lines)`);
+    return 0;
+  } catch (err) {
+    console.error(`Edit failed: ${err.message}`);
+    return 1;
+  } finally {
+    await ctx.client.request('fs.edit.unlock', { path: remotePath }).catch(() => {});
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+
+function summarizeDiff(oldLines, newLines) {
+  const a = new Set(oldLines);
+  const b = new Set(newLines);
+  let added = 0;
+  let removed = 0;
+  for (const l of newLines) if (!a.has(l)) added++;
+  for (const l of oldLines) if (!b.has(l)) removed++;
+  return { added, removed };
+}
+
+module.exports = { editFile };

package/src/formatters.js

@@ -0,0 +1,134 @@
+/*
+ * Copyright 2026 DemonZDevelopment
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+'use strict';
+
+function humanSize(bytes) {
+  if (bytes == null || bytes < 0) return '-';
+  const units = ['B', 'K', 'M', 'G', 'T'];
+  let v = bytes;
+  let i = 0;
+  while (v >= 1024 && i < units.length - 1) {
+    v /= 1024;
+    i++;
+  }
+  return (i === 0 ? String(bytes) : v.toFixed(1)) + units[i];
+}
+
+function formatDate(ms) {
+  if (!ms) return '-';
+  const d = new Date(ms);
+  const p = (n) => String(n).padStart(2, '0');
+  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}`;
+}
+
+function formatLs(entries, { longFormat }) {
+  if (!entries.length) return '(empty)';
+  if (!longFormat) {
+    return wrap(entries.map((e) => e.name + (e.isDir ? '/' : '')));
+  }
+  return entries.map((e) => {
+    const perms = e.perms || '----------';
+    const size = e.isDir ? '-' : humanSize(e.size);
+    return `${perms} ${String(size).padStart(8)} ${formatDate(e.mtime)} ${e.name}${e.isDir ? '/' : ''}${e.link ? ' -> ' + e.link : ''}`;
+  }).join('\n');
+}
+
+function wrap(items, width = 100) {
+  let line = '';
+  const out = [];
+  for (const it of items) {
+    if (line && line.length + it.length + 2 > width) {
+      out.push(line);
+      line = '';
+    }
+    line = line ? line + '  ' + it : it;
+  }
+  if (line) out.push(line);
+  return out.join('\n');
+}
+
+function formatTree(nodes, prefix = '') {
+  const out = [];
+  nodes.forEach((node, i) => {
+    const last = i === nodes.length - 1;
+    const branch = last ? '└── ' : '├── ';
+    out.push(prefix + branch + node.name + (node.isDir ? '/' : ''));
+    if (node.children && node.children.length) {
+      out.push(...formatTree(node.children, prefix + (last ? '    ' : '│   ')));
+    }
+  });
+  return out.join('\n');
+}
+
+function formatUptime(ms) {
+  const total = Math.floor(ms / 1000);
+  const d = Math.floor(total / 86400);
+  const h = Math.floor((total % 86400) / 3600);
+  const m = Math.floor((total % 3600) / 60);
+  return `${d}d ${h}h ${m}m`;
+}
+
+function formatStats(s) {
+  const mem = s.memory || {};
+  const cpu = s.cpu || {};
+  const disk = s.disk || {};
+  const load = cpu.load >= 0 ? cpu.load.toFixed(2) : 'n/a';
+  const proc = cpu.processCpuPercent >= 0 ? cpu.processCpuPercent.toFixed(1) + '%' : 'n/a';
+  const rows = [
+    `Uptime:       ${formatUptime(s.uptimeMs || 0)}`,
+    `CPU load:     ${load}   process: ${proc}`,
+    `Memory heap:  ${humanSize(mem.heapUsed)} / ${humanSize(mem.heapTotal)} (max ${humanSize(mem.heapMax)})`,
+    `Disk (root):  ${humanSize(disk.used)} / ${humanSize(disk.total)} (usable ${humanSize(disk.usable)})`,
+  ];
+  if (s.jvm && s.jvm.javaVersion) rows.push(`Java:         ${s.jvm.javaVersion} (${s.jvm.availableProcessors} cores)`);
+  return rows.join('\n');
+}
+
+function tpsBar(tps) {
+  const filled = Math.max(0, Math.min(20, Math.round(tps)));
+  return '█'.repeat(filled) + '░'.repeat(20 - filled);
+}
+
+function formatTps(t) {
+  return `TPS: 1m ${t.tps1m.toFixed(1)} | 5m ${t.tps5m.toFixed(1)} | 15m ${t.tps15m.toFixed(1)}  [${tpsBar(t.tps1m)}]  tick ${t.tickMs}ms`;
+}
+
+function formatMatches(matches) {
+  return matches.map((m) => `${m.path}${m.line ? ':' + m.line : ''}: ${m.text}`).join('\n');
+}
+
+function formatInfo(e) {
+  return [
+    `Path:     ${e.path}`,
+    `Type:     ${e.isDir ? 'directory' : 'file'}${e.link ? ' (symlink -> ' + e.link + ')' : ''}`,
+    `Perms:    ${e.perms || '-'}`,
+    `Size:     ${e.isDir ? '-' : humanSize(e.size)}`,
+    `Modified: ${formatDate(e.mtime)}`,
+  ].join('\n');
+}
+
+module.exports = {
+  humanSize,
+  formatDate,
+  formatLs,
+  formatTree,
+  formatStats,
+  formatTps,
+  formatMatches,
+  formatInfo,
+  wrap,
+};