@mingxy/ocosay 1.1.0 → 1.1.2

package/dist/plugin.js

@@ -5049,15 +5049,15 @@ var require_tools = __commonJS({
         return data + propStr + msgStr + end;
       }
     }
-    function asChindings(instance2, bindings) {
+    function asChindings(instance, bindings) {
       let value;
-      let data = instance2[chindingsSym];
-      const stringify2 = instance2[stringifySym];
-      const stringifySafe = instance2[stringifySafeSym];
-      const stringifiers = instance2[stringifiersSym];
+      let data = instance[chindingsSym];
+      const stringify2 = instance[stringifySym];
+      const stringifySafe = instance[stringifySafeSym];
+      const stringifiers = instance[stringifiersSym];
       const wildcardStringifier = stringifiers[wildcardFirstSym];
-      const serializers = instance2[serializersSym];
-      const formatter = instance2[formattersSym].bindings;
+      const serializers = instance[serializersSym];
+      const formatter = instance[formattersSym].bindings;
       bindings = formatter(bindings);
       for (const key in bindings) {
         value = bindings[key];
@@ -5110,7 +5110,7 @@ var require_tools = __commonJS({
       }
     }
     function createArgsNormalizer(defaultOptions) {
-      return function normalizeArgs(instance2, caller, opts = {}, stream2) {
+      return function normalizeArgs(instance, caller, opts = {}, stream2) {
         if (typeof opts === "string") {
           stream2 = buildSafeSonicBoom({ dest: opts });
           opts = {};
@@ -5262,16 +5262,16 @@ var require_levels = __commonJS({
       o[k] = '{"level":' + Number(k);
       return o;
     }, {});
-    function genLsCache(instance2) {
-      const formatter = instance2[formattersSym].level;
-      const { labels } = instance2.levels;
+    function genLsCache(instance) {
+      const formatter = instance[formattersSym].level;
+      const { labels } = instance.levels;
       const cache = {};
       for (const label in labels) {
         const level2 = formatter(labels[label], Number(label));
         cache[label] = JSON.stringify(level2).slice(0, -1);
       }
-      instance2[lsCacheSym] = cache;
-      return instance2;
+      instance[lsCacheSym] = cache;
+      return instance;
     }
     function isStandardLevel(level2, useOnlyCustomLevels) {
       if (useOnlyCustomLevels) {
@@ -5516,49 +5516,49 @@ var require_proto = __commonJS({
       }
       const serializers = this[serializersSym];
       const formatters = this[formattersSym];
-      const instance2 = Object.create(this);
+      const instance = Object.create(this);
       if (options == null) {
-        if (instance2[formattersSym].bindings !== resetChildingsFormatter) {
-          instance2[formattersSym] = buildFormatters(
+        if (instance[formattersSym].bindings !== resetChildingsFormatter) {
+          instance[formattersSym] = buildFormatters(
             formatters.level,
             resetChildingsFormatter,
             formatters.log
           );
         }
-        instance2[chindingsSym] = asChindings(instance2, bindings2);
+        instance[chindingsSym] = asChindings(instance, bindings2);
         if (this.onChild !== noop) {
-          this.onChild(instance2);
+          this.onChild(instance);
         }
-        return instance2;
+        return instance;
       }
       if (options.hasOwnProperty("serializers") === true) {
-        instance2[serializersSym] = /* @__PURE__ */ Object.create(null);
+        instance[serializersSym] = /* @__PURE__ */ Object.create(null);
         for (const k in serializers) {
-          instance2[serializersSym][k] = serializers[k];
+          instance[serializersSym][k] = serializers[k];
         }
         const parentSymbols = Object.getOwnPropertySymbols(serializers);
         for (var i = 0; i < parentSymbols.length; i++) {
           const ks = parentSymbols[i];
-          instance2[serializersSym][ks] = serializers[ks];
+          instance[serializersSym][ks] = serializers[ks];
         }
         for (const bk in options.serializers) {
-          instance2[serializersSym][bk] = options.serializers[bk];
+          instance[serializersSym][bk] = options.serializers[bk];
         }
         const bindingsSymbols = Object.getOwnPropertySymbols(options.serializers);
         for (var bi = 0; bi < bindingsSymbols.length; bi++) {
           const bks = bindingsSymbols[bi];
-          instance2[serializersSym][bks] = options.serializers[bks];
+          instance[serializersSym][bks] = options.serializers[bks];
         }
-      } else instance2[serializersSym] = serializers;
+      } else instance[serializersSym] = serializers;
       if (options.hasOwnProperty("formatters")) {
         const { level: level2, bindings: chindings, log } = options.formatters;
-        instance2[formattersSym] = buildFormatters(
+        instance[formattersSym] = buildFormatters(
           level2 || formatters.level,
           chindings || resetChildingsFormatter,
           log || formatters.log
         );
       } else {
-        instance2[formattersSym] = buildFormatters(
+        instance[formattersSym] = buildFormatters(
           formatters.level,
           resetChildingsFormatter,
           formatters.log
@@ -5566,27 +5566,27 @@ var require_proto = __commonJS({
       }
       if (options.hasOwnProperty("customLevels") === true) {
         assertNoLevelCollisions(this.levels, options.customLevels);
-        instance2.levels = mappings(options.customLevels, instance2[useOnlyCustomLevelsSym]);
-        genLsCache(instance2);
+        instance.levels = mappings(options.customLevels, instance[useOnlyCustomLevelsSym]);
+        genLsCache(instance);
       }
       if (typeof options.redact === "object" && options.redact !== null || Array.isArray(options.redact)) {
-        instance2.redact = options.redact;
-        const stringifiers = redaction(instance2.redact, stringify);
+        instance.redact = options.redact;
+        const stringifiers = redaction(instance.redact, stringify);
         const formatOpts = { stringify: stringifiers[redactFmtSym] };
-        instance2[stringifySym] = stringify;
-        instance2[stringifiersSym] = stringifiers;
-        instance2[formatOptsSym] = formatOpts;
+        instance[stringifySym] = stringify;
+        instance[stringifiersSym] = stringifiers;
+        instance[formatOptsSym] = formatOpts;
       }
       if (typeof options.msgPrefix === "string") {
-        instance2[msgPrefixSym] = (this[msgPrefixSym] || "") + options.msgPrefix;
+        instance[msgPrefixSym] = (this[msgPrefixSym] || "") + options.msgPrefix;
       }
-      instance2[chindingsSym] = asChindings(instance2, bindings2);
+      instance[chindingsSym] = asChindings(instance, bindings2);
       if (options.level !== void 0 && options.level !== this.level || options.hasOwnProperty("customLevels")) {
         const childLevel = options.level || this.level;
-        instance2[setLevelSym](childLevel);
+        instance[setLevelSym](childLevel);
       }
-      this.onChild(instance2);
-      return instance2;
+      this.onChild(instance);
+      return instance;
     }
     function bindings() {
       const chindings = this[chindingsSym];
@@ -6287,11 +6287,11 @@ var require_multistream = __commonJS({
       function write(data) {
         let dest;
         const level2 = this.lastLevel;
-        const { streams: streams2 } = this;
+        const { streams } = this;
         let recordedLevel = 0;
         let stream2;
-        for (let i = initLoopVar(streams2.length, opts.dedupe); checkLoopVar(i, streams2.length, opts.dedupe); i = adjustLoopVar(i, opts.dedupe)) {
-          dest = streams2[i];
+        for (let i = initLoopVar(streams.length, opts.dedupe); checkLoopVar(i, streams.length, opts.dedupe); i = adjustLoopVar(i, opts.dedupe)) {
+          dest = streams[i];
           if (dest.level <= level2) {
             if (recordedLevel !== 0 && recordedLevel !== dest.level) {
               break;
@@ -6337,7 +6337,7 @@ var require_multistream = __commonJS({
         if (!isStream) {
           throw Error("stream object needs to implement either StreamEntry or DestinationStream interface");
         }
-        const { streams: streams2, streamLevels: streamLevels2 } = this;
+        const { streams, streamLevels: streamLevels2 } = this;
         let level2;
         if (typeof dest.levelVal === "number") {
           level2 = dest.levelVal;
@@ -6354,18 +6354,18 @@ var require_multistream = __commonJS({
           levelVal: void 0,
           id: ++res.lastId
         };
-        streams2.unshift(dest_);
-        streams2.sort(compareByLevel);
-        this.minLevel = streams2[0].level;
+        streams.unshift(dest_);
+        streams.sort(compareByLevel);
+        this.minLevel = streams[0].level;
         return res;
       }
       function remove(id2) {
-        const { streams: streams2 } = this;
-        const index = streams2.findIndex((s) => s.id === id2);
+        const { streams } = this;
+        const index = streams.findIndex((s) => s.id === id2);
         if (index >= 0) {
-          streams2.splice(index, 1);
-          streams2.sort(compareByLevel);
-          this.minLevel = streams2.length > 0 ? streams2[0].level : -1;
+          streams.splice(index, 1);
+          streams.sort(compareByLevel);
+          this.minLevel = streams.length > 0 ? streams[0].level : -1;
         }
         return res;
       }
@@ -6378,9 +6378,9 @@ var require_multistream = __commonJS({
         }
       }
       function clone(level2) {
-        const streams2 = new Array(this.streams.length);
-        for (let i = 0; i < streams2.length; i++) {
-          streams2[i] = {
+        const streams = new Array(this.streams.length);
+        for (let i = 0; i < streams.length; i++) {
+          streams[i] = {
             level: level2,
             stream: this.streams[i].stream
           };
@@ -6390,7 +6390,7 @@ var require_multistream = __commonJS({
           add,
           remove,
           minLevel: level2,
-          streams: streams2,
+          streams,
           clone,
           emit,
           flushSync,
@@ -6502,8 +6502,8 @@ var require_pino = __commonJS({
     var normalize = createArgsNormalizer(defaultOptions);
     var serializers = Object.assign(/* @__PURE__ */ Object.create(null), stdSerializers);
     function pino2(...args) {
-      const instance2 = {};
-      const { opts, stream: stream2 } = normalize(instance2, caller(), ...args);
+      const instance = {};
+      const { opts, stream: stream2 } = normalize(instance, caller(), ...args);
       if (opts.level && typeof opts.level === "string" && DEFAULT_LEVELS[opts.level.toLowerCase()] !== void 0) opts.level = opts.level.toLowerCase();
       const {
         redact,
@@ -6571,7 +6571,7 @@ var require_pino = __commonJS({
       }
       assertLevelComparison(levelComparison);
       const levelCompFunc = genLevelComparison(levelComparison);
-      Object.assign(instance2, {
+      Object.assign(instance, {
         levels,
         [levelCompSym]: levelCompFunc,
         [useOnlyCustomLevelsSym]: useOnlyCustomLevels,
@@ -6598,10 +6598,10 @@ var require_pino = __commonJS({
         onChild,
         [msgPrefixSym]: msgPrefix
       });
-      Object.setPrototypeOf(instance2, proto());
-      genLsCache(instance2);
-      instance2[setLevelSym](level2);
-      return instance2;
+      Object.setPrototypeOf(instance, proto());
+      genLsCache(instance);
+      instance[setLevelSym](level2);
+      return instance;
     }
     module.exports = pino2;
     module.exports.destination = (dest = process.stdout.fd) => {
@@ -7391,6 +7391,7 @@ var HowlerBackend = class {
 
 // src/utils/logger.ts
 var import_pino = __toESM(require_pino(), 1);
+import { Transform } from "stream";
 import { homedir } from "os";
 import { join as join4 } from "path";
 import { existsSync as existsSync4, mkdirSync } from "fs";
@@ -7402,22 +7403,52 @@ if (!existsSync4(logDir)) {
   } catch {
   }
 }
-var streams = [
-  { stream: process.stdout }
-];
+var level = process.env.NODE_ENV !== "production" ? "debug" : process.env.OCOSAY_LOG_LEVEL || "info";
+var formatLog = (log) => {
+  const time = log.time ? new Date(log.time).toISOString().replace("T", " ").replace("Z", "") : "";
+  const levelStr = log.level === 30 ? "INFO" : log.level === 40 ? "WARNING" : log.level === 50 ? "ERROR" : "DEBUG";
+  const module = log.module || "App";
+  const msg = log.msg || "";
+  return `[Ocosay][${time}][${levelStr}][${module}] \u5BF9\u5E94\u4E8B\u4EF6{${msg}}
+`;
+};
+var createFormatStream = () => new Transform({
+  transform(chunk, _encoding, callback) {
+    try {
+      const log = JSON.parse(chunk.toString());
+      this.push(formatLog(log));
+    } catch {
+      this.push(chunk);
+    }
+    callback();
+  }
+});
+var stdoutStream = createFormatStream();
+stdoutStream.pipe(process.stdout);
+var fileStream = null;
 try {
-  streams.push({ stream: import_pino.default.destination({ dest: logFile, mkdir: true }) });
+  const fileDest = import_pino.default.destination({ dest: logFile, mkdir: true });
+  fileStream = createFormatStream();
+  fileStream.pipe(fileDest);
 } catch {
 }
-var level = process.env.NODE_ENV !== "production" ? "debug" : process.env.OCOSAY_LOG_LEVEL || "info";
 var logger = (0, import_pino.default)(
   {
     level,
     base: { service: "ocosay" },
-    timestamp: import_pino.default.stdTimeFunctions.isoTime
+    timestamp: import_pino.default.stdTimeFunctions.isoTime,
+    formatters: {
+      level: (label) => ({ level: label })
+    }
   },
-  import_pino.default.multistream(streams)
+  import_pino.default.multistream([
+    { stream: stdoutStream },
+    ...fileStream ? [{ stream: fileStream }] : []
+  ])
 );
+function createModuleLogger(module) {
+  return logger.child({ module });
+}
 
 // src/core/backends/index.ts
 function isNaudiodonAvailable() {
@@ -7639,22 +7670,81 @@ var AudioPlayer = class extends EventEmitter {
   }
 };
 
-// src/core/speaker.ts
-function toast(options) {
-  const tui2 = global.__opencode_tui__;
-  if (tui2?.showToast) {
+// src/core/notification.ts
+var logger2 = createModuleLogger("NotificationService");
+var NotificationService = class {
+  tui = null;
+  pendingToasts = [];
+  retryTimer;
+  setTui(tui) {
+    this.tui = tui;
+    logger2.debug("tui reference set");
+    this.flushPending();
+  }
+  showToast(options) {
+    const { title, message, variant = "info", duration = 5e3 } = options;
+    if (!this.tui) {
+      logger2.debug({ title }, "tui not ready, queueing toast");
+      this.pendingToasts.push(options);
+      this.scheduleRetry();
+      return false;
+    }
     try {
-      tui2.showToast({
-        title: options.title,
-        message: options.body,
-        variant: options.type,
-        duration: 3e3
+      this.tui.showToast({
+        body: {
+          title,
+          message,
+          variant,
+          duration
+        }
       });
+      logger2.debug({ title, variant }, "toast shown");
+      return true;
     } catch (err) {
-      logger.warn({ err }, "toast call failed");
+      logger2.warn({ err, title }, "toast call failed, queueing for retry");
+      this.pendingToasts.push(options);
+      this.scheduleRetry();
+      return false;
     }
   }
-}
+  scheduleRetry() {
+    if (this.retryTimer) return;
+    this.retryTimer = setTimeout(() => {
+      this.retryTimer = void 0;
+      this.flushPending();
+    }, 2e3);
+  }
+  flushPending() {
+    if (this.pendingToasts.length === 0 || !this.tui) return;
+    logger2.info({ count: this.pendingToasts.length }, "flushing pending toasts");
+    const pending = [...this.pendingToasts];
+    this.pendingToasts = [];
+    for (const toast of pending) {
+      try {
+        this.showToast(toast);
+      } catch (err) {
+        this.pendingToasts.push(toast);
+        logger2.warn({ err }, "showToast threw unexpected error, re-queued");
+      }
+    }
+  }
+  success(title, message, duration) {
+    return this.showToast({ title, message, variant: "success", duration });
+  }
+  error(title, message, duration) {
+    return this.showToast({ title, message, variant: "error", duration });
+  }
+  info(title, message, duration) {
+    return this.showToast({ title, message, variant: "info", duration });
+  }
+  warning(title, message, duration) {
+    return this.showToast({ title, message, variant: "warning", duration });
+  }
+};
+var notificationService = new NotificationService();
+
+// src/core/speaker.ts
+var logger3 = createModuleLogger("Speaker");
 var Speaker = class extends EventEmitter2 {
   constructor(options = {}) {
     super();
@@ -7664,11 +7754,10 @@ var Speaker = class extends EventEmitter2 {
       onEnd: () => {
         this.isSpeaking = false;
         this.emit("end", this.currentText);
-        toast({
-          title: "TTS playback success",
-          body: "Audio generated and playing",
-          type: "info"
-        });
+        notificationService.info(
+          "TTS playback success",
+          "Audio generated and playing"
+        );
       },
       onError: (error) => this.emit("error", error),
       onPause: () => {
@@ -7731,17 +7820,16 @@ var Speaker = class extends EventEmitter2 {
       });
       if (this.player) {
         await this.player.play(result.audioData, result.format);
-        logger.info({ textLength: text.length, model: options.model }, "TTS playback completed");
+        logger3.info({ textLength: text.length, model: options.model }, "TTS playback completed");
       }
     } catch (error) {
       this.isSpeaking = false;
-      logger.error({ error }, "speak failed");
+      logger3.error({ error }, "speak failed");
       const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      toast({
-        title: "TTS playback error",
-        body: errorMessage,
-        type: "error"
-      });
+      notificationService.error(
+        "TTS playback error",
+        errorMessage
+      );
       if (error instanceof TTSError) {
         this.emit("error", error);
         throw error;
@@ -8321,6 +8409,7 @@ async function stream(text, options) {
 }
 
 // src/tools/tts.ts
+var logger4 = createModuleLogger("TTS");
 function extractTextArg(args) {
   if (!args || typeof args !== "object") {
     return void 0;
@@ -8333,26 +8422,26 @@ function extractTextArg(args) {
   const text7 = argObj.text7;
   if (text7 != null) {
     if (typeof text7 === "string" && text7.trim().length > 0) {
-      logger.warn("received text7 instead of text from OpenCode framework");
+      logger4.warn("received text7 instead of text from OpenCode framework");
       return text7.trim();
     }
     if (typeof text7 === "object") {
       if ("split" in text7 && "content" in text7) {
         const content = text7.content;
         if (typeof content === "string" && content.trim().length > 0) {
-          logger.info("text7 split format detected");
+          logger4.info("text7 split format detected");
           return content.trim();
         }
       }
       if ("content" in text7) {
         const content = text7.content;
         if (typeof content === "string" && content.trim().length > 0) {
-          logger.info("text7 content format detected");
+          logger4.info("text7 content format detected");
           return content.trim();
         }
       }
     }
-    logger.warn({ type: typeof text7 }, "text7 is not a valid string or object with content");
+    logger4.warn({ type: typeof text7 }, "text7 is not a valid string or object with content");
     return void 0;
   }
   for (const key of Object.keys(argObj)) {
@@ -8364,7 +8453,7 @@ function extractTextArg(args) {
     }
   }
   if (text !== void 0) {
-    logger.warn({ type: typeof text }, "text arg is not a valid string");
+    logger4.warn({ type: typeof text }, "text arg is not a valid string");
   }
   return void 0;
 }
@@ -8424,9 +8513,9 @@ async function handleToolCall(toolName, args) {
         if (streamingService) {
           const textArg = extractTextArg(args);
           if (textArg && typeof textArg === "string" && textArg.trim().length > 0) {
-            logger.info({ text: textArg.substring(0, 50) + "..." }, "synthesizing text");
+            logger4.info({ text: textArg.substring(0, 50) + "..." }, "synthesizing text");
             stream(textArg).catch((error) => {
-              logger.error({ error }, "stream failed");
+              logger4.error({ error }, "stream failed");
             });
           }
           return { success: true, message: "Stream speak started" };
@@ -8922,6 +9011,7 @@ var MINIMAX_VOICES = [
 
 // src/core/stream-reader.ts
 import { EventEmitter as EventEmitter5 } from "events";
+var logger5 = createModuleLogger("StreamReader");
 var StreamReader = class extends EventEmitter5 {
   constructor(bufferSize = 30, bufferTimeout = 2e3) {
     super();
@@ -8948,7 +9038,7 @@ var StreamReader = class extends EventEmitter5 {
   }
   handleDelta(sessionID, messageID, partID, delta) {
     if (typeof delta !== "string") {
-      logger.warn({ delta }, "handleDelta received non-string delta, skipping");
+      logger5.warn({ delta }, "handleDelta received non-string delta, skipping");
       return;
     }
     if (this.state === "idle" /* IDLE */) {
@@ -8957,11 +9047,11 @@ var StreamReader = class extends EventEmitter5 {
       this.messageID = messageID;
       this.partID = partID;
       this.emit("streamStart");
-      logger.debug({ sessionID, messageID, partID }, "Stream started");
+      logger5.debug({ sessionID, messageID, partID }, "Stream started");
     }
     this.buffer += delta;
     this.resetTimeout();
-    logger.debug({ deltaLength: delta.length, bufferLength: this.buffer.length }, "Delta received");
+    logger5.debug({ deltaLength: delta.length, bufferLength: this.buffer.length }, "Delta received");
     if (this.shouldFlush()) {
       this.flushBuffer();
     }
@@ -9314,6 +9404,7 @@ function getStreamStatus() {
 import * as fs2 from "fs";
 import * as path from "path";
 import * as os from "os";
+var logger6 = createModuleLogger("Config");
 var DEFAULT_CONFIG = {
   enabled: true,
   autoPlay: false,
@@ -9412,12 +9503,12 @@ function loadOrCreateConfig() {
     try {
       fs2.mkdirSync(configDir, { recursive: true });
     } catch (err) {
-      logger.error({ err }, "failed to create config directory");
+      logger6.error({ err }, "failed to create config directory");
       throw new Error(`[ocosay] \u65E0\u6CD5\u521B\u5EFA\u914D\u7F6E\u76EE\u5F55 ${configDir}: ${err}`);
     }
   }
   if (!fs2.existsSync(CONFIG_PATH)) {
-    logger.info("config file not found, creating default config");
+    logger6.info("config file not found, creating default config");
     const defaultConfig = generateDefaultConfig();
     const configContent = JSON.stringify(defaultConfig, null, 2);
     try {
@@ -9425,14 +9516,14 @@ function loadOrCreateConfig() {
       try {
         fs2.chmodSync(CONFIG_PATH, 384);
       } catch (err) {
-        logger.warn({ err }, "failed to set config file permissions");
+        logger6.warn({ err }, "failed to set config file permissions");
       }
     } catch (err) {
-      logger.error({ err }, "failed to write config file");
+      logger6.error({ err }, "failed to write config file");
       throw new Error(`[ocosay] cannot write config file ${CONFIG_PATH}: ${err}`);
     }
-    logger.info({ path: CONFIG_PATH }, "config file created");
-    logger.info("please edit config file to add API Key and Base URL");
+    logger6.info({ path: CONFIG_PATH }, "config file created");
+    logger6.info("please edit config file to add API Key and Base URL");
     return defaultConfig;
   }
   try {
@@ -9454,96 +9545,16 @@ function loadOrCreateConfig() {
       }
     };
   } catch (error) {
-    logger.error({ error }, "config file read failed, using default config");
+    logger6.error({ error }, "config file read failed, using default config");
     return generateDefaultConfig();
   }
 }
 
-// src/services/notification-service.ts
-var instance;
-var tui = null;
-var initialized2 = false;
-var NotificationService = class _NotificationService {
-  constructor() {
-  }
-  static getInstance() {
-    if (!instance) {
-      instance = new _NotificationService();
-    }
-    return instance;
-  }
-  initialize(tuiInstance) {
-    if (initialized2) return;
-    tui = tuiInstance;
-    initialized2 = true;
-    logger.debug("NotificationService initialized");
-  }
-  isReady() {
-    return initialized2 && tui !== null;
-  }
-  showToast(message, type = "info") {
-    const title = this.getTitleForType(type);
-    if (tui?.showToast) {
-      try {
-        tui.showToast({
-          title,
-          message,
-          variant: type,
-          duration: type === "error" ? 8e3 : 5e3
-        });
-        return;
-      } catch (err) {
-        logger.warn({ err }, "tui.showToast failed");
-      }
-    }
-    this.fallbackLog(type, title, message);
-  }
-  success(message) {
-    this.showToast(message, "success");
-  }
-  error(message) {
-    this.showToast(message, "error");
-  }
-  warning(message) {
-    this.showToast(message, "warning");
-  }
-  info(message) {
-    this.showToast(message, "info");
-  }
-  getTitleForType(type) {
-    const titles = {
-      success: "Success",
-      error: "Error",
-      warning: "Warning",
-      info: "Info"
-    };
-    return titles[type];
-  }
-  fallbackLog(type, title, message) {
-    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    switch (type) {
-      case "error":
-        logger.error({ title, message, timestamp }, "Toast (fallback)");
-        break;
-      case "warning":
-        logger.warn({ title, message, timestamp }, "Toast (fallback)");
-        break;
-      default:
-        logger.info({ title, message, timestamp }, "Toast (fallback)");
-    }
-  }
-};
-function showToast(message, type = "info") {
-  NotificationService.getInstance().showToast(message, type);
-}
-function initializeNotificationService(tuiInstance) {
-  NotificationService.getInstance().initialize(tuiInstance);
-}
-
 // src/plugin.ts
 import { readFileSync as readFileSync2 } from "fs";
 import { fileURLToPath } from "url";
 import { dirname as dirname2, join as join7 } from "path";
+var logger7 = createModuleLogger("Plugin");
 var __filename = fileURLToPath(import.meta.url);
 var __dirname2 = dirname2(__filename);
 var id = "ocosay";
@@ -9683,18 +9694,26 @@ var server = (async (input, _options) => {
     });
   } catch (err) {
     initError = err instanceof Error ? err : new Error(String(err));
-    logger.error({ error: initError }, "initialization failed");
+    logger7.error({ error: initError }, "initialization failed");
   }
   const opencodeTui = input.client?.tui;
   global.__opencode_tui__ = opencodeTui;
-  initializeNotificationService(opencodeTui);
-  setTimeout(async () => {
+  notificationService.setTui(opencodeTui);
+  setTimeout(() => {
     if (initError) {
-      showToast(`Ocosay v${pluginVersion} Initialization Failed: please check config`, "error");
+      notificationService.error(
+        `Ocosay v${pluginVersion} Init Failed`,
+        "Please check your config file",
+        8e3
+      );
     } else {
-      showToast(`Ocosay v${pluginVersion} Plugin Loaded (Auto-read: ${config.autoRead ? "ON" : "OFF"})`, "success");
+      notificationService.success(
+        `Ocosay v${pluginVersion} Ready`,
+        `Auto-read: ${config.autoRead ? "ON" : "OFF"}`,
+        5e3
+      );
     }
-  }, 7e3);
+  }, 1500);
   return {
     tool: {
       tts_speak: ttsSpeakTool,
@@ -9727,7 +9746,11 @@ var server = (async (input, _options) => {
             });
             initError = null;
           } catch (err) {
-            showToast(`Ocosay v${pluginVersion} Initialization Failed: please check config`, "error");
+            notificationService.error(
+              `Ocosay v${pluginVersion} Init Failed`,
+              "Initialization failed, please check config",
+              8e3
+            );
           }
         }
       }