node-plume 1.0.1

package/dist/cli/index.mjs

@@ -0,0 +1,639 @@
+#!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/cli/index.ts
+import { readFileSync as readFileSync5 } from "fs";
+import { fileURLToPath } from "url";
+import { Command } from "commander";
+import pc6 from "picocolors";
+
+// src/cli/init.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+import pc from "picocolors";
+
+// src/service/config/index.ts
+import { extname as extname3, resolve as resolve3 } from "path";
+
+// src/service/config/default.ts
+var plumeDefaultConfig = Object.freeze({
+  app: {
+    name: "Plume Bot",
+    version: "1.0.0"
+  },
+  log: {
+    level: "info",
+    timestamp: true
+  },
+  transport: {
+    host: "127.0.0.1",
+    port: 23333,
+    path: "/api",
+    wsPath: "/ws",
+    cors: true,
+    enableHttp: true,
+    enableWebSocket: true,
+    maxBodySize: 1024 * 1024
+  }
+});
+var plumeConfigSections = Object.freeze(
+  Object.keys(plumeDefaultConfig)
+);
+
+// src/service/config/init.ts
+import { dirname, extname as extname2, resolve as resolve2 } from "path";
+
+// src/service/config/file/config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { basename, extname, join, resolve } from "path";
+
+// src/service/config/tools.ts
+function stringifyJSON(data) {
+  return `${JSON.stringify(data, null, 2)}
+`;
+}
+
+// src/service/config/file/config.ts
+function resolveConfigDirectory(path = "config") {
+  return resolve(path);
+}
+function ensureConfigDirectory(path = "config") {
+  const directory = resolveConfigDirectory(path);
+  mkdirSync(directory, { recursive: true });
+  return directory;
+}
+function ensureDefaultConfigFiles(path = "config") {
+  const directory = ensureConfigDirectory(path);
+  const createdFiles = [];
+  for (const section of plumeConfigSections) {
+    const filePath = join(directory, `${section}.json`);
+    if (existsSync(filePath)) {
+      continue;
+    }
+    writeConfigObject(filePath, plumeDefaultConfig[section]);
+    createdFiles.push(filePath);
+  }
+  return createdFiles;
+}
+function writeConfigObject(path, data) {
+  writeFileSync(path, stringifyJSON(data), "utf-8");
+}
+
+// src/service/config/init.ts
+function initConfig(options = {}) {
+  const basePath = options.path ?? "config";
+  const useConfigDirectory = extname2(basePath) === "";
+  const configDirectory = useConfigDirectory ? ensureConfigDirectory(basePath) : ensureConfigDirectory(dirname(resolve2(basePath)));
+  const createdConfigFiles = useConfigDirectory ? ensureDefaultConfigFiles(basePath) : [];
+  return {
+    configDirectory,
+    createdConfigFiles
+  };
+}
+
+// src/service/log.ts
+import { createLogger } from "@plume/logger";
+var LogService = class _LogService {
+  logger;
+  options;
+  outputs = [];
+  buffer = [];
+  maxBufferSize = 1e3;
+  suspended = false;
+  pending = [];
+  constructor(options = {}) {
+    this.options = {
+      level: "info",
+      timestamp: true,
+      ...options
+    };
+    this.logger = createLogger({
+      level: this.options.level,
+      prefix: this.options.prefix,
+      timestamp: this.options.timestamp
+    });
+    if (this.options.outputs) {
+      this.outputs = this.options.outputs;
+    }
+  }
+  get level() {
+    return this.options.level ?? "info";
+  }
+  setLevel(level) {
+    this.options.level = level;
+    this.logger.setLevel(level);
+  }
+  suspend() {
+    this.suspended = true;
+    return this;
+  }
+  resume() {
+    if (!this.suspended) {
+      return this;
+    }
+    this.suspended = false;
+    for (const entry of this.pending) {
+      this.writeEntry(entry);
+    }
+    this.pending = [];
+    return this;
+  }
+  debug(message, ...args) {
+    this.log("debug", message, ...args);
+  }
+  info(message, ...args) {
+    this.log("info", message, ...args);
+  }
+  warn(message, ...args) {
+    this.log("warn", message, ...args);
+  }
+  error(message, ...args) {
+    this.log("error", message, ...args);
+  }
+  log(level, message, ...args) {
+    if (level === "silent") return;
+    const entry = {
+      level,
+      message,
+      timestamp: /* @__PURE__ */ new Date(),
+      args,
+      prefix: this.options.prefix
+    };
+    this.buffer.push(entry);
+    if (this.buffer.length > this.maxBufferSize) {
+      this.buffer.shift();
+    }
+    if (this.suspended) {
+      this.pending.push(entry);
+      return;
+    }
+    this.writeEntry(entry);
+  }
+  writeEntry(entry) {
+    switch (entry.level) {
+      case "debug":
+        this.logger.debug(entry.message, ...entry.args);
+        break;
+      case "info":
+        this.logger.info(entry.message, ...entry.args);
+        break;
+      case "warn":
+        this.logger.warn(entry.message, ...entry.args);
+        break;
+      case "error":
+        this.logger.error(entry.message, ...entry.args);
+        break;
+      case "silent":
+        return;
+    }
+    for (const output of this.outputs) {
+      this.writeToOutput(output, entry);
+    }
+  }
+  writeToOutput(output, entry) {
+    switch (output.type) {
+      case "console":
+        break;
+      case "file":
+        break;
+      case "custom":
+        if (output.handler) {
+          output.handler(entry.level, entry.message, ...entry.args);
+        }
+        break;
+    }
+  }
+  addOutput(output) {
+    this.outputs.push(output);
+    return this;
+  }
+  removeOutput(output) {
+    const index = this.outputs.indexOf(output);
+    if (index > -1) {
+      this.outputs.splice(index, 1);
+      return true;
+    }
+    return false;
+  }
+  child(prefix) {
+    return new _LogService({
+      ...this.options,
+      prefix: this.options.prefix ? `${this.options.prefix}:${prefix}` : prefix
+    });
+  }
+  getBuffer() {
+    return [...this.buffer];
+  }
+  clearBuffer() {
+    this.buffer = [];
+  }
+  flush() {
+    for (const output of this.outputs) {
+      if (output.type === "file" && output.path) {
+        const fs = __require("fs");
+        const content = this.buffer.map((e) => `[${e.timestamp.toISOString()}] [${e.level.toUpperCase()}] ${e.prefix ? `[${e.prefix}] ` : ""}${e.message}`).join("\n");
+        fs.appendFileSync(output.path, content + "\n");
+      }
+    }
+  }
+};
+var logService = new LogService();
+
+// src/cli/init.ts
+async function initCommand(_options) {
+  const cwd = process.cwd();
+  const pkgPath = join2(cwd, "package.json");
+  if (!existsSync2(pkgPath)) {
+    console.error(pc.red("Error: No package.json found in current directory"));
+    console.log(pc.gray("Run `pnpm init` first to create a package.json"));
+    process.exit(1);
+  }
+  const configDir = join2(cwd, "config");
+  const tsconfigPath = join2(cwd, "tsconfig.json");
+  const srcDir = join2(cwd, "src");
+  const mainPath = join2(srcDir, "main.ts");
+  mkdirSync2(configDir, { recursive: true });
+  mkdirSync2(srcDir, { recursive: true });
+  const initResult = initConfig({
+    path: configDir
+  });
+  for (const filePath of initResult.createdConfigFiles) {
+    console.log(pc.green(`Created ${filePath.replace(`${cwd}\\`, "")}`));
+  }
+  if (!existsSync2(tsconfigPath)) {
+    writeFileSync2(tsconfigPath, JSON.stringify(createTsConfig(), null, 2));
+    console.log(pc.green("Created tsconfig.json"));
+  }
+  if (!existsSync2(mainPath)) {
+    writeFileSync2(mainPath, createMainTs());
+    console.log(pc.green("Created src/main.ts"));
+  }
+  const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+  if (!pkg.scripts) pkg.scripts = {};
+  if (!pkg.scripts.app) {
+    pkg.scripts.app = "tsx src/main.ts";
+    pkg.scripts.start = "node dist/main.js";
+    pkg.scripts.build = "tsup src/main.ts --format esm --sourcemap --clean";
+  }
+  if (!pkg.dependencies?.["@plume/core"] && !pkg.devDependencies?.["@plume/core"]) {
+    if (!pkg.dependencies) pkg.dependencies = {};
+    pkg.dependencies["@plume/core"] = "^1.0.0";
+  }
+  writeFileSync2(pkgPath, JSON.stringify(pkg, null, 2));
+  console.log(pc.green("Updated package.json"));
+  console.log(pc.cyan("\nNext steps:"));
+  console.log(pc.gray("  pnpm install"));
+  console.log(pc.gray("  pnpm app"));
+}
+function createTsConfig() {
+  return {
+    compilerOptions: {
+      target: "ES2022",
+      module: "ESNext",
+      moduleResolution: "bundler",
+      strict: true,
+      esModuleInterop: true,
+      skipLibCheck: true,
+      outDir: "dist",
+      rootDir: "src"
+    },
+    include: ["src/**/*"],
+    exclude: ["node_modules", "dist"]
+  };
+}
+function createMainTs() {
+  return `import { App, start } from '@plume/core'
+
+export const app = new App({
+  name: 'my-bot',
+  logger: {
+    level: 'debug'
+  }
+})
+
+app.on('message', async ({ ctx, event }) => {
+  console.log('Received message:', event.text)
+  
+  if (event.text === 'ping') {
+    console.log('pong')
+  }
+})
+
+start({ app }).then(() => {
+  console.log('Bot started!')
+})
+`;
+}
+
+// src/cli/start.ts
+import { spawn } from "child_process";
+import { join as join3 } from "path";
+import { existsSync as existsSync3 } from "fs";
+import pc2 from "picocolors";
+async function startCommand() {
+  const cwd = process.cwd();
+  const mainPath = join3(cwd, "src", "main.ts");
+  if (!existsSync3(mainPath)) {
+    console.error(pc2.red("Error: src/main.ts not found"));
+    console.log(pc2.gray("Run `plume init` to create the project structure"));
+    process.exit(1);
+  }
+  console.log(pc2.cyan("Starting Plume...\n"));
+  await runCommand("pnpm", ["exec", "tsx", "src/main.ts"]);
+}
+async function appCommand() {
+  return startCommand();
+}
+function runCommand(command, args) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    const child = spawn(command, args, {
+      cwd: process.cwd(),
+      stdio: "inherit",
+      shell: process.platform === "win32"
+    });
+    child.on("exit", (code) => {
+      if (code === 0) {
+        resolvePromise();
+        return;
+      }
+      rejectPromise(new Error(`${command} ${args.join(" ")} exited with code ${code ?? "unknown"}`));
+    });
+    child.on("error", rejectPromise);
+  });
+}
+
+// src/cli/pm2.ts
+import { spawn as spawn2 } from "child_process";
+import { join as join4 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import pc3 from "picocolors";
+async function pm2Command() {
+  const cwd = process.cwd();
+  const mainPath = join4(cwd, "src", "main.ts");
+  if (!existsSync4(mainPath)) {
+    console.error(pc3.red("Error: src/main.ts not found"));
+    process.exit(1);
+  }
+  const pkgPath = join4(cwd, "package.json");
+  let appName = "plume-app";
+  if (existsSync4(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
+      appName = pkg.name || appName;
+    } catch {
+    }
+  }
+  console.log(pc3.cyan(`Starting ${appName} with PM2...
+`));
+  await runCommand2("pnpm", ["exec", "pm2", "start", "tsx", "--name", appName, "--", "src/main.ts"]);
+}
+async function stopCommand() {
+  const cwd = process.cwd();
+  const pkgPath = join4(cwd, "package.json");
+  let appName = "plume-app";
+  if (existsSync4(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
+      appName = pkg.name || appName;
+    } catch {
+    }
+  }
+  console.log(pc3.cyan(`Stopping ${appName}...
+`));
+  await runCommand2("pnpm", ["exec", "pm2", "stop", appName]);
+}
+async function restartCommand(options) {
+  const cwd = process.cwd();
+  const pkgPath = join4(cwd, "package.json");
+  let appName = "plume-app";
+  if (existsSync4(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
+      appName = pkg.name || appName;
+    } catch {
+    }
+  }
+  const args = ["exec", "pm2", "restart", appName];
+  if (options.force) {
+    args.push("--force");
+  }
+  console.log(pc3.cyan(`Restarting ${appName}...
+`));
+  await runCommand2("pnpm", args);
+}
+async function logCommand() {
+  const cwd = process.cwd();
+  const pkgPath = join4(cwd, "package.json");
+  let appName = "plume-app";
+  if (existsSync4(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
+      appName = pkg.name || appName;
+    } catch {
+    }
+  }
+  await runCommand2("pnpm", ["exec", "pm2", "logs", appName]);
+}
+function runCommand2(command, args) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    const child = spawn2(command, args, {
+      cwd: process.cwd(),
+      stdio: "inherit",
+      shell: process.platform === "win32"
+    });
+    child.on("exit", (code) => {
+      if (code === 0) {
+        resolvePromise();
+        return;
+      }
+      rejectPromise(new Error(`${command} ${args.join(" ")} exited with code ${code ?? "unknown"}`));
+    });
+    child.on("error", rejectPromise);
+  });
+}
+
+// src/cli/update.ts
+import { spawn as spawn3 } from "child_process";
+import pc4 from "picocolors";
+async function updateCommand(options) {
+  console.log(pc4.cyan("Updating dependencies...\n"));
+  const args = ["update"];
+  if (options.force) {
+    args.push("--force");
+  }
+  await runCommand3("pnpm", args);
+  console.log(pc4.green("\nDependencies updated successfully!"));
+}
+function runCommand3(command, args) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    const child = spawn3(command, args, {
+      cwd: process.cwd(),
+      stdio: "inherit",
+      shell: process.platform === "win32"
+    });
+    child.on("exit", (code) => {
+      if (code === 0) {
+        resolvePromise();
+        return;
+      }
+      rejectPromise(new Error(`${command} ${args.join(" ")} exited with code ${code ?? "unknown"}`));
+    });
+    child.on("error", rejectPromise);
+  });
+}
+
+// src/cli/build-dep.ts
+import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { join as join5 } from "path";
+import pc5 from "picocolors";
+async function buildDepCommand(action, dependency) {
+  const cwd = process.cwd();
+  const workspacePath = join5(cwd, "pnpm-workspace.yaml");
+  if (!existsSync5(workspacePath)) {
+    console.error(pc5.red("Error: pnpm-workspace.yaml not found"));
+    process.exit(1);
+  }
+  const content = readFileSync4(workspacePath, "utf-8");
+  const lines = content.split("\n");
+  let onlyBuiltStart = -1;
+  let onlyBuiltEnd = -1;
+  const deps = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].includes("onlyBuiltDependencies:")) {
+      onlyBuiltStart = i;
+    }
+    if (onlyBuiltStart !== -1 && onlyBuiltEnd === -1) {
+      if (lines[i].trim().startsWith("-")) {
+        const dep = lines[i].trim().slice(1).trim();
+        if (dep) deps.push(dep);
+      } else if (lines[i].trim() && !lines[i].includes("onlyBuiltDependencies")) {
+        onlyBuiltEnd = i;
+      }
+    }
+  }
+  switch (action) {
+    case "ls":
+    case "list":
+      console.log(pc5.cyan("Build dependencies:"));
+      if (deps.length === 0) {
+        console.log(pc5.gray("  (none)"));
+      } else {
+        deps.forEach((dep) => console.log(pc5.green(`  - ${dep}`)));
+      }
+      break;
+    case "add":
+      if (!dependency) {
+        console.error(pc5.red("Error: Dependency name required for add action"));
+        process.exit(1);
+      }
+      const depsToAdd = dependency.split(",").map((d) => d.trim()).filter(Boolean);
+      for (const dep of depsToAdd) {
+        if (!deps.includes(dep)) {
+          deps.push(dep);
+          console.log(pc5.green(`Added: ${dep}`));
+        } else {
+          console.log(pc5.yellow(`Already exists: ${dep}`));
+        }
+      }
+      updateWorkspaceFile(workspacePath, content, deps);
+      break;
+    case "rm":
+    case "remove":
+      if (!dependency) {
+        console.error(pc5.red("Error: Dependency name required for rm action"));
+        process.exit(1);
+      }
+      const depsToRemove = dependency.split(",").map((d) => d.trim()).filter(Boolean);
+      for (const dep of depsToRemove) {
+        const index = deps.indexOf(dep);
+        if (index !== -1) {
+          deps.splice(index, 1);
+          console.log(pc5.green(`Removed: ${dep}`));
+        } else {
+          console.log(pc5.yellow(`Not found: ${dep}`));
+        }
+      }
+      updateWorkspaceFile(workspacePath, content, deps);
+      break;
+    default:
+      console.error(pc5.red(`Error: Unknown action "${action}". Use: add, rm, or ls`));
+      process.exit(1);
+  }
+}
+function updateWorkspaceFile(path, content, deps) {
+  const lines = content.split("\n");
+  let onlyBuiltStart = -1;
+  let onlyBuiltEnd = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].includes("onlyBuiltDependencies:")) {
+      onlyBuiltStart = i;
+    }
+    if (onlyBuiltStart !== -1 && onlyBuiltEnd === -1) {
+      if (lines[i].trim() && !lines[i].trim().startsWith("-") && !lines[i].includes("onlyBuiltDependencies")) {
+        onlyBuiltEnd = i;
+      }
+    }
+  }
+  if (onlyBuiltStart === -1) {
+    lines.push("onlyBuiltDependencies:");
+    onlyBuiltStart = lines.length - 1;
+    onlyBuiltEnd = lines.length;
+  }
+  if (onlyBuiltEnd === -1) {
+    onlyBuiltEnd = lines.length;
+  }
+  const newLines = [
+    ...lines.slice(0, onlyBuiltStart + 1),
+    ...deps.map((dep) => `  - ${dep}`),
+    ...lines.slice(onlyBuiltEnd)
+  ];
+  writeFileSync3(path, newLines.join("\n"));
+}
+
+// src/cli/index.ts
+function getVersion() {
+  try {
+    const file = fileURLToPath(new URL("../../package.json", import.meta.url));
+    const packageJson = JSON.parse(readFileSync5(file, "utf-8"));
+    return packageJson.version;
+  } catch {
+    return "unknown";
+  }
+}
+var program = new Command();
+program.name("plume").description("Modern CLI for developing and running Plume projects").version(getVersion(), "-v, --version", "\u663E\u793A\u7248\u672C\u53F7");
+program.command("init").description("\u521D\u59CB\u5316 Plume \u9879\u76EE").option("-f, --force", "\u5F3A\u5236\u521D\u59CB\u5316\uFF0C\u8986\u76D6\u5DF2\u5B58\u5728\u7684\u914D\u7F6E\u6587\u4EF6").option("-d, --dev", "\u5F00\u53D1\u6A21\u5F0F\u521D\u59CB\u5316").action((options) => {
+  process.env.PLUME_CLI = "true";
+  if (options.dev) {
+    process.env.NODE_ENV = "development";
+  }
+  initCommand(options);
+});
+program.command(".").description("\u524D\u53F0\u542F\u52A8").action(startCommand);
+program.command("app").description("\u524D\u53F0\u542F\u52A8").action(appCommand);
+program.command("start").description("\u524D\u53F0\u542F\u52A8").action(startCommand);
+program.command("pm2").description("\u540E\u53F0\u8FD0\u884C").action(pm2Command);
+program.command("stop").description("\u505C\u6B62\u540E\u53F0\u670D\u52A1").action(stopCommand);
+program.command("rs").alias("restart").description("\u91CD\u542F\u540E\u53F0\u670D\u52A1").option("-f, --force", "\u5F3A\u5236\u91CD\u542F").action((options) => restartCommand(options));
+program.command("log").alias("logs").description("\u67E5\u770B\u65E5\u5FD7").action(logCommand);
+program.command("up").description("\u66F4\u65B0\u63D2\u4EF6").option("-f, --force", "\u5F3A\u5236\u66F4\u65B0").option("-s, --serial", "\u4E32\u884C\u66F4\u65B0").action((options) => updateCommand(options));
+program.command("b").alias("allow-build").description("\u6784\u5EFA\u4F9D\u8D56\u7BA1\u7406 (pnpm v10.x)").argument("<action>", "\u64CD\u4F5C\u7C7B\u578B: add, rm, ls").argument("[dependency]", "\u4F9D\u8D56\u5305\u540D\u79F0 (add/rm\u64CD\u4F5C\u9700\u8981\uFF0C\u591A\u4E2A\u4F7F\u7528\u9017\u53F7\u5206\u5272)").action((action, dependency) => {
+  if (action === "add" && dependency) {
+    buildDepCommand("add", dependency);
+  } else if (action === "rm" && dependency) {
+    buildDepCommand("rm", dependency);
+  } else if (action === "ls") {
+    buildDepCommand("ls");
+  } else {
+    console.log(pc6.red("\u65E0\u6548\u7684\u547D\u4EE4\u3002\u6709\u6548\u547D\u4EE4: add <dependency>, rm <dependency>, ls"));
+  }
+});
+if (!process.argv?.[2]) {
+  process.argv.push("-h");
+}
+program.parse(process.argv);