@icaruk/zai-peak-hours 0.0.8 → 0.1.0

package/dist/config.d.ts

@@ -1,6 +1,4 @@
 export interface PluginConfig {
     enabled: boolean;
-    updateIntervalMinutes: number;
 }
 export declare const DEFAULT_CONFIG: PluginConfig;
-export declare function getPluginConfig(config: any): PluginConfig;

package/dist/config.js

@@ -1,11 +1,3 @@
 export const DEFAULT_CONFIG = {
-    enabled: true,
-    updateIntervalMinutes: 15 // 15 minutes
+    enabled: true
 };
-export function getPluginConfig(config) {
-    const userConfig = config?.peakHours || {};
-    return {
-        enabled: userConfig.enabled !== undefined ? userConfig.enabled : DEFAULT_CONFIG.enabled,
-        updateIntervalMinutes: userConfig.updateIntervalMinutes !== undefined ? userConfig.updateIntervalMinutes : DEFAULT_CONFIG.updateIntervalMinutes
-    };
-}

package/dist/index.js

@@ -1,10 +1,7 @@
-import { tool } from '@opencode-ai/plugin';
 import { getPeakHoursStatus, formatPeakHoursMessage } from './peak-hours';
 import { DEFAULT_CONFIG } from './config';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-let timerId = null;
-let configCache = null;
 function getConfigPath() {
     const configDir = process.env.XDG_CONFIG_HOME
         ? path.join(process.env.XDG_CONFIG_HOME, 'opencode')
@@ -12,119 +9,117 @@ function getConfigPath() {
     return path.join(configDir, 'peak-hours.json');
 }
 function loadConfig() {
-    if (configCache) {
-        return configCache;
-    }
     const configPath = getConfigPath();
     if (fs.existsSync(configPath)) {
         try {
             const configContent = fs.readFileSync(configPath, 'utf-8');
             const userConfig = JSON.parse(configContent);
-            configCache = {
-                enabled: userConfig.enabled !== undefined ? userConfig.enabled : DEFAULT_CONFIG.enabled,
-                updateIntervalMinutes: userConfig.updateIntervalMinutes !== undefined ? userConfig.updateIntervalMinutes : DEFAULT_CONFIG.updateIntervalMinutes
+            return {
+                enabled: userConfig.enabled !== undefined ? userConfig.enabled : DEFAULT_CONFIG.enabled
             };
-            return configCache;
         }
         catch (error) {
             console.error('Error loading peak-hours config:', error);
         }
     }
-    configCache = DEFAULT_CONFIG;
-    return configCache;
+    return DEFAULT_CONFIG;
 }
-async function showPeakHoursToast(client) {
-    const config = loadConfig();
-    if (!config.enabled) {
-        await client.tui.showToast({
-            body: {
-                message: 'Peak Hours plugin is disabled in config'
-            }
-        });
-        return;
-    }
-    const status = getPeakHoursStatus();
-    const message = formatPeakHoursMessage(status);
-    await client.tui.showToast({
-        body: {
-            message
-        }
-    });
+function renderCommandHeading(title) {
+    return `${title}\n${'='.repeat(title.length)}`;
 }
-async function showDiagnostics(client) {
-    const config = loadConfig();
-    const status = getPeakHoursStatus();
+function renderStatusReport(status, config) {
     const currentTime = new Date().toISOString();
-    const diagnostics = `=== Peak Hours Plugin Diagnostics ===
-Plugin enabled: ${config.enabled}
-Update interval: ${config.updateIntervalMinutes} minutes
-Current time: ${currentTime}
-In peak hours: ${status.inPeakHours}
-Time until ${status.transitionType}: ${status.timeUntilTransition}
-===================================`;
-    await client.tui.showToast({
-        body: {
-            message: diagnostics
-        }
-    });
+    const lines = [
+        renderCommandHeading('Peak Hours Status'),
+        '',
+        'Configuration:',
+        `- enabled: ${config.enabled}`,
+        '',
+        'Current Status:',
+        `- current_time: ${currentTime}`,
+        `- in_peak_hours: ${status.inPeakHours}`,
+        `- transition: ${status.transitionType}`,
+        `- time_until_${status.transitionType}: ${status.timeUntilTransition}`,
+        '',
+        'Peak Hours (UTC+8):',
+        `- start: 14:00`,
+        `- end: 18:00`
+    ];
+    return lines.join('\n');
 }
 export const PeakHours = async ({ client }) => {
     const config = loadConfig();
+    const typedClient = client;
+    async function injectRawOutput(sessionID, output) {
+        try {
+            await typedClient.session.prompt({
+                path: { id: sessionID },
+                body: {
+                    noReply: true,
+                    parts: [{ type: 'text', text: output, ignored: true }]
+                }
+            });
+        }
+        catch (err) {
+            console.error('Failed to inject output:', err);
+        }
+    }
+    async function handlePeakHoursCommand(sessionID) {
+        const status = getPeakHoursStatus();
+        const output = formatPeakHoursMessage(status);
+        await injectRawOutput(sessionID, output);
+        handled();
+    }
+    async function handlePeakHoursStatusCommand(sessionID) {
+        const status = getPeakHoursStatus();
+        const output = renderStatusReport(status, config);
+        await injectRawOutput(sessionID, output);
+        handled();
+    }
     return {
         config: async (input) => {
-            input.command ?? (input.command = {});
-            input.command['peak_hours'] = {
-                template: '/peak_hours',
-                description: 'Display current peak hours status'
-            };
-            input.command['peak_hours_status'] = {
-                template: '/peak_hours_status',
-                description: 'Display peak hours plugin diagnostics'
+            input.output.command = {
+                peak_hours: {
+                    template: '',
+                    description: 'Display current z.ai peak hours status and time until next transition'
+                },
+                peak_hours_status: {
+                    template: '',
+                    description: 'Display peak hours plugin diagnostics and configuration status'
+                }
             };
         },
-        'tool.execute.after': async (input) => {
+        'tui.command.execute': async (input) => {
+            const command = input.command;
+            const sessionID = input.sessionID;
             if (!config.enabled) {
+                await injectRawOutput(sessionID, 'Peak Hours plugin is disabled');
                 return;
             }
-            if (input.tool === 'peak_hours') {
-                await showPeakHoursToast(client);
+            if (command === 'peak_hours') {
+                await handlePeakHoursCommand(sessionID);
             }
-            else if (input.tool === 'peak_hours_status') {
-                await showDiagnostics(client);
+            else if (command === 'peak_hours_status') {
+                await handlePeakHoursStatusCommand(sessionID);
             }
         },
-        'session.created': async () => {
+        'session.created': async (input) => {
             if (!config.enabled) {
                 return;
             }
-            await showPeakHoursToast(client);
-        },
-        tool: {
-            'peak_hours': tool({
-                description: 'Display current z.ai peak hours status and time until next transition',
-                args: {},
-                async execute(_args, context) {
-                    const status = getPeakHoursStatus();
-                    const message = formatPeakHoursMessage(status);
-                    return `Peak Hours Status:\n${message}\n\nIn peak hours: ${status.inPeakHours}\nTime until ${status.transitionType}: ${status.timeUntilTransition}`;
-                }
-            }),
-            'peak_hours_status': tool({
-                description: 'Display peak hours plugin diagnostics and configuration status',
-                args: {},
-                async execute(_args, context) {
-                    const config = loadConfig();
-                    const status = getPeakHoursStatus();
-                    const currentTime = new Date().toISOString();
-                    return `=== Peak Hours Plugin Diagnostics ===
-Plugin enabled: ${config.enabled}
-Update interval: ${config.updateIntervalMinutes} minutes
-Current time: ${currentTime}
-In peak hours: ${status.inPeakHours}
-Time until ${status.transitionType}: ${status.timeUntilTransition}
-====================================`;
-                }
-            })
+            const status = getPeakHoursStatus();
+            const message = formatPeakHoursMessage(status);
+            try {
+                await typedClient.tui.showToast({
+                    body: {
+                        message,
+                        variant: status.inPeakHours ? 'warning' : 'info'
+                    }
+                });
+            }
+            catch (err) {
+                console.error('Failed to show toast:', err);
+            }
         }
     };
 };

package/dist/peak-hours.js

@@ -1,32 +1,33 @@
-import dayjs from 'dayjs';
-import utc from 'dayjs/plugin/utc.js';
-import timezone from 'dayjs/plugin/timezone.js';
-dayjs.extend(utc);
-dayjs.extend(timezone);
 export function getPeakHoursStatus() {
     const peakHoursStart = 14;
     const peakHoursEnd = 18;
-    const currentTime = dayjs().utc().utcOffset(8);
-    const currentHour = currentTime.hour();
+    // Calcular hora actual en UTC+8 (China timezone)
+    const now = new Date();
+    const utcMs = now.getTime() + now.getTimezoneOffset() * 60000;
+    const chinaTime = new Date(utcMs + 8 * 3600000);
+    const currentHour = chinaTime.getHours();
     let inPeakHours;
     let transitionTime;
     let transitionType;
     if (currentHour >= peakHoursStart && currentHour < peakHoursEnd) {
         inPeakHours = true;
         transitionType = 'end';
-        transitionTime = currentTime.hour(peakHoursEnd).minute(0).second(0);
+        transitionTime = new Date(chinaTime);
+        transitionTime.setHours(peakHoursEnd, 0, 0, 0);
     }
     else {
         inPeakHours = false;
         transitionType = 'start';
-        const transitionDay = currentHour >= peakHoursEnd
-            ? currentTime.add(1, 'day')
-            : currentTime;
-        transitionTime = transitionDay.hour(peakHoursStart).minute(0).second(0);
+        let transitionDay = new Date(chinaTime);
+        if (currentHour >= peakHoursEnd) {
+            transitionDay.setDate(transitionDay.getDate() + 1);
+        }
+        transitionDay.setHours(peakHoursStart, 0, 0, 0);
+        transitionTime = transitionDay;
     }
-    const diff = transitionTime.diff(currentTime);
-    const hours = Math.floor(diff / (1000 * 60 * 60));
-    const minutes = Math.floor((diff % (1000 * 60 * 60)) / (1000 * 60));
+    const diffMs = transitionTime.getTime() - chinaTime.getTime();
+    const hours = Math.floor(diffMs / (1000 * 60 * 60));
+    const minutes = Math.floor((diffMs % (1000 * 60 * 60)) / (1000 * 60));
     let timeUntilTransition;
     if (hours > 0 && minutes > 0) {
         timeUntilTransition = `${hours} hours ${minutes} minutes`;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@icaruk/zai-peak-hours",
-	"version": "0.0.8",
+	"version": "0.1.0",
 	"type": "module",
 	"description": "OpenCode plugin to display z.ai peak hours information with automatic timezone detection",
 	"main": "dist/index.js",
@@ -26,9 +26,7 @@
 	"author": "Icaruk",
 	"license": "MIT",
 	"dependencies": {
-		"@opencode-ai/plugin": "^1.4.0",
-		"@opencode-ai/sdk": "^1.4.3",
-		"dayjs": "^1.11.10"
+		"@opencode-ai/plugin": "^1.4.3"
 	},
 	"devDependencies": {
 		"@types/node": "^20.0.0",