node-plume 1.0.1

package/dist/start/app.mjs

@@ -0,0 +1,3087 @@
+import {
+  __require
+} from "./chunk-T7M5RXO7.mjs";
+
+// src/start/app.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL2 } from "url";
+import { logger as logger2 } from "@plume/logger";
+
+// src/app.ts
+import { createLogger as createLogger2 } from "@plume/logger";
+
+// src/context.ts
+var Context = class {
+  constructor(app, event) {
+    this.app = app;
+    this.event = event;
+  }
+  app;
+  event;
+  state = /* @__PURE__ */ new Map();
+  get messageId() {
+    return this.event.messageId;
+  }
+  get text() {
+    return this.event.text;
+  }
+  get content() {
+    return this.event.content;
+  }
+  get sender() {
+    return this.event.sender;
+  }
+  get userId() {
+    return this.event.userId;
+  }
+  get groupId() {
+    return this.event.groupId;
+  }
+  get isPrivate() {
+    return this.event.isPrivate;
+  }
+  get isGroup() {
+    return this.event.isGroup;
+  }
+  get target() {
+    return this.event.target;
+  }
+  get selfId() {
+    return this.event.selfId;
+  }
+  get timestamp() {
+    return this.event.timestamp;
+  }
+  get raw() {
+    return this.event.raw;
+  }
+  get services() {
+    return this.app.services;
+  }
+  setState(key, value) {
+    this.state.set(key, value);
+    return this;
+  }
+  getState(key) {
+    return this.state.get(key);
+  }
+  async reply(content, options = {}) {
+    return this.app.sendMessage(this.target, normalizeReplyInput(content), {
+      ...options,
+      replyTo: options.reply === false ? void 0 : this.messageId
+    });
+  }
+};
+function normalizeReplyInput(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (Array.isArray(content)) {
+    return content.map(
+      (item) => typeof item === "string" ? { type: "text", data: { text: item } } : item
+    );
+  }
+  return [content];
+}
+
+// src/service/container.ts
+var ServiceContainer = class {
+  services = /* @__PURE__ */ new Map();
+  factories = /* @__PURE__ */ new Map();
+  register(name, service) {
+    this.services.set(name, service);
+    return this;
+  }
+  registerFactory(name, factory) {
+    this.factories.set(name, factory);
+    return this;
+  }
+  resolve(name) {
+    if (this.services.has(name)) {
+      return this.services.get(name);
+    }
+    if (this.factories.has(name)) {
+      const service = this.factories.get(name)();
+      this.services.set(name, service);
+      return service;
+    }
+    throw new Error(`Service '${name}' not found`);
+  }
+  has(name) {
+    return this.services.has(name) || this.factories.has(name);
+  }
+  delete(name) {
+    return this.services.delete(name) || this.factories.delete(name);
+  }
+  clear() {
+    this.services.clear();
+    this.factories.clear();
+  }
+  get(name) {
+    if (this.services.has(name)) {
+      return this.services.get(name);
+    }
+    return void 0;
+  }
+  set(name, service) {
+    return this.register(name, service);
+  }
+  keys() {
+    return [.../* @__PURE__ */ new Set([...this.services.keys(), ...this.factories.keys()])];
+  }
+  entries() {
+    const resolvedEntries = [...this.services.entries()];
+    for (const [name] of this.factories.entries()) {
+      if (!this.services.has(name)) {
+        resolvedEntries.push([name, this.resolve(name)]);
+      }
+    }
+    return resolvedEntries;
+  }
+  size() {
+    return this.keys().length;
+  }
+};
+
+// src/service/message.ts
+var MessageService = class {
+  sender = null;
+  registerSender(sender) {
+    this.sender = sender;
+    return this;
+  }
+  clearSender() {
+    this.sender = null;
+    return this;
+  }
+  hasSender() {
+    return this.sender !== null;
+  }
+  async sendMessage(params) {
+    if (!this.sender) {
+      throw new Error("\u6D88\u606F\u53D1\u9001\u5668\u672A\u6CE8\u518C");
+    }
+    return this.sender.sendMessage(params);
+  }
+};
+
+// 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 parsePrimitiveValue(value) {
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (value === "null" || value === "~") return null;
+  if (/^-?\d+$/.test(value)) return parseInt(value, 10);
+  if (/^-?\d+\.\d+$/.test(value)) return parseFloat(value);
+  if (value.startsWith('"') && value.endsWith('"')) return value.slice(1, -1);
+  if (value.startsWith("'") && value.endsWith("'")) return value.slice(1, -1);
+  return value;
+}
+function flattenObject(obj, prefix = "", entries = []) {
+  for (const [key, value] of Object.entries(obj)) {
+    const fullKey = prefix ? `${prefix}.${key}` : key;
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      flattenObject(value, fullKey, entries);
+    } else {
+      entries.push([fullKey, value]);
+    }
+  }
+  return entries;
+}
+function parseYAML(content) {
+  const result = {};
+  const lines = content.split(/\r?\n/);
+  const stack = [
+    { obj: result, indent: -1 }
+  ];
+  for (const rawLine of lines) {
+    const line = rawLine.replace(/\t/g, "  ");
+    if (!line.trim() || line.trim().startsWith("#")) {
+      continue;
+    }
+    const indent = line.search(/\S/);
+    const [key, ...valueParts] = line.trim().split(":");
+    const value = valueParts.join(":").trim();
+    while (stack.length > 1 && indent <= stack[stack.length - 1].indent) {
+      stack.pop();
+    }
+    const current = stack[stack.length - 1].obj;
+    if (value) {
+      current[key.trim()] = parsePrimitiveValue(value);
+    } else {
+      const child = {};
+      current[key.trim()] = child;
+      stack.push({ obj: child, indent });
+    }
+  }
+  return result;
+}
+function stringifyJSON(data) {
+  return `${JSON.stringify(data, null, 2)}
+`;
+}
+
+// src/service/config/file/config.ts
+var CONFIG_EXTENSIONS = [".json", ".yaml", ".yml"];
+function resolveConfigDirectory(path = "config") {
+  return resolve(path);
+}
+function ensureConfigDirectory(path = "config") {
+  const directory = resolveConfigDirectory(path);
+  mkdirSync(directory, { recursive: true });
+  return directory;
+}
+function readConfigDirectory(path = "config") {
+  const directory = resolveConfigDirectory(path);
+  const result = {};
+  for (const section of plumeConfigSections) {
+    const filePath = findSectionConfigFile(directory, section);
+    if (!filePath) {
+      continue;
+    }
+    result[section] = readConfigObject(filePath);
+  }
+  return result;
+}
+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 readConfigObject(path) {
+  const content = readFileSync(path, "utf-8");
+  const extension = extname(path).toLowerCase();
+  if (extension === ".json") {
+    return JSON.parse(content);
+  }
+  if (extension === ".yaml" || extension === ".yml") {
+    return parseYAML(content);
+  }
+  throw new Error(`Unsupported config file format: ${basename(path)}`);
+}
+function writeConfigObject(path, data) {
+  writeFileSync(path, stringifyJSON(data), "utf-8");
+}
+function findSectionConfigFile(directory, section) {
+  for (const extension of CONFIG_EXTENSIONS) {
+    const filePath = join(directory, `${section}${extension}`);
+    if (existsSync(filePath)) {
+      return filePath;
+    }
+  }
+  return null;
+}
+
+// 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/config/index.ts
+var ConfigService = class {
+  config = /* @__PURE__ */ new Map();
+  path;
+  constructor(options = {}) {
+    this.path = options.path ?? "config";
+    this.loadDefaults();
+  }
+  initialize(options = {}) {
+    return initConfig({
+      path: options.path ?? this.path
+    });
+  }
+  loadDefaults() {
+    const entries = flattenObject(plumeDefaultConfig);
+    for (const [key, value] of entries) {
+      this.set(key, value, "default");
+    }
+    return this;
+  }
+  loadFile(path) {
+    const targetPath = path ?? this.path;
+    const absolutePath = resolve3(targetPath);
+    const extension = extname3(absolutePath).toLowerCase();
+    if (!extension) {
+      return this.loadDirectory(targetPath);
+    }
+    return this.loadObject(readConfigObject(absolutePath), "file");
+  }
+  loadDirectory(path = this.path) {
+    return this.loadObject(readConfigDirectory(path), "file");
+  }
+  loadObject(data, source = "file") {
+    for (const [key, value] of flattenObject(data)) {
+      this.set(key, value, source);
+    }
+    return this;
+  }
+  reload() {
+    this.clear();
+    this.loadFile();
+    return this;
+  }
+  get(key, defaultValue) {
+    const entry = this.config.get(key);
+    if (entry) {
+      return entry.value;
+    }
+    return defaultValue;
+  }
+  set(key, value, source = "default") {
+    this.config.set(key, { value, source });
+    return this;
+  }
+  has(key) {
+    return this.config.has(key);
+  }
+  delete(key) {
+    return this.config.delete(key);
+  }
+  getSource(key) {
+    return this.config.get(key)?.source;
+  }
+  getAll() {
+    const result = {};
+    for (const [key, entry] of this.config) {
+      result[key] = entry.value;
+    }
+    return result;
+  }
+  entries() {
+    return [...this.config.entries()];
+  }
+  clear() {
+    this.config.clear();
+    this.loadDefaults();
+  }
+};
+
+// 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 output2 of this.outputs) {
+      this.writeToOutput(output2, entry);
+    }
+  }
+  writeToOutput(output2, entry) {
+    switch (output2.type) {
+      case "console":
+        break;
+      case "file":
+        break;
+      case "custom":
+        if (output2.handler) {
+          output2.handler(entry.level, entry.message, ...entry.args);
+        }
+        break;
+    }
+  }
+  addOutput(output2) {
+    this.outputs.push(output2);
+    return this;
+  }
+  removeOutput(output2) {
+    const index = this.outputs.indexOf(output2);
+    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 output2 of this.outputs) {
+      if (output2.type === "file" && output2.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(output2.path, content + "\n");
+      }
+    }
+  }
+};
+var logService = new LogService();
+
+// src/event-emitter.ts
+var EventEmitter = class {
+  handlers = /* @__PURE__ */ new Map();
+  on(event, handler) {
+    if (!this.handlers.has(event)) {
+      this.handlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.handlers.get(event).add(handler);
+    return this;
+  }
+  once(event, handler) {
+    const wrappedHandler = (data) => {
+      this.off(event, wrappedHandler);
+      return handler(data);
+    };
+    return this.on(event, wrappedHandler);
+  }
+  off(event, handler) {
+    const handlers = this.handlers.get(event);
+    if (handlers) {
+      handlers.delete(handler);
+    }
+    return this;
+  }
+  async emit(event, data) {
+    const handlers = this.handlers.get(event);
+    if (!handlers) return;
+    const promises = [];
+    for (const handler of handlers) {
+      try {
+        const result = handler(data);
+        if (result instanceof Promise) {
+          promises.push(result);
+        }
+      } catch (error) {
+        console.error(`Error in event handler for "${String(event)}":`, error);
+      }
+    }
+    await Promise.all(promises);
+  }
+  listenerCount(event) {
+    return this.handlers.get(event)?.size ?? 0;
+  }
+  removeAllListeners(event) {
+    if (event) {
+      this.handlers.delete(event);
+    } else {
+      this.handlers.clear();
+    }
+    return this;
+  }
+};
+
+// src/event/base.ts
+var BaseEvent = class {
+  constructor(payload) {
+    this.payload = payload;
+    this.timestamp = payload.timestamp;
+    this.raw = payload.raw;
+  }
+  payload;
+  timestamp;
+  raw;
+  get selfId() {
+    return this.payload.selfId;
+  }
+};
+
+// src/event/message.ts
+var MessageEvent = class extends BaseEvent {
+  type = "message";
+  get messageId() {
+    return this.payload.messageId;
+  }
+  get content() {
+    return this.payload.content;
+  }
+  get text() {
+    return this.payload.text;
+  }
+  get sender() {
+    return this.payload.sender;
+  }
+  get target() {
+    return this.payload.target;
+  }
+  get isPrivate() {
+    return this.payload.target.type === "private";
+  }
+  get isGroup() {
+    return this.payload.target.type === "group";
+  }
+  get userId() {
+    return this.payload.sender.id;
+  }
+  get groupId() {
+    return this.payload.target.type === "group" ? this.payload.target.id : void 0;
+  }
+};
+
+// src/event/notice.ts
+var NoticeEvent = class extends BaseEvent {
+  type = "notice";
+  get subtype() {
+    return this.payload.subtype;
+  }
+  get operator() {
+    return this.payload.operator;
+  }
+  get targetUser() {
+    return this.payload.targetUser;
+  }
+  get group() {
+    return this.payload.group;
+  }
+  get data() {
+    return this.payload.data;
+  }
+  isGroupIncrease() {
+    return this.subtype === "group_increase";
+  }
+  isGroupDecrease() {
+    return this.subtype === "group_decrease";
+  }
+  isGroupAdmin() {
+    return this.subtype === "group_admin";
+  }
+  isGroupUpload() {
+    return this.subtype === "group_upload";
+  }
+  isFriendAdd() {
+    return this.subtype === "friend_add";
+  }
+  isFriendRecall() {
+    return this.subtype === "friend_recall";
+  }
+  isGroupRecall() {
+    return this.subtype === "group_recall";
+  }
+};
+
+// src/event/request.ts
+var RequestEvent = class extends BaseEvent {
+  type = "request";
+  get subtype() {
+    return this.payload.subtype;
+  }
+  get requestId() {
+    return this.payload.requestId;
+  }
+  get sender() {
+    return this.payload.sender;
+  }
+  get group() {
+    return this.payload.group;
+  }
+  get comment() {
+    return this.payload.comment;
+  }
+  isFriendRequest() {
+    return this.subtype === "friend";
+  }
+  isGroupInvite() {
+    return this.subtype === "group_invite";
+  }
+};
+
+// src/segment.ts
+function text(value) {
+  return {
+    type: "text",
+    data: { text: value }
+  };
+}
+function image(source) {
+  return {
+    type: "image",
+    data: normalizeBinaryData(source)
+  };
+}
+function audio(source) {
+  return {
+    type: "audio",
+    data: normalizeBinaryData(source)
+  };
+}
+function video(source) {
+  return {
+    type: "video",
+    data: normalizeBinaryData(source)
+  };
+}
+function file(source, name) {
+  if (typeof source === "string") {
+    return {
+      type: "file",
+      data: {
+        file: source.trim(),
+        name: trimOptionalString(name)
+      }
+    };
+  }
+  return {
+    type: "file",
+    data: {
+      name: trimOptionalString(source.name),
+      ...normalizeBinaryData(source)
+    }
+  };
+}
+function at(userId, name) {
+  return {
+    type: "at",
+    data: {
+      userId,
+      name: trimOptionalString(name)
+    }
+  };
+}
+function face(id, name) {
+  return {
+    type: "face",
+    data: {
+      id,
+      name: trimOptionalString(name)
+    }
+  };
+}
+function reply(messageId) {
+  return {
+    type: "reply",
+    data: { messageId }
+  };
+}
+function forward(input2) {
+  if (typeof input2 === "string") {
+    return {
+      type: "forward",
+      data: { id: input2.trim() }
+    };
+  }
+  if (Array.isArray(input2)) {
+    return {
+      type: "forward",
+      data: { messages: input2.map(normalizeForwardNode) }
+    };
+  }
+  return {
+    type: "forward",
+    data: {
+      id: trimOptionalString(input2.id),
+      messages: input2.messages?.map(normalizeForwardNode)
+    }
+  };
+}
+function location(latitudeOrData, longitude, title, content) {
+  if (typeof latitudeOrData === "number") {
+    return {
+      type: "location",
+      data: {
+        latitude: latitudeOrData,
+        longitude: longitude ?? 0,
+        title: trimOptionalString(title),
+        content: trimOptionalString(content)
+      }
+    };
+  }
+  return {
+    type: "location",
+    data: {
+      latitude: latitudeOrData.latitude,
+      longitude: latitudeOrData.longitude,
+      title: trimOptionalString(latitudeOrData.title),
+      content: trimOptionalString(latitudeOrData.content)
+    }
+  };
+}
+function json(data) {
+  return {
+    type: "json",
+    data: {
+      data: typeof data === "string" ? data.trim() : { ...data }
+    }
+  };
+}
+function xml(data) {
+  return {
+    type: "xml",
+    data: {
+      data: data.trim()
+    }
+  };
+}
+function custom(typeOrData, data = {}) {
+  if (typeof typeOrData === "string") {
+    return {
+      type: trimOptionalString(typeOrData) ?? "custom",
+      data: { ...data }
+    };
+  }
+  return {
+    type: "custom",
+    data: { ...typeOrData }
+  };
+}
+function normalizeMessageContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  return content.map((item) => normalizeMessageSegment(item));
+}
+function normalizeMessageSegment(segment2) {
+  switch (segment2.type) {
+    case "forward":
+      return forward(segment2.data);
+    case "location":
+      return location(segment2.data);
+    case "json":
+      return json(segment2.data.data);
+    case "xml":
+      return xml(typeof segment2.data.data === "string" ? segment2.data.data : "");
+    case "image":
+      return image(segment2.data);
+    case "audio":
+      return audio(segment2.data);
+    case "video":
+      return video(segment2.data);
+    case "file":
+      return file(segment2.data);
+    case "at":
+      return at(
+        typeof segment2.data.userId === "string" ? segment2.data.userId : "",
+        trimOptionalString(segment2.data.name)
+      );
+    case "face":
+      return face(
+        typeof segment2.data.id === "number" ? segment2.data.id : 0,
+        trimOptionalString(segment2.data.name)
+      );
+    case "reply":
+      return reply(typeof segment2.data.messageId === "string" ? segment2.data.messageId : "");
+    case "text":
+      return text(typeof segment2.data.text === "string" ? segment2.data.text : "");
+    case "custom":
+      return custom(segment2.data);
+    default:
+      return {
+        type: segment2.type,
+        data: { ...segment2.data }
+      };
+  }
+}
+function extractMessageText(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  return content.map((item) => renderMessageSegment(item)).filter(Boolean).join("");
+}
+function formatMessageContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  return content.map((item) => formatMessageSegment(item)).filter(Boolean).join(" ");
+}
+function renderMessageSegment(segment2) {
+  switch (segment2.type) {
+    case "text":
+      return typeof segment2.data.text === "string" ? segment2.data.text : "";
+    case "image":
+      return "[image]";
+    case "audio":
+      return "[audio]";
+    case "video":
+      return "[video]";
+    case "file":
+      return typeof segment2.data.name === "string" && segment2.data.name.trim() ? `[file:${segment2.data.name.trim()}]` : "[file]";
+    case "at":
+      return typeof segment2.data.userId === "string" ? `@${segment2.data.userId}` : "@unknown";
+    case "face":
+      return typeof segment2.data.name === "string" && segment2.data.name.trim() ? `[face:${segment2.data.name.trim()}]` : typeof segment2.data.id === "number" ? `[face:${segment2.data.id}]` : "[face]";
+    case "reply":
+      return typeof segment2.data.messageId === "string" ? `[reply:${segment2.data.messageId}]` : "[reply]";
+    case "forward":
+      return "[forward]";
+    case "location":
+      return typeof segment2.data.title === "string" && segment2.data.title.trim() ? `[location:${segment2.data.title.trim()}]` : "[location]";
+    case "json":
+      return "[json]";
+    case "xml":
+      return "[xml]";
+    case "custom":
+      return "[custom]";
+    default:
+      return `[${segment2.type}]`;
+  }
+}
+function formatMessageSegment(segment2) {
+  switch (segment2.type) {
+    case "text":
+      return typeof segment2.data.text === "string" ? segment2.data.text : "[text]";
+    case "image":
+      return formatCompactTypedSegment("image", segment2.data, ["url", "file", "path", "base64"]);
+    case "audio":
+      return formatCompactTypedSegment("audio", segment2.data, ["url", "file", "path", "base64"]);
+    case "video":
+      return formatCompactTypedSegment("video", segment2.data, ["url", "file", "path", "base64"]);
+    case "file":
+      return formatCompactTypedSegment("file", segment2.data, ["name", "url", "file", "path", "base64"]);
+    case "at":
+      return typeof segment2.data.userId === "string" ? `@${segment2.data.userId}` : "[at]";
+    case "face":
+      return formatCompactTypedSegment("face", segment2.data, ["name", "id"]);
+    case "reply":
+      return typeof segment2.data.messageId === "string" ? `[reply:${segment2.data.messageId}]` : "[reply]";
+    case "forward":
+      return formatCompactTypedSegment("forward", segment2.data, ["id"], formatForwardCount(segment2.data));
+    case "location":
+      return formatCompactTypedSegment("location", segment2.data, ["title", "latitude", "longitude", "content"]);
+    case "json":
+      return formatCompactTypedValue("json", segment2.data.data);
+    case "xml":
+      return formatCompactTypedValue("xml", segment2.data.data);
+    case "custom":
+      return formatCompactTypedValue("custom", segment2.data);
+    default:
+      return formatCompactTypedValue(segment2.type, segment2.data);
+  }
+}
+function normalizeForwardNode(node) {
+  return {
+    userId: trimOptionalString(node.userId),
+    nickname: trimOptionalString(node.nickname),
+    content: normalizeMessageContent(node.content)
+  };
+}
+function normalizeBinaryData(source) {
+  if (typeof source === "string") {
+    return { url: source.trim() };
+  }
+  return {
+    url: trimOptionalString(source.url),
+    file: trimOptionalString(source.file),
+    path: trimOptionalString(source.path),
+    base64: trimOptionalString(source.base64)
+  };
+}
+function formatCompactTypedSegment(type, data, fields, suffix = "") {
+  const primaryValue = pickFirstDefinedValue(data, fields);
+  if (!primaryValue) {
+    return suffix ? `[${type}${suffix}]` : `[${type}]`;
+  }
+  return `[${type} ${primaryValue}${suffix}]`;
+}
+function formatForwardCount(data) {
+  const messages = Array.isArray(data.messages) ? data.messages.length : 0;
+  return messages > 0 ? ` messages=${messages}` : "";
+}
+function formatCompactTypedValue(type, value) {
+  const formatted = formatDataValue(value);
+  return formatted === "..." ? `[${type}]` : `[${type} ${formatted}]`;
+}
+function pickFirstDefinedValue(data, fields) {
+  for (const field of fields) {
+    const value = data[field];
+    if (value === void 0 || value === null || value === "") {
+      continue;
+    }
+    return formatDataValue(value);
+  }
+  return void 0;
+}
+function formatDataValue(value) {
+  if (typeof value === "string") {
+    return truncateValue(value);
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  try {
+    return truncateValue(JSON.stringify(value));
+  } catch {
+    return String(value);
+  }
+}
+function truncateValue(value, maxLength = 48) {
+  const normalized = value.replace(/\s+/g, " ").trim();
+  if (!normalized) {
+    return "...";
+  }
+  return normalized.length > maxLength ? `${normalized.slice(0, maxLength - 3)}...` : normalized;
+}
+function trimOptionalString(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed ? trimmed : void 0;
+}
+
+// src/app.ts
+var App = class {
+  services = new ServiceContainer();
+  events = new EventEmitter();
+  logger;
+  name;
+  running = false;
+  plugins = /* @__PURE__ */ new Map();
+  constructor(config = {}) {
+    this.name = config.name ?? "app";
+    this.logger = createLogger2({
+      ...config.logger,
+      prefix: config.logger?.prefix ?? this.name
+    });
+  }
+  use(plugin) {
+    if (this.plugins.has(plugin.name)) {
+      throw new Error(`Plugin ${plugin.name} is already registered`);
+    }
+    this.plugins.set(plugin.name, plugin);
+    this.logger.debug(
+      `Registered plugin | name: ${plugin.name} | version: ${plugin.version ?? "unknown"} | priority: ${plugin.priority ?? 0}`
+    );
+    return this;
+  }
+  plugin(plugin) {
+    return this.use(plugin);
+  }
+  registerService(name, service) {
+    this.services.register(name, service);
+    return this;
+  }
+  on(event, handler) {
+    this.events.on(event, handler);
+    return this;
+  }
+  ready(handler) {
+    return this.on("ready", handler);
+  }
+  message(handler) {
+    return this.on("message", handler);
+  }
+  command(name, handler, options = {}) {
+    this.message(({ ctx, event }) => {
+      const matched = matchCommand(event.text, name, options);
+      if (!matched) {
+        return;
+      }
+      return Promise.resolve(handler({
+        app: this,
+        command: name,
+        args: matched.args,
+        rawArgs: matched.rawArgs,
+        event,
+        text: event.text,
+        sender: event.sender,
+        userId: event.userId,
+        groupId: event.groupId,
+        isPrivate: event.isPrivate,
+        isGroup: event.isGroup,
+        reply: (content) => ctx.reply(content)
+      })).then(() => void 0);
+    });
+    return this;
+  }
+  commands(commandMap) {
+    for (const [name, definition] of Object.entries(commandMap)) {
+      if (typeof definition === "function") {
+        this.command(name, definition);
+        continue;
+      }
+      this.command(name, definition.handler, definition);
+    }
+    return this;
+  }
+  notice(handler) {
+    return this.on("notice", handler);
+  }
+  request(handler) {
+    return this.on("request", handler);
+  }
+  error(handler) {
+    return this.on("error", handler);
+  }
+  stopped(handler) {
+    return this.on("stop", handler);
+  }
+  once(event, handler) {
+    this.events.once(event, handler);
+    return this;
+  }
+  off(event, handler) {
+    this.events.off(event, handler);
+    return this;
+  }
+  async start() {
+    if (this.running) {
+      return;
+    }
+    const plugins = this.getPluginsInOrder();
+    for (const plugin of plugins) {
+      const pluginStartTime = Date.now();
+      try {
+        this.logger.debug(`\u52A0\u8F7D\u63D2\u4EF6 ${plugin.name} v${plugin.version ?? "unknown"} priority=${plugin.priority ?? 0}`);
+        await plugin.setup(this);
+        this.logger.debug(`\u63D2\u4EF6\u5C31\u7EEA ${plugin.name} ${Date.now() - pluginStartTime}ms`);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        this.logger.error(`\u63D2\u4EF6\u52A0\u8F7D\u5931\u8D25 ${plugin.name}: ${message}`);
+        if (error instanceof Error && error.stack) {
+          this.logger.debug(error.stack);
+        }
+        throw error;
+      }
+    }
+    this.running = true;
+    await this.events.emit("ready", void 0);
+  }
+  async stop() {
+    if (!this.running) {
+      return;
+    }
+    const plugins = this.getPluginsInOrder().reverse();
+    for (const plugin of plugins) {
+      if (!plugin.dispose) continue;
+      const pluginStartTime = Date.now();
+      try {
+        this.logger.debug(`\u5378\u8F7D\u63D2\u4EF6 ${plugin.name}`);
+        await plugin.dispose(this);
+        this.logger.debug(`\u63D2\u4EF6\u5DF2\u5378\u8F7D ${plugin.name} ${Date.now() - pluginStartTime}ms`);
+      } catch (error) {
+        await this.handleError(error);
+      }
+    }
+    this.running = false;
+    await this.events.emit("stop", void 0);
+  }
+  isRunning() {
+    return this.running;
+  }
+  get api() {
+    return this.services.resolve("apiClient");
+  }
+  get transport() {
+    return this.services.get("apiTransport");
+  }
+  setMessageSender(sender) {
+    const service = this.getService("message");
+    if (service) {
+      service.registerSender(sender);
+      return this;
+    }
+    this.registerService("message", new MessageService().registerSender(sender));
+    return this;
+  }
+  getMessageService() {
+    return this.getService("message");
+  }
+  action(name, handler) {
+    this.api.on(name, handler);
+    return this;
+  }
+  actions(handlers) {
+    this.api.register(handlers);
+    return this;
+  }
+  service(name) {
+    return this.services.resolve(name);
+  }
+  getService(name) {
+    return this.services.get(name);
+  }
+  listPlugins() {
+    return this.getPluginsInOrder();
+  }
+  pluginCount() {
+    return this.plugins.size;
+  }
+  async call(request) {
+    return this.api.call(request);
+  }
+  async sendMessage(target, content, options = {}) {
+    return this.call({
+      id: `send:${Date.now()}`,
+      version: "1.0.0",
+      action: "send_message",
+      params: {
+        target,
+        content,
+        replyTo: options.replyTo
+      },
+      timestamp: Date.now()
+    });
+  }
+  async dispatch(payload) {
+    switch (payload.type) {
+      case "message": {
+        const event = new MessageEvent(payload);
+        const ctx = new Context(this, event);
+        await this.events.emit("message", { ctx, event });
+        return;
+      }
+      case "notice": {
+        const event = new NoticeEvent(payload);
+        await this.events.emit("notice", { event });
+        return;
+      }
+      case "request": {
+        const event = new RequestEvent(payload);
+        await this.events.emit("request", { event });
+        return;
+      }
+      default:
+        this.logger.warn(`Unknown event type: ${payload.type}`);
+    }
+  }
+  async handleError(error) {
+    if (this.events.listenerCount("error") === 0) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error(`\u6846\u67B6\u672A\u5904\u7406\u9519\u8BEF: ${message}`);
+      if (error instanceof Error && error.stack) {
+        this.logger.debug(error.stack);
+      }
+      return;
+    }
+    await this.events.emit("error", { error });
+  }
+  getPluginsInOrder() {
+    return [...this.plugins.values()].sort((a, b) => {
+      const aPriority = a.priority ?? 0;
+      const bPriority = b.priority ?? 0;
+      return bPriority - aPriority;
+    });
+  }
+};
+function matchCommand(input2, name, options) {
+  const text2 = input2.trim();
+  if (!text2) {
+    return null;
+  }
+  const segments = text2.split(/\s+/);
+  const head = segments[0];
+  const candidates = [name, ...options.aliases ?? []];
+  const prefixes = options.prefix === void 0 ? [""] : Array.isArray(options.prefix) ? options.prefix : [options.prefix];
+  const caseSensitive = options.caseSensitive ?? false;
+  for (const candidate of candidates) {
+    for (const prefix of prefixes) {
+      const expected = `${prefix}${candidate}`;
+      const matched = caseSensitive ? head === expected : head.toLowerCase() === expected.toLowerCase();
+      if (matched) {
+        return {
+          args: segments.slice(1),
+          rawArgs: segments.slice(1).join(" ")
+        };
+      }
+    }
+  }
+  return null;
+}
+
+// src/index.ts
+import { existsSync as existsSync2, readdirSync, statSync, readFileSync as readFileSync2 } from "fs";
+import { join as join2, resolve as resolve4 } from "path";
+import { fileURLToPath, pathToFileURL } from "url";
+
+// src/api/router.ts
+var APIRouter = class {
+  routes = /* @__PURE__ */ new Map();
+  route(action, handler) {
+    this.routes.set(action, handler);
+  }
+  match(action) {
+    return this.routes.get(action);
+  }
+  has(action) {
+    return this.routes.has(action);
+  }
+  remove(action) {
+    return this.routes.delete(action);
+  }
+  clear() {
+    this.routes.clear();
+  }
+  getActions() {
+    return Array.from(this.routes.keys());
+  }
+};
+
+// src/api/client.ts
+var APIClient = class {
+  router;
+  options;
+  constructor(options = {}) {
+    this.router = new APIRouter();
+    this.options = {
+      timeout: 3e4,
+      ...options
+    };
+  }
+  async call(request) {
+    const startTime = Date.now();
+    try {
+      const handler = this.router.match(request.action);
+      if (!handler) {
+        return this.createErrorResponse(
+          4e3,
+          `Unknown action: ${request.action}`,
+          startTime
+        );
+      }
+      const result = await Promise.race([
+        handler(request),
+        this.createTimeoutPromise(request.timeout ?? this.options.timeout)
+      ]);
+      return result;
+    } catch (error) {
+      return this.createErrorResponse(
+        5e3,
+        error instanceof Error ? error.message : "Internal error",
+        startTime,
+        error
+      );
+    }
+  }
+  on(action, handler) {
+    this.router.route(action, handler);
+    return this;
+  }
+  register(handlers) {
+    for (const [action, handler] of Object.entries(handlers)) {
+      this.router.route(action, handler);
+    }
+    return this;
+  }
+  getRouter() {
+    return this.router;
+  }
+  getActions() {
+    return this.router.getActions();
+  }
+  getActionCount() {
+    return this.router.getActions().length;
+  }
+  createErrorResponse(code, message, startTime, error) {
+    const apiError = {
+      code,
+      message,
+      details: error instanceof Error ? { stack: error.stack } : void 0
+    };
+    return {
+      status: "error",
+      error: apiError,
+      timestamp: Date.now(),
+      duration: Date.now() - startTime
+    };
+  }
+  createTimeoutPromise(timeout) {
+    return new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new Error(`Request timeout after ${timeout}ms`));
+      }, timeout);
+    });
+  }
+};
+
+// src/api/error.ts
+import { ErrorCode } from "@plume/types";
+function createSuccessResponse(data, startTime) {
+  return {
+    status: "success",
+    data,
+    timestamp: Date.now(),
+    duration: Date.now() - startTime
+  };
+}
+function createErrorResponse(code, message, startTime, details) {
+  return {
+    status: "error",
+    error: {
+      code,
+      message,
+      details
+    },
+    timestamp: Date.now(),
+    duration: Date.now() - startTime
+  };
+}
+
+// src/api/middleware.ts
+var MiddlewareChain = class {
+  middlewares = [];
+  use(middleware) {
+    this.middlewares.push(middleware);
+    return this;
+  }
+  async execute(request, handler) {
+    let index = 0;
+    const next = async () => {
+      if (index < this.middlewares.length) {
+        const middleware = this.middlewares[index++];
+        const ctx = {
+          request,
+          next
+        };
+        const result = await middleware(ctx);
+        if (result) {
+          ctx.response = result;
+          return result;
+        }
+        return ctx.response ?? next();
+      }
+      return handler();
+    };
+    return next();
+  }
+  clear() {
+    this.middlewares = [];
+  }
+};
+
+// src/api/auth.ts
+function extractToken(request) {
+  return request.token ?? null;
+}
+function createAuthMiddleware(authProvider) {
+  return async (ctx) => {
+    const token = extractToken(ctx.request);
+    if (!token) {
+      return {
+        status: "error",
+        error: { code: 2e3, message: "Unauthorized: No token provided" },
+        timestamp: Date.now(),
+        duration: 0
+      };
+    }
+    const payload = await authProvider.verify(token);
+    if (!payload) {
+      return {
+        status: "error",
+        error: { code: 2002, message: "Invalid token" },
+        timestamp: Date.now(),
+        duration: 0
+      };
+    }
+    ctx.request.auth = payload;
+    return ctx.next();
+  };
+}
+
+// src/api/transport.ts
+import { createHash, randomUUID } from "crypto";
+import { createServer } from "http";
+var DEFAULT_TRANSPORT_OPTIONS = {
+  host: "127.0.0.1",
+  port: 23333,
+  path: "/api",
+  wsPath: "/ws",
+  cors: true,
+  enableHttp: true,
+  enableWebSocket: true,
+  maxBodySize: 1024 * 1024
+};
+var APITransportServer = class {
+  apiClient;
+  logger;
+  middlewareChain = new MiddlewareChain();
+  clients = /* @__PURE__ */ new Map();
+  connections = /* @__PURE__ */ new Set();
+  options;
+  server = null;
+  address = null;
+  constructor(apiClient, options = {}, logger3) {
+    this.apiClient = apiClient;
+    this.logger = logger3;
+    this.options = {
+      ...DEFAULT_TRANSPORT_OPTIONS,
+      ...options
+    };
+    if (this.options.authProvider) {
+      this.middlewareChain.use(createAuthMiddleware(this.options.authProvider));
+    }
+    for (const middleware of this.options.middlewares ?? []) {
+      this.middlewareChain.use(middleware);
+    }
+  }
+  async start() {
+    if (this.server && this.address) {
+      return this.address;
+    }
+    this.server = createServer((request, response) => {
+      void this.handleHTTPRequest(request, response);
+    });
+    this.server.on("connection", (socket) => {
+      this.connections.add(socket);
+      socket.on("close", () => {
+        this.connections.delete(socket);
+      });
+      socket.on("error", () => {
+        this.connections.delete(socket);
+      });
+    });
+    if (this.options.enableWebSocket) {
+      this.server.on("upgrade", (request, socket, head) => {
+        this.handleUpgrade(request, socket, head);
+      });
+    }
+    await new Promise((resolve5, reject) => {
+      this.server.once("error", reject);
+      this.server.listen(this.options.port, this.options.host, () => {
+        this.server.off("error", reject);
+        resolve5();
+      });
+    });
+    this.address = {
+      host: this.options.host,
+      port: this.options.port,
+      httpUrl: this.options.enableHttp ? `http://${this.options.host}:${this.options.port}${this.options.path}` : void 0,
+      wsUrl: this.options.enableWebSocket ? `ws://${this.options.host}:${this.options.port}${this.options.wsPath}` : void 0
+    };
+    return this.address;
+  }
+  async stop() {
+    for (const client of this.clients.values()) {
+      client.socket.end();
+      client.socket.destroy();
+    }
+    this.clients.clear();
+    if (!this.server) {
+      this.connections.clear();
+      this.address = null;
+      return;
+    }
+    const server = this.server;
+    const connections = [...this.connections];
+    this.server = null;
+    this.address = null;
+    server.closeAllConnections?.();
+    for (const connection of connections) {
+      connection.destroy();
+    }
+    this.connections.clear();
+    await new Promise((resolve5, reject) => {
+      server.close((error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve5();
+      });
+    });
+  }
+  isRunning() {
+    return this.server !== null && this.address !== null;
+  }
+  isEnabled() {
+    return this.options.enableHttp || this.options.enableWebSocket;
+  }
+  getAddress() {
+    return this.address;
+  }
+  getConnectedClientCount() {
+    return this.clients.size;
+  }
+  async handleHTTPRequest(request, response) {
+    this.applyCORSHeaders(response);
+    const url = new URL(request.url ?? "/", `http://${request.headers.host ?? "127.0.0.1"}`);
+    const pathname = url.pathname;
+    const method = request.method ?? "GET";
+    if (method === "OPTIONS") {
+      response.writeHead(204);
+      response.end();
+      return;
+    }
+    if (pathname === "/health") {
+      this.writeJSON(response, 200, {
+        status: "ok",
+        timestamp: Date.now(),
+        transport: this.address
+      });
+      return;
+    }
+    if (pathname === "/actions") {
+      this.writeJSON(response, 200, {
+        status: "success",
+        data: this.apiClient.getActions(),
+        timestamp: Date.now()
+      });
+      return;
+    }
+    if (!this.options.enableHttp || pathname !== this.options.path) {
+      this.writeJSON(response, 404, {
+        status: "error",
+        error: { code: 4e3, message: `Not found: ${pathname}` },
+        timestamp: Date.now()
+      });
+      return;
+    }
+    if (method !== "POST") {
+      this.writeJSON(response, 405, {
+        status: "error",
+        error: { code: 1e3, message: `Method not allowed: ${method}` },
+        timestamp: Date.now()
+      });
+      return;
+    }
+    try {
+      const rawBody = await this.readRequestBody(request);
+      const payload = rawBody.length > 0 ? JSON.parse(rawBody) : {};
+      const apiRequest = this.normalizeRequest(payload, this.extractBearerToken(request.headers.authorization));
+      const apiResponse = await this.executeRequest(apiRequest);
+      this.writeJSON(response, 200, apiResponse);
+      this.logger?.info(`HTTP API \u8BF7\u6C42\u5B8C\u6210 | action: ${apiRequest.action} | status: ${apiResponse.status}`);
+    } catch (error) {
+      const apiResponse = createErrorResponse(
+        5e3,
+        error instanceof Error ? error.message : "Invalid request",
+        Date.now()
+      );
+      this.writeJSON(response, 400, apiResponse);
+      this.logger?.error("HTTP API \u8BF7\u6C42\u5931\u8D25", error);
+    }
+  }
+  handleUpgrade(request, socket, _head) {
+    const url = new URL(request.url ?? "/", `http://${request.headers.host ?? "127.0.0.1"}`);
+    if (!this.options.enableWebSocket || url.pathname !== this.options.wsPath) {
+      socket.write("HTTP/1.1 404 Not Found\r\n\r\n");
+      socket.destroy();
+      return;
+    }
+    const key = request.headers["sec-websocket-key"];
+    if (typeof key !== "string") {
+      socket.write("HTTP/1.1 400 Bad Request\r\n\r\n");
+      socket.destroy();
+      return;
+    }
+    const accept = this.createWebSocketAccept(key);
+    socket.write(
+      [
+        "HTTP/1.1 101 Switching Protocols",
+        "Upgrade: websocket",
+        "Connection: Upgrade",
+        `Sec-WebSocket-Accept: ${accept}`,
+        "\r\n"
+      ].join("\r\n")
+    );
+    const client = {
+      id: randomUUID(),
+      socket,
+      buffer: Buffer.alloc(0)
+    };
+    this.clients.set(client.id, client);
+    this.sendWebSocketJSON(client, {
+      type: "hello",
+      data: {
+        clientId: client.id,
+        actions: this.apiClient.getActions(),
+        timestamp: Date.now()
+      }
+    });
+    socket.on("data", (chunk) => {
+      this.handleWebSocketData(client, chunk);
+    });
+    socket.on("close", () => {
+      this.clients.delete(client.id);
+    });
+    socket.on("error", () => {
+      this.clients.delete(client.id);
+    });
+    this.logger?.info(`WebSocket \u5BA2\u6237\u7AEF\u5DF2\u8FDE\u63A5 | id: ${client.id} | total: ${this.clients.size}`);
+  }
+  handleWebSocketData(client, chunk) {
+    client.buffer = Buffer.concat([client.buffer, chunk]);
+    while (true) {
+      const parsed = this.tryParseFrame(client.buffer);
+      if (!parsed) {
+        return;
+      }
+      client.buffer = parsed.remaining;
+      const frame = parsed.frame;
+      if (frame.opcode === 8) {
+        client.socket.end();
+        this.clients.delete(client.id);
+        return;
+      }
+      if (frame.opcode === 9) {
+        this.sendWebSocketFrame(client.socket, 10, frame.payload);
+        continue;
+      }
+      if (frame.opcode !== 1) {
+        continue;
+      }
+      void this.handleWebSocketMessage(client, frame.payload.toString("utf-8"));
+    }
+  }
+  async handleWebSocketMessage(client, text2) {
+    try {
+      const payload = JSON.parse(text2);
+      const apiRequest = this.normalizeRequest(payload, typeof payload?.token === "string" ? payload.token : null);
+      const apiResponse = await this.executeRequest(apiRequest);
+      this.sendWebSocketJSON(client, {
+        type: "response",
+        id: apiRequest.id,
+        action: apiRequest.action,
+        response: apiResponse
+      });
+      this.logger?.info(`WebSocket API \u8BF7\u6C42\u5B8C\u6210 | client: ${client.id} | action: ${apiRequest.action} | status: ${apiResponse.status}`);
+    } catch (error) {
+      this.sendWebSocketJSON(client, {
+        type: "error",
+        data: {
+          message: error instanceof Error ? error.message : "Invalid websocket payload"
+        }
+      });
+      this.logger?.error(`WebSocket API \u8BF7\u6C42\u5931\u8D25 | client: ${client.id}`, error);
+    }
+  }
+  async executeRequest(request) {
+    return this.middlewareChain.execute(request, () => this.apiClient.call(request));
+  }
+  normalizeRequest(payload, token) {
+    const request = typeof payload === "object" && payload !== null ? payload : {};
+    if (typeof request.action !== "string" || request.action.trim() === "") {
+      throw new Error("Missing action in API request");
+    }
+    return {
+      id: typeof request.id === "string" && request.id.length > 0 ? request.id : randomUUID(),
+      version: typeof request.version === "string" && request.version.length > 0 ? request.version : "1.0.0",
+      action: request.action,
+      params: request.params ?? {},
+      timestamp: typeof request.timestamp === "number" ? request.timestamp : Date.now(),
+      timeout: typeof request.timeout === "number" ? request.timeout : void 0,
+      token: request.token ?? token ?? void 0
+    };
+  }
+  async readRequestBody(request) {
+    return new Promise((resolve5, reject) => {
+      let size = 0;
+      const chunks = [];
+      request.on("data", (chunk) => {
+        size += chunk.length;
+        if (size > this.options.maxBodySize) {
+          reject(new Error(`Request body exceeds limit: ${this.options.maxBodySize}`));
+          request.destroy();
+          return;
+        }
+        chunks.push(chunk);
+      });
+      request.on("end", () => {
+        resolve5(Buffer.concat(chunks).toString("utf-8"));
+      });
+      request.on("error", reject);
+    });
+  }
+  applyCORSHeaders(response) {
+    if (!this.options.cors) {
+      return;
+    }
+    response.setHeader("Access-Control-Allow-Origin", "*");
+    response.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+    response.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+  }
+  extractBearerToken(header) {
+    if (!header) {
+      return null;
+    }
+    const match = /^Bearer\s+(.+)$/i.exec(header);
+    return match?.[1] ?? null;
+  }
+  writeJSON(response, statusCode, payload) {
+    response.writeHead(statusCode, {
+      "Content-Type": "application/json; charset=utf-8"
+    });
+    response.end(JSON.stringify(payload));
+  }
+  createWebSocketAccept(key) {
+    return createHash("sha1").update(`${key}258EAFA5-E914-47DA-95CA-C5AB0DC85B11`).digest("base64");
+  }
+  sendWebSocketJSON(client, payload) {
+    this.sendWebSocketFrame(client.socket, 1, Buffer.from(JSON.stringify(payload), "utf-8"));
+  }
+  sendWebSocketFrame(socket, opcode, payload) {
+    const length = payload.length;
+    let header;
+    if (length < 126) {
+      header = Buffer.from([128 | opcode, length]);
+    } else if (length <= 65535) {
+      header = Buffer.alloc(4);
+      header[0] = 128 | opcode;
+      header[1] = 126;
+      header.writeUInt16BE(length, 2);
+    } else {
+      header = Buffer.alloc(10);
+      header[0] = 128 | opcode;
+      header[1] = 127;
+      header.writeBigUInt64BE(BigInt(length), 2);
+    }
+    socket.write(Buffer.concat([header, payload]));
+  }
+  tryParseFrame(buffer) {
+    if (buffer.length < 2) {
+      return null;
+    }
+    const firstByte = buffer[0];
+    const secondByte = buffer[1];
+    const fin = (firstByte & 128) !== 0;
+    const opcode = firstByte & 15;
+    const masked = (secondByte & 128) !== 0;
+    let payloadLength = secondByte & 127;
+    let offset = 2;
+    if (payloadLength === 126) {
+      if (buffer.length < offset + 2) {
+        return null;
+      }
+      payloadLength = buffer.readUInt16BE(offset);
+      offset += 2;
+    } else if (payloadLength === 127) {
+      if (buffer.length < offset + 8) {
+        return null;
+      }
+      payloadLength = Number(buffer.readBigUInt64BE(offset));
+      offset += 8;
+    }
+    const maskLength = masked ? 4 : 0;
+    if (buffer.length < offset + maskLength + payloadLength) {
+      return null;
+    }
+    const maskingKey = masked ? buffer.subarray(offset, offset + 4) : void 0;
+    offset += maskLength;
+    const payload = Buffer.from(buffer.subarray(offset, offset + payloadLength));
+    if (masked && maskingKey) {
+      for (let index = 0; index < payload.length; index += 1) {
+        payload[index] ^= maskingKey[index % 4];
+      }
+    }
+    return {
+      frame: { fin, opcode, payload },
+      remaining: buffer.subarray(offset + payloadLength)
+    };
+  }
+};
+
+// src/adapter.ts
+var Bot = class {
+  constructor(app, options) {
+    this.app = app;
+    this.id = options.id;
+    this.adapter = options.adapter;
+    this.logger = options.logger ?? new LogService({
+      prefix: options.loggerPrefix ?? `bot:${options.adapter}:${options.id}`
+    });
+  }
+  app;
+  logger;
+  id;
+  adapter;
+  async dispatchEvent(event) {
+    return this.app.call({
+      id: `dispatch:${Date.now()}`,
+      version: "1.0.0",
+      action: "dispatch_event",
+      params: { event },
+      timestamp: Date.now()
+    });
+  }
+  async sendMessage(target, content, options = {}) {
+    return this.app.sendMessage(target, content, options);
+  }
+};
+function normalizeEventPayload(event) {
+  switch (event.type) {
+    case "message":
+      return isMessagePayload(event) ? event : normalizeMessageEvent(event);
+    case "notice":
+      return isNoticePayload(event) ? event : normalizeNoticeEvent(event);
+    case "request":
+      return isRequestPayload(event) ? event : normalizeRequestEvent(event);
+  }
+  throw new TypeError(`Unsupported event type: ${event.type}`);
+}
+function buildEventLog(event, _options = {}) {
+  const payload = normalizeEventPayload(event);
+  switch (payload.type) {
+    case "message":
+      return buildMessageEventLog(payload);
+    case "notice":
+      return buildNoticeEventLog(payload);
+    case "request":
+      return buildRequestEventLog(payload);
+  }
+}
+function buildSendMessageLog(input2, _options = {}) {
+  return formatLogLine(
+    describeSendMessageTitle(input2.target.type),
+    formatOutboundTarget(input2.target),
+    input2.replyTo ? `[reply:${input2.replyTo}]` : void 0,
+    formatPreview(extractMessageText(input2.content))
+  );
+}
+function normalizeMessageEvent(event) {
+  const content = normalizeMessageContent(event.content);
+  return {
+    type: "message",
+    selfId: event.selfId,
+    timestamp: event.timestamp ?? Date.now(),
+    raw: event.raw ?? event,
+    messageId: event.messageId ?? createGeneratedId("msg", event.selfId),
+    content,
+    text: normalizeText(event.text, content),
+    sender: event.sender,
+    target: event.target
+  };
+}
+function normalizeNoticeEvent(event) {
+  return {
+    type: "notice",
+    selfId: event.selfId,
+    timestamp: event.timestamp ?? Date.now(),
+    raw: event.raw ?? event,
+    subtype: event.subtype,
+    operator: event.operator,
+    targetUser: event.targetUser,
+    group: event.group,
+    data: event.data
+  };
+}
+function normalizeRequestEvent(event) {
+  return {
+    type: "request",
+    selfId: event.selfId,
+    timestamp: event.timestamp ?? Date.now(),
+    raw: event.raw ?? event,
+    subtype: event.subtype,
+    requestId: event.requestId ?? createGeneratedId("req", event.selfId),
+    sender: event.sender,
+    group: event.group,
+    comment: event.comment
+  };
+}
+function isMessagePayload(event) {
+  return event.type === "message" && typeof event.messageId === "string" && typeof event.text === "string" && typeof event.timestamp === "number" && "raw" in event;
+}
+function isNoticePayload(event) {
+  return event.type === "notice" && typeof event.timestamp === "number" && "raw" in event;
+}
+function isRequestPayload(event) {
+  return event.type === "request" && typeof event.requestId === "string" && typeof event.timestamp === "number" && "raw" in event;
+}
+function normalizeText(text2, content) {
+  const value = text2?.trim();
+  if (value) {
+    return value;
+  }
+  return extractMessageText(content);
+}
+function createGeneratedId(prefix, selfId) {
+  return `${prefix}:${selfId}:${Date.now()}`;
+}
+function buildMessageEventLog(payload) {
+  if (payload.target.type === "group") {
+    return formatLogLine(
+      "Group message",
+      `[${payload.target.id}-${payload.sender.id}]`,
+      formatPreview(payload.text)
+    );
+  }
+  return formatLogLine(
+    "Private message",
+    `[${payload.sender.id}]`,
+    formatPreview(payload.text)
+  );
+}
+function buildNoticeEventLog(payload) {
+  if (payload.group?.id) {
+    return formatLogLine(
+      "Group notice",
+      formatGroupNoticeIdentity(payload),
+      describeNoticeSubtype(payload.subtype)
+    );
+  }
+  if (payload.targetUser?.id) {
+    return formatLogLine(
+      "Friend notice",
+      `[${payload.targetUser.id}]`,
+      describeNoticeSubtype(payload.subtype)
+    );
+  }
+  return formatLogLine(
+    "Notice",
+    describeNoticeSubtype(payload.subtype)
+  );
+}
+function buildRequestEventLog(payload) {
+  if (payload.group?.id) {
+    return formatLogLine(
+      "Group request",
+      `[${payload.group.id}-${payload.sender.id}]`,
+      formatRequestComment(payload.comment)
+    );
+  }
+  return formatLogLine(
+    "Friend request",
+    `[${payload.sender.id}]`,
+    formatRequestComment(payload.comment)
+  );
+}
+function formatPreview(text2) {
+  const normalized = text2.replace(/\s+/g, " ").trim();
+  if (!normalized) {
+    return "[\u7A7A\u6D88\u606F]";
+  }
+  return normalized.length > 48 ? `${normalized.slice(0, 45)}...` : normalized;
+}
+function formatLogLine(title, ...parts) {
+  return [title, ...parts.filter((part) => Boolean(part))].join(" ");
+}
+function describeSendMessageTitle(type) {
+  return type === "group" ? "Send group message" : "Send private message";
+}
+function formatOutboundTarget(target) {
+  return target.type === "group" ? `[${target.id}]` : `[${target.id}]`;
+}
+function formatGroupNoticeIdentity(payload) {
+  const userId = payload.targetUser?.id ?? payload.operator?.id;
+  return userId ? `[${payload.group.id}-${userId}]` : `[${payload.group.id}]`;
+}
+function formatRequestComment(comment) {
+  const value = comment?.trim();
+  return value ? formatPreview(value) : void 0;
+}
+function describeNoticeSubtype(subtype) {
+  switch (subtype) {
+    case "group_increase":
+      return "\u7FA4\u6210\u5458\u589E\u52A0";
+    case "group_decrease":
+      return "\u7FA4\u6210\u5458\u51CF\u5C11";
+    case "group_admin":
+      return "\u7FA4\u7BA1\u7406\u53D8\u66F4";
+    case "group_upload":
+      return "\u7FA4\u6587\u4EF6\u4E0A\u4F20";
+    case "friend_add":
+      return "\u65B0\u589E\u597D\u53CB";
+    case "friend_recall":
+      return "\u597D\u53CB\u64A4\u56DE";
+    case "group_recall":
+      return "\u7FA4\u6D88\u606F\u64A4\u56DE";
+    case "group_ban":
+      return "\u7FA4\u7981\u8A00";
+    case "group_lift_ban":
+      return "\u89E3\u9664\u7981\u8A00";
+  }
+}
+
+// src/api/standard.ts
+var STANDARD_ACTION_NAMES = [
+  "get_framework_info",
+  "get_plugin_list",
+  "get_service_list",
+  "get_action_list",
+  "get_runtime_snapshot",
+  "dispatch_event",
+  "send_message"
+];
+function getServiceKind(service) {
+  if (service === null) return "null";
+  if (service === void 0) return "undefined";
+  if (typeof service === "object" && service.constructor?.name) {
+    return service.constructor.name;
+  }
+  return typeof service;
+}
+function createTypedErrorResponse(code, message, startTime) {
+  return createErrorResponse(code, message, startTime);
+}
+function createStandardActions(app, apiClient, startedAt) {
+  return {
+    get_framework_info: () => {
+      const startTime = Date.now();
+      return createSuccessResponse(
+        {
+          name: app.name,
+          running: app.isRunning(),
+          uptime: app.isRunning() ? Date.now() - startedAt : 0,
+          startedAt,
+          pluginCount: app.pluginCount(),
+          serviceCount: app.services.size(),
+          actionCount: apiClient.getActionCount()
+        },
+        startTime
+      );
+    },
+    get_plugin_list: () => {
+      const startTime = Date.now();
+      return createSuccessResponse(
+        app.listPlugins().map((plugin) => ({
+          name: plugin.name,
+          version: plugin.version,
+          priority: plugin.priority ?? 0
+        })),
+        startTime
+      );
+    },
+    get_service_list: () => {
+      const startTime = Date.now();
+      return createSuccessResponse(
+        app.services.entries().map(([name, service]) => ({
+          name,
+          kind: getServiceKind(service)
+        })),
+        startTime
+      );
+    },
+    get_action_list: () => {
+      const startTime = Date.now();
+      return createSuccessResponse(
+        apiClient.getActions(),
+        startTime
+      );
+    },
+    get_runtime_snapshot: () => {
+      const startTime = Date.now();
+      return createSuccessResponse(
+        {
+          framework: {
+            name: app.name,
+            running: app.isRunning(),
+            uptime: app.isRunning() ? Date.now() - startedAt : 0
+          },
+          plugins: app.listPlugins().map((plugin) => plugin.name),
+          services: app.services.keys(),
+          actions: apiClient.getActions()
+        },
+        startTime
+      );
+    },
+    dispatch_event: async (request) => {
+      const startTime = Date.now();
+      const params = request.params;
+      if (!params || typeof params !== "object" || !("event" in params)) {
+        return createTypedErrorResponse(1e3, "Invalid dispatch_event params", startTime);
+      }
+      const rawEvent = params.event;
+      if (!rawEvent || typeof rawEvent !== "object" || !("type" in rawEvent) || !("selfId" in rawEvent)) {
+        return createTypedErrorResponse(1e3, "Invalid dispatch_event event payload", startTime);
+      }
+      const payload = normalizeEventPayload(rawEvent);
+      app.logger.info(buildEventLog(payload));
+      await app.dispatch(payload);
+      return createSuccessResponse({
+        type: payload.type,
+        timestamp: payload.timestamp,
+        selfId: payload.selfId
+      }, startTime);
+    },
+    send_message: async (request) => {
+      const startTime = Date.now();
+      const messageService = app.services.get("message");
+      const params = request.params;
+      if (!params || typeof params !== "object" || !("target" in params) || !("content" in params)) {
+        return createTypedErrorResponse(1e3, "Invalid send_message params", startTime);
+      }
+      if (!messageService?.hasSender()) {
+        return createTypedErrorResponse(5001, "\u6D88\u606F\u53D1\u9001\u5668\u672A\u6CE8\u518C", startTime);
+      }
+      app.logger.info(buildSendMessageLog(params));
+      const result = await messageService.sendMessage(params);
+      return createSuccessResponse(result, startTime);
+    }
+  };
+}
+function registerStandardActions(app, apiClient, startedAt) {
+  const actions = createStandardActions(app, apiClient, startedAt);
+  const actionNames = [];
+  for (const [name, handler] of Object.entries(actions)) {
+    apiClient.on(name, handler);
+    actionNames.push(name);
+  }
+  return actionNames;
+}
+
+// src/plugin/base.ts
+function definePlugin(options) {
+  return {
+    name: options.name,
+    version: options.version,
+    priority: options.priority,
+    setup: options.setup,
+    dispose: options.dispose
+  };
+}
+
+// src/plugin/hooks/lifecycle.ts
+var LifecycleHookManager = class {
+  hooks = /* @__PURE__ */ new Map();
+  on(name, handler) {
+    if (!this.hooks.has(name)) {
+      this.hooks.set(name, /* @__PURE__ */ new Set());
+    }
+    this.hooks.get(name).add(handler);
+    return this;
+  }
+  off(name, handler) {
+    const handlers = this.hooks.get(name);
+    if (handlers) {
+      return handlers.delete(handler);
+    }
+    return false;
+  }
+  async emit(name, app) {
+    const handlers = this.hooks.get(name);
+    if (!handlers || handlers.size === 0) return;
+    for (const handler of handlers) {
+      try {
+        await handler(app);
+      } catch (error) {
+        app.logger.error(`Lifecycle hook '${name}' error:`, error);
+      }
+    }
+  }
+  has(name) {
+    const handlers = this.hooks.get(name);
+    return handlers !== void 0 && handlers.size > 0;
+  }
+  count(name) {
+    return this.hooks.get(name)?.size ?? 0;
+  }
+  clear(name) {
+    if (name) {
+      this.hooks.delete(name);
+    } else {
+      this.hooks.clear();
+    }
+  }
+};
+
+// src/plugin/hooks/error.ts
+var ErrorHooks = class {
+  hooks = /* @__PURE__ */ new Map();
+  app;
+  handleUnhandledRejection = (reason) => {
+    const error = reason instanceof Error ? reason : new Error(String(reason));
+    void this.emit("onUnhandledRejection", error);
+  };
+  handleUncaughtException = (error) => {
+    void this.emit("onUncaughtException", error);
+  };
+  globalHandlersAttached = false;
+  constructor(app) {
+    this.app = app;
+    this.setupGlobalHandlers();
+  }
+  on(name, handler) {
+    if (!this.hooks.has(name)) {
+      this.hooks.set(name, /* @__PURE__ */ new Set());
+    }
+    this.hooks.get(name).add(handler);
+    return this;
+  }
+  off(name, handler) {
+    return this.hooks.get(name)?.delete(handler) ?? false;
+  }
+  async emit(name, error, context) {
+    const handlers = this.hooks.get(name);
+    if (!handlers || handlers.size === 0) {
+      if (name === "onError") {
+        return false;
+      }
+      this.app.logger.error(`[${name}] ${error.message}`);
+      if (error.stack) {
+        this.app.logger.debug(error.stack);
+      }
+      return false;
+    }
+    for (const handler of handlers) {
+      try {
+        const result = await handler(error, context);
+        if (result === true) {
+          return true;
+        }
+      } catch (handlerError) {
+        const message = handlerError instanceof Error ? handlerError.message : String(handlerError);
+        this.app.logger.error(`Error in error hook '${name}': ${message}`);
+        if (handlerError instanceof Error && handlerError.stack) {
+          this.app.logger.debug(handlerError.stack);
+        }
+      }
+    }
+    return false;
+  }
+  setupGlobalHandlers() {
+    if (this.globalHandlersAttached) {
+      return;
+    }
+    process.on("unhandledRejection", this.handleUnhandledRejection);
+    process.on("uncaughtException", this.handleUncaughtException);
+    this.globalHandlersAttached = true;
+  }
+  has(name) {
+    const handlers = this.hooks.get(name);
+    return handlers !== void 0 && handlers.size > 0;
+  }
+  count(name) {
+    return this.hooks.get(name)?.size ?? 0;
+  }
+  clear(name) {
+    if (name) {
+      this.hooks.delete(name);
+    } else {
+      this.hooks.clear();
+    }
+  }
+  destroy() {
+    if (this.globalHandlersAttached) {
+      process.off("unhandledRejection", this.handleUnhandledRejection);
+      process.off("uncaughtException", this.handleUncaughtException);
+      this.globalHandlersAttached = false;
+    }
+    this.clear();
+  }
+};
+
+// src/console-adapter.ts
+import { createInterface } from "readline";
+import { stdin as input, stdout as output } from "process";
+var REQUIRED_STANDARD_ACTIONS = ["get_action_list", "dispatch_event", "send_message"];
+function createConsoleAdapter(options = {}) {
+  const runtime = {
+    rl: null,
+    sequence: 0
+  };
+  return definePlugin({
+    name: "adapter-console",
+    version: "1.0.0",
+    async setup(app) {
+      const bot = new Bot(app, {
+        id: options.selfId ?? "console-bot",
+        adapter: options.adapter ?? "console",
+        loggerPrefix: options.loggerPrefix ?? "console"
+      });
+      await ensureStandardActions(app);
+      app.registerService("bot", bot);
+      app.registerService("consoleBot", bot);
+      app.setMessageSender(createConsoleSender(bot, runtime));
+      runtime.rl = createConsoleInterface();
+      runtime.rl.on("line", (line) => {
+        void handleConsoleLine(line, bot, options, runtime);
+      });
+      bot.logger.info("\u63A7\u5236\u53F0\u9002\u914D\u5668\u5DF2\u542F\u52A8");
+    },
+    async dispose(app) {
+      runtime.rl?.close();
+      runtime.rl = null;
+      app.getMessageService()?.clearSender();
+    }
+  });
+}
+function createConsoleSender(bot, runtime) {
+  return {
+    async sendMessage(params) {
+      const timestamp = Date.now();
+      const messageId = `console:out:${++runtime.sequence}`;
+      output.write(`${formatOutgoingMessage(params.content)}
+`);
+      bot.logger.debug(`\u63A7\u5236\u53F0\u6D88\u606F\u5DF2\u8F93\u51FA  id=${messageId}`);
+      return {
+        messageId,
+        timestamp
+      };
+    }
+  };
+}
+async function ensureStandardActions(app) {
+  const response = await app.call(createRequest("get_action_list", {}));
+  if (response.status !== "success" || !response.data) {
+    throw new Error("\u65E0\u6CD5\u8BFB\u53D6\u5E94\u7528\u6807\u51C6\u63A5\u53E3\u52A8\u4F5C\u5217\u8868");
+  }
+  for (const action of REQUIRED_STANDARD_ACTIONS) {
+    if (!response.data.includes(action)) {
+    }
+  }
+}
+async function handleConsoleLine(line, bot, options, runtime) {
+  try {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      return;
+    }
+    const event = createDefaultMessageEvent(trimmed, bot, options, runtime);
+    const response = await bot.dispatchEvent(event);
+    if (response.status === "error") {
+      const message = response.error?.message ?? "unknown error";
+      bot.logger.error(`\u63A7\u5236\u53F0\u4E8B\u4EF6\u5206\u53D1\u5931\u8D25: ${message}`);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    bot.logger.error(`\u63A7\u5236\u53F0\u8F93\u5165\u65E0\u6548: ${message}`);
+  }
+}
+function createDefaultMessageEvent(text2, bot, options, runtime) {
+  const userId = options.userId ?? "1145114";
+  const target = options.targetType === "group" ? { type: "group", id: options.groupId ?? "123456" } : { type: "private", id: userId };
+  return createMessageEvent(bot, runtime, {
+    content: text2,
+    sender: createUser(userId, options.nickname),
+    target
+  });
+}
+function createMessageEvent(bot, runtime, input2) {
+  const content = normalizeMessageContent(input2.content);
+  return {
+    type: "message",
+    selfId: bot.id,
+    adapter: bot.adapter,
+    timestamp: Date.now(),
+    raw: input2,
+    messageId: `console:in:${++runtime.sequence}`,
+    text: extractMessageText(content),
+    content,
+    sender: input2.sender,
+    target: input2.target
+  };
+}
+function createUser(userId, nickname) {
+  return {
+    id: userId,
+    nickname: nickname ?? userId
+  };
+}
+function createConsoleInterface() {
+  const rl = createInterface({ input, output, terminal: true });
+  return rl;
+}
+function formatOutgoingMessage(content) {
+  return `[console] ${formatMessageContent(content)}`;
+}
+function createRequest(action, params) {
+  return {
+    id: `console:${action}:${Date.now()}`,
+    version: "1.0.0",
+    action,
+    params,
+    timestamp: Date.now()
+  };
+}
+
+// src/index.ts
+var START_SIGNALS = ["SIGINT", "SIGTERM"];
+var currentApp = null;
+var startPromise = null;
+var stopPromise = null;
+var disposeSignalHandlers = null;
+var logger = globalThis.logger ?? createPackageLogger();
+globalThis.logger = logger;
+function createApp(config = {}) {
+  return new App(config);
+}
+function getFrameworkServices(app) {
+  const logger3 = app.services.get("logger") ?? app.services.get("log") ?? registerLoggerService(app, {
+    prefix: app.name,
+    timestamp: true
+  });
+  const lifecycleHooks = app.services.get("lifecycleHooks") ?? app.services.get("lifecycle") ?? registerLifecycleHooks(app);
+  const errorHooks = app.services.get("errorHooks") ?? app.services.get("errors") ?? registerErrorHooks(app);
+  const apiClient = app.services.get("apiClient") ?? registerAPIService(app);
+  const builtInActions = app.services.get("builtInActions") ?? [...STANDARD_ACTION_NAMES];
+  const transportServer = app.services.get("apiTransport") ?? registerAPITransport(app, apiClient, logger3, void 0);
+  const config = app.services.get("config") ?? registerConfigService(app);
+  return {
+    logger: logger3,
+    lifecycleHooks,
+    errorHooks,
+    apiClient,
+    builtInActions,
+    transportServer,
+    config
+  };
+}
+async function start(optionsOrSetup = {}) {
+  const options = typeof optionsOrSetup === "function" ? { setup: optionsOrSetup } : optionsOrSetup;
+  const plugins = resolveStartPlugins(options.plugins);
+  if (startPromise) {
+    return startPromise;
+  }
+  startPromise = (async () => {
+    if (currentApp?.isRunning()) {
+      return currentApp;
+    }
+    const app = options.app ?? createApp(options);
+    currentApp = app;
+    const startTime = Date.now();
+    const services = setupFramework(app, options);
+    logStartupBanner(services.logger, app);
+    try {
+      logRuntimeConfig(services.logger, services.config);
+      await services.lifecycleHooks.emit("beforeStart", app);
+      for (const plugin of plugins) {
+        app.use(plugin);
+      }
+      if (options.services) {
+        for (const [name, service] of Object.entries(options.services)) {
+          app.registerService(name, service);
+        }
+      }
+      if (options.setup) {
+        await options.setup(app);
+      }
+      await loadPackageApps(app, services.logger);
+      logPluginSummary(services.logger, app);
+      logStandardInterface(services.logger, services.apiClient);
+      await app.start();
+      await services.lifecycleHooks.emit("afterStart", app);
+      const transportAddress = await startTransport(services.transportServer, services.logger);
+      const duration = Date.now() - startTime;
+      logStartupSummary(
+        services.logger,
+        app,
+        services.apiClient,
+        services.builtInActions,
+        transportAddress,
+        duration
+      );
+      if (options.onStarted) {
+        await options.onStarted(app);
+      }
+      return app;
+    } catch (error) {
+      const startupError = error instanceof Error ? error : new Error(String(error));
+      await services.errorHooks.emit("onError", startupError, { phase: "start", appName: app.name });
+      await cleanupRuntime(app);
+      throw startupError;
+    }
+  })().finally(() => {
+    startPromise = null;
+  });
+  return startPromise;
+}
+async function stop(app = currentApp) {
+  if (!app) {
+    return;
+  }
+  if (stopPromise) {
+    return stopPromise;
+  }
+  stopPromise = (async () => {
+    const { logger: logger3, lifecycleHooks, errorHooks, transportServer } = getFrameworkServices(app);
+    try {
+      await lifecycleHooks.emit("beforeStop", app);
+      if (transportServer.isRunning()) {
+        await transportServer.stop();
+        logger3.info("\u5BF9\u5916\u4F20\u8F93\u5165\u53E3\u5DF2\u5173\u95ED");
+      }
+      if (app.isRunning()) {
+        await app.stop();
+      }
+      await lifecycleHooks.emit("afterStop", app);
+      logger3.info(`Plume \u5E94\u7528\u5DF2\u505C\u6B62 | name: ${app.name}`);
+    } catch (error) {
+      const stopError = error instanceof Error ? error : new Error(String(error));
+      await errorHooks.emit("onError", stopError, { phase: "stop", appName: app.name });
+      throw stopError;
+    } finally {
+      await cleanupRuntime(app);
+    }
+  })().finally(() => {
+    stopPromise = null;
+  });
+  return stopPromise;
+}
+function setupFramework(app, options) {
+  const config = registerConfigService(app, options.config);
+  if (options.config?.initialize !== false) {
+    config.initialize({
+      path: options.config?.path
+    });
+  }
+  config.reload();
+  const logger3 = registerLoggerService(app, {
+    level: options.logger?.level ?? config.get("log.level", "info"),
+    prefix: options.logger?.prefix ?? app.name,
+    timestamp: config.get("log.timestamp", true)
+  });
+  app.logger.setLevel(options.logger?.level ?? config.get("log.level", "info"));
+  const lifecycleHooks = registerLifecycleHooks(app);
+  const errorHooks = registerErrorHooks(app);
+  registerMessageService(app);
+  const apiClient = registerAPIService(app);
+  const builtInActions = registerStandardActions(app, apiClient, Date.now());
+  app.registerService("builtInActions", builtInActions);
+  app.registerService("apiStandard", createStandardInterfaceDescriptor(apiClient));
+  const transportOptions = resolveTransportOptions(config, options.transport);
+  const transportServer = registerAPITransport(app, apiClient, logger3, transportOptions);
+  registerSignalHandlers(app, logger3);
+  return {
+    logger: logger3,
+    lifecycleHooks,
+    errorHooks,
+    apiClient,
+    builtInActions,
+    transportServer,
+    config
+  };
+}
+function registerConfigService(app, options) {
+  const existingConfig = app.services.get("config");
+  if (existingConfig) {
+    return existingConfig;
+  }
+  const config = new ConfigService(options);
+  app.registerService("config", config);
+  return config;
+}
+function registerLoggerService(app, options) {
+  const existingLogger = app.services.get("logger") ?? app.services.get("log");
+  if (existingLogger) {
+    return existingLogger;
+  }
+  const logger3 = new LogService(options);
+  app.registerService("logger", logger3);
+  app.registerService("log", logger3);
+  return logger3;
+}
+function registerLifecycleHooks(app) {
+  const existingHooks = app.services.get("lifecycleHooks") ?? app.services.get("lifecycle");
+  if (existingHooks) {
+    return existingHooks;
+  }
+  const lifecycleHooks = new LifecycleHookManager();
+  app.registerService("lifecycleHooks", lifecycleHooks);
+  app.registerService("lifecycle", lifecycleHooks);
+  return lifecycleHooks;
+}
+function registerErrorHooks(app) {
+  const existingHooks = app.services.get("errorHooks") ?? app.services.get("errors");
+  if (existingHooks) {
+    return existingHooks;
+  }
+  const errorHooks = new ErrorHooks(app);
+  app.registerService("errorHooks", errorHooks);
+  app.registerService("errors", errorHooks);
+  return errorHooks;
+}
+function registerAPIService(app) {
+  const existingClient = app.services.get("apiClient");
+  if (existingClient) {
+    return existingClient;
+  }
+  const apiClient = new APIClient();
+  app.registerService("apiClient", apiClient);
+  app.registerService("apiRouter", apiClient.getRouter());
+  app.registerService("apiStandard", createStandardInterfaceDescriptor(apiClient));
+  app.registerService("builtInActions", [...STANDARD_ACTION_NAMES]);
+  return apiClient;
+}
+function registerMessageService(app) {
+  const existingService = app.services.get("message");
+  if (existingService) {
+    return existingService;
+  }
+  const messageService = new MessageService();
+  app.registerService("message", messageService);
+  return messageService;
+}
+function registerAPITransport(app, apiClient, logger3, options) {
+  const existingTransport = app.services.get("apiTransport");
+  if (existingTransport) {
+    return existingTransport;
+  }
+  const transportServer = new APITransportServer(apiClient, options, logger3);
+  app.registerService("apiTransport", transportServer);
+  return transportServer;
+}
+function registerSignalHandlers(app, logger3) {
+  disposeSignalHandlers?.();
+  let shuttingDown = false;
+  const listeners = START_SIGNALS.map((signal) => {
+    const listener = () => {
+      if (shuttingDown) {
+        return;
+      }
+      shuttingDown = true;
+      logger3.warn(`\u6536\u5230\u4FE1\u53F7 ${signal}\uFF0C\u51C6\u5907\u505C\u6B62\u5E94\u7528...`);
+      void stop(app).finally(() => {
+        process.exit(0);
+      });
+    };
+    process.on(signal, listener);
+    return { signal, listener };
+  });
+  disposeSignalHandlers = () => {
+    for (const { signal, listener } of listeners) {
+      process.off(signal, listener);
+    }
+    disposeSignalHandlers = null;
+  };
+}
+async function cleanupRuntime(app) {
+  if (currentApp === app) {
+    currentApp = null;
+  }
+  const transportServer = app.services.get("apiTransport");
+  if (transportServer?.isRunning()) {
+    await transportServer.stop().catch(() => void 0);
+  }
+  app.services.get("errorHooks")?.destroy();
+  disposeSignalHandlers?.();
+}
+function logStartupBanner(logger3, app) {
+  logger3.info(`Plume \u542F\u52A8\u4E2D  app=${app.name}  cwd=${process.cwd()}`);
+}
+function logStartupSummary(logger3, app, apiClient, builtInActions, transportAddress, duration) {
+  logger3.info(`\u542F\u52A8\u5B8C\u6210  app=${app.name}  duration=${duration}ms  plugins=${app.pluginCount()}  actions=${apiClient.getActionCount()}`);
+  if (transportAddress) {
+    logger3.info(`HTTP  ${transportAddress.httpUrl ?? "disabled"}`);
+    logger3.info(`WS    ${transportAddress.wsUrl ?? "disabled"}`);
+  }
+  if (builtInActions.length > 0) {
+    logger3.debug(`\u5185\u7F6E\u52A8\u4F5C\u6570\u91CF  ${builtInActions.length}`);
+  }
+}
+function logStandardInterface(logger3, apiClient) {
+  logger3.info(`\u63A5\u53E3\u5DF2\u5C31\u7EEA  actions=${apiClient.getActionCount()}`);
+}
+function logRuntimeConfig(logger3, config) {
+  logger3.info(
+    `\u914D\u7F6E  host=${config.get("transport.host")}  port=${config.get("transport.port")}  level=${config.get("log.level")}  source=${config.getSource("transport.port") ?? "default"}`
+  );
+}
+function logPluginSummary(logger3, app) {
+  logger3.info(`\u63D2\u4EF6  count=${app.pluginCount()}  names=${formatList(app.listPlugins().map((plugin) => plugin.name))}`);
+}
+function createStandardInterfaceDescriptor(apiClient) {
+  return {
+    requestFormat: "APIRequest",
+    responseFormat: "APIResponse",
+    authProvider: "TokenAuth",
+    middleware: "MiddlewareChain",
+    actions: apiClient.getActions()
+  };
+}
+async function loadPackageApps(app, logger3) {
+  const packageMetadata = readCurrentPackageMetadata();
+  const manifest = packageMetadata?.plume ?? null;
+  if (!manifest) {
+    resumePackageLogger();
+    return;
+  }
+  const directories = resolveManifestAppDirectories(manifest);
+  if (directories.length === 0) {
+    resumePackageLogger();
+    return;
+  }
+  const loadedFiles = /* @__PURE__ */ new Set();
+  for (const directory of directories) {
+    if (!existsSync2(directory) || !statSync(directory).isDirectory()) {
+      continue;
+    }
+    for (const filePath of collectAppModuleFiles(directory)) {
+      if (loadedFiles.has(filePath)) {
+        continue;
+      }
+      loadedFiles.add(filePath);
+    }
+  }
+  if (isPluginPackage(packageMetadata) && loadedFiles.size > 0) {
+    logger3.info(`\u6B63\u5728\u52A0\u8F7D\u63D2\u4EF6  count=${loadedFiles.size}`);
+  }
+  resumePackageLogger();
+  for (const filePath of loadedFiles) {
+    const module = await importAppModule(filePath);
+    await registerAppModule(app, module, filePath);
+  }
+}
+function formatList(items) {
+  return items.length > 0 ? items.join(", ") : "none";
+}
+function createPackageLogger() {
+  const packageLogger = new LogService();
+  packageLogger.suspend();
+  return packageLogger;
+}
+function resumePackageLogger() {
+  logger.resume();
+}
+function readCurrentPackageMetadata() {
+  const packageJsonPath = resolve4(process.cwd(), "package.json");
+  if (!existsSync2(packageJsonPath)) {
+    return null;
+  }
+  try {
+    return JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function isPluginPackage(metadata) {
+  const packageName = metadata?.name?.trim();
+  if (!packageName) {
+    return false;
+  }
+  return packageName.includes("plugin");
+}
+function resolveManifestAppDirectories(manifest) {
+  const isTypeScriptEntry = /\.(?:ts|tsx|mts|cts)$/i.test(process.argv[1] ?? "");
+  const preferredDirs = isTypeScriptEntry ? manifest.sourceAppDirs ?? manifest.appDirs ?? [] : manifest.appDirs ?? manifest.sourceAppDirs ?? [];
+  const fallbackDirs = isTypeScriptEntry ? manifest.appDirs ?? [] : manifest.sourceAppDirs ?? [];
+  return [...preferredDirs, ...fallbackDirs].map((path) => resolve4(process.cwd(), path));
+}
+function collectAppModuleFiles(directory) {
+  const files = [];
+  for (const entry of readdirSync(directory)) {
+    const fullPath = join2(directory, entry);
+    const stats = statSync(fullPath);
+    if (stats.isDirectory()) {
+      files.push(...collectAppModuleFiles(fullPath));
+      continue;
+    }
+    if (isAppModuleFile(fullPath)) {
+      files.push(fullPath);
+    }
+  }
+  return files.sort();
+}
+function isAppModuleFile(filePath) {
+  if (filePath.endsWith(".d.ts") || filePath.endsWith(".map")) {
+    return false;
+  }
+  return /\.(?:js|mjs|cjs|ts|mts|cts)$/i.test(filePath);
+}
+async function importAppModule(filePath) {
+  return import(pathToFileURL(filePath).href);
+}
+async function registerAppModule(app, module, filePath) {
+  if (isAppModuleDefinition(module.default)) {
+    await applyAppModuleDefinition(app, module.default);
+    return;
+  }
+  if (typeof module.default === "function") {
+    await module.default(app);
+    return;
+  }
+  if (module.default && typeof module.default === "object" && "setup" in module.default) {
+    app.use(module.default);
+    return;
+  }
+  if (typeof module.setup === "function" || isCommandMap(module.commands) || typeof module.name === "string" || typeof module.log === "boolean") {
+    const setup = typeof module.setup === "function" ? module.setup : void 0;
+    await applyAppModuleDefinition(app, {
+      name: typeof module.name === "string" ? module.name : void 0,
+      log: typeof module.log === "boolean" ? module.log : void 0,
+      setup,
+      commands: isCommandMap(module.commands) ? module.commands : void 0
+    });
+    return;
+  }
+  if (module.plugin && typeof module.plugin === "object" && "setup" in module.plugin) {
+    app.use(module.plugin);
+    return;
+  }
+  const namedDefinitions = Object.entries(module).filter(([name]) => !RESERVED_APP_EXPORT_NAMES.has(name)).map(([, value]) => value).filter(isAppModuleDefinition);
+  if (namedDefinitions.length > 0) {
+    for (const definition of namedDefinitions) {
+      await applyAppModuleDefinition(app, definition);
+    }
+    return;
+  }
+  throw new TypeError(`\u5E94\u7528\u6A21\u5757\u65E0\u53EF\u6CE8\u518C\u5BFC\u51FA: ${filePath}`);
+}
+async function applyAppModuleDefinition(app, definition) {
+  const moduleLogger = createAppModuleLogger(definition);
+  if (definition.setup) {
+    await definition.setup(app, moduleLogger);
+  }
+  if (definition.commands) {
+    app.commands(definition.commands);
+  }
+}
+function createAppModuleLogger(definition) {
+  if (definition.log === true && !definition.name?.trim()) {
+    throw new TypeError("\u5E94\u7528\u6A21\u5757\u542F\u7528\u65E5\u5FD7\u65F6\u5FC5\u987B\u63D0\u4F9B name");
+  }
+  const scopedLogger = logger;
+  if (definition.log === false) {
+    scopedLogger.setLevel("silent");
+  }
+  return scopedLogger;
+}
+function isAppModuleDefinition(value) {
+  return typeof value === "object" && value !== null && "__plumeAppModule" in value && value.__plumeAppModule === true;
+}
+function isCommandMap(value) {
+  return typeof value === "object" && value !== null;
+}
+var RESERVED_APP_EXPORT_NAMES = /* @__PURE__ */ new Set(["default", "setup", "commands", "name", "log", "plugin"]);
+async function startTransport(transportServer, logger3) {
+  if (!transportServer || !transportServer.isEnabled()) {
+    logger3.warn("\u4F20\u8F93\u5165\u53E3\u5DF2\u7981\u7528");
+    return null;
+  }
+  try {
+    const address = await transportServer.start();
+    return address;
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "EADDRINUSE") {
+      throw new Error("\u4F20\u8F93\u7AEF\u53E3\u5DF2\u88AB\u5360\u7528\uFF0C\u8BF7\u4FEE\u6539 config/transport.json \u4E2D\u7684 port");
+    }
+    throw error;
+  }
+}
+function isDirectExecution() {
+  const entry = process.argv[1];
+  if (!entry) {
+    return false;
+  }
+  try {
+    return fileURLToPath(import.meta.url) === entry;
+  } catch {
+    return false;
+  }
+}
+if (isDirectExecution()) {
+  start().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`[Plume] \u542F\u52A8\u5931\u8D25: ${message}`);
+    process.exit(1);
+  });
+}
+function resolveStartPlugins(plugins) {
+  const resolvedPlugins = [...plugins ?? []];
+  if (!resolvedPlugins.some((plugin) => plugin.name === "adapter-console")) {
+    resolvedPlugins.push(createConsoleAdapter());
+  }
+  return resolvedPlugins;
+}
+function resolveTransportOptions(config, transport) {
+  if (transport === false) {
+    return {
+      enableHttp: false,
+      enableWebSocket: false
+    };
+  }
+  return {
+    host: config.get("transport.host", "127.0.0.1"),
+    port: config.get("transport.port", 23333),
+    path: config.get("transport.path", "/api"),
+    wsPath: config.get("transport.wsPath", "/ws"),
+    cors: config.get("transport.cors", true),
+    enableHttp: config.get("transport.enableHttp", true),
+    enableWebSocket: config.get("transport.enableWebSocket", true),
+    maxBodySize: config.get("transport.maxBodySize", 1024 * 1024),
+    ...transport
+  };
+}
+
+// src/start/app.ts
+var isStarted = false;
+async function bootstrap() {
+  if (isStarted) {
+    logger2.warn("\u5E94\u7528\u5DF2\u542F\u52A8\uFF0C\u8DF3\u8FC7\u91CD\u590D\u542F\u52A8");
+    return;
+  }
+  isStarted = true;
+  const currentDir = fileURLToPath2(new URL(".", import.meta.url));
+  const isDev = import.meta.url.includes(".ts");
+  const possibleEntries = isDev ? [
+    join3(currentDir, "..", "index.ts"),
+    join3(process.cwd(), "src", "main.ts"),
+    join3(process.cwd(), "src", "index.ts")
+  ] : [
+    join3(currentDir, "..", "index.mjs"),
+    join3(process.cwd(), "dist", "main.js"),
+    join3(process.cwd(), "dist", "index.js")
+  ];
+  let entryPath = null;
+  for (const entry of possibleEntries) {
+    if (existsSync3(entry)) {
+      entryPath = entry;
+      break;
+    }
+  }
+  if (!entryPath) {
+    logger2.error("\u672A\u627E\u5230\u6709\u6548\u7684\u5165\u53E3\u6587\u4EF6");
+    logger2.info("\u8BF7\u786E\u4FDD\u4EE5\u4E0B\u6587\u4EF6\u4E4B\u4E00\u5B58\u5728:");
+    possibleEntries.forEach((p) => logger2.info(`  - ${p}`));
+    process.exit(1);
+  }
+  try {
+    logger2.info(`\u6B63\u5728\u52A0\u8F7D\u5165\u53E3: ${entryPath}`);
+    const module = await import(pathToFileURL2(entryPath).href);
+    await runEntryModule(module);
+    logger2.info("\u5E94\u7528\u542F\u52A8\u6210\u529F");
+  } catch (error) {
+    logger2.error("\u5E94\u7528\u542F\u52A8\u5931\u8D25:", error);
+    process.exit(1);
+  }
+}
+async function runEntryModule(module) {
+  if (module.app instanceof App) {
+    await start({ app: module.app });
+    return;
+  }
+  if (module.default instanceof App) {
+    await start({ app: module.default });
+    return;
+  }
+  if (typeof module.createApp === "function") {
+    const app = await module.createApp();
+    if (!(app instanceof App)) {
+      throw new TypeError("createApp \u5FC5\u987B\u8FD4\u56DE App \u5B9E\u4F8B");
+    }
+    await start({ app });
+    return;
+  }
+  if (typeof module.start === "function") {
+    await module.start();
+    return;
+  }
+  if (typeof module.default === "function") {
+    await module.default();
+    return;
+  }
+  if (module.default && typeof module.default === "object" && "start" in module.default) {
+    const defaultExport = module.default;
+    if (typeof defaultExport.start === "function") {
+      await defaultExport.start();
+      return;
+    }
+  }
+  logger2.warn("\u5165\u53E3\u6A21\u5757\u5DF2\u52A0\u8F7D\uFF0C\u4F46\u672A\u53D1\u73B0\u53EF\u6267\u884C\u7684\u542F\u52A8\u5BFC\u51FA");
+}
+bootstrap().catch((error) => {
+  logger2.error("\u5F15\u5BFC\u7A0B\u5E8F\u9519\u8BEF:", error);
+  process.exit(1);
+});