@icaruk/zai-peak-hours 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Icaruk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,116 @@
+# @icaruk/zai-peak-hours
+
+OpenCode TUI plugin that displays z.ai peak hours information with automatic timezone detection via toast notifications.
+
+## Quick Start
+
+Add this to your `~/.config/opencode/tui.json`:
+
+**After npm publication:**
+```jsonc
+{
+  "plugin": ["@icaruk/zai-peak-hours"]
+}
+```
+
+**Local development (before npm publication):**
+```jsonc
+{
+  "plugin": ["file://D:/Dev/zai-peak-hours/dist/index.js"]
+}
+```
+
+## Features
+
+- 🌍 Automatic timezone detection (UTC+8 / Asia/Shanghai)
+- ⏰ Real-time peak hours status (14:00-18:00 UTC+8)
+- 📊 Time remaining until next peak/off-peak transition
+- 🔔 Toast notifications on session start and periodic updates
+- ⚙️ Configurable update interval
+- 🛠️ Manual commands for on-demand status checks
+
+## TUI vs Regular Plugins
+
+This is a **TUI plugin** (runs in the OpenCode client/terminal UI), not a regular server-side plugin.
+
+|               | TUI Plugin (this)        | Regular Plugin               |
+| ------------- | ------------------------ | -------------------------- |
+| **Config**        | `tui.json`               | `opencode.jsonc`            |
+| **Dónde corre**   | Client/TUI                | Server/backend             |
+| **Acceso UI**     | Sí (toasts, comandos)    | No                        |
+| **Custom tools**  | No                        | Sí                        |
+| **Hook en tools** | No                        | Sí                        |
+
+TUI plugins can display toasts, register slash commands, and show UI elements directly in the terminal.
+
+## Commands
+
+- `/peak_hours` - Display current peak hours status
+- `/peak_hours_status` - Display plugin diagnostics and configuration
+
+## Configuration
+
+Configuration is optional - the plugin works out of the box.
+
+To customize, create `~/.config/opencode/peak-hours.json`:
+
+```json
+{
+  "enabled": true,
+  "updateIntervalMinutes": 15
+}
+```
+
+### Options
+
+- `enabled` (boolean, default: `true`) - Enable or disable the plugin
+- `updateIntervalMinutes` (number, default: `15`) - Update interval in minutes
+
+## Peak Hours Schedule
+
+- **Peak Hours**: 14:00-18:00 UTC+8 (Asia/Shanghai timezone)
+- **Off-Peak Hours**: All other times
+
+## Messages
+
+The plugin displays toast notifications in the following format:
+
+**Peak Hours:**
+```
+Currently in peak hours. X hours Y minutes remaining
+```
+
+**Off-Peak Hours:**
+```
+Currently in off-peak hours. X hours Y minutes remaining
+```
+
+## Development
+
+For local development and testing:
+
+```bash
+# Clone the repository
+git clone https://github.com/Icaruk/zai-peak-hours.git
+cd zai-peak-hours
+
+# Install dependencies
+npm install
+
+# Build the plugin
+npm run build
+
+# Run in watch mode for development
+npm run dev
+```
+
+Then use the local development path in `tui.json`:
+```jsonc
+{
+  "plugin": ["file://D:/Dev/zai-peak-hours/dist/index.js"]
+}
+```
+
+## License
+
+MIT

package/dist/config.d.ts

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

package/dist/config.js

@@ -0,0 +1,11 @@
+export const DEFAULT_CONFIG = {
+    enabled: true,
+    updateIntervalMinutes: 15 // 15 minutes
+};
+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.d.ts

@@ -0,0 +1,8 @@
+import type { TuiPluginApi, TuiPluginMeta } from '../node_modules/@opencode-ai/plugin/dist/tui';
+import type { PluginOptions } from '@opencode-ai/plugin';
+declare function tui(api: TuiPluginApi, options: PluginOptions | undefined, meta: TuiPluginMeta): Promise<void>;
+declare const plugin: {
+    id: string;
+    tui: typeof tui;
+};
+export default plugin;

package/dist/index.js

@@ -0,0 +1,137 @@
+import { getPeakHoursStatus, formatPeakHoursMessage } from './peak-hours';
+import { DEFAULT_CONFIG } from './config';
+import * as fs from 'fs';
+import * as path from 'path';
+let timerId = null;
+let pluginLoaded = false;
+let configCache = null;
+function getConfigPath() {
+    const configDir = process.env.XDG_CONFIG_HOME
+        ? path.join(process.env.XDG_CONFIG_HOME, 'opencode')
+        : path.join(process.env.HOME || process.env.USERPROFILE || '', '.config', 'opencode');
+    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 configCache;
+        }
+        catch (error) {
+            console.error('Error loading peak-hours config:', error);
+        }
+    }
+    configCache = DEFAULT_CONFIG;
+    return configCache;
+}
+function showPeakHoursToast(api) {
+    const config = loadConfig();
+    if (!config.enabled) {
+        api.ui.toast({
+            message: 'Peak Hours plugin is disabled in config',
+            duration: 3000
+        });
+        return;
+    }
+    const status = getPeakHoursStatus();
+    const message = formatPeakHoursMessage(status);
+    api.ui.toast({
+        message,
+        duration: 5000
+    });
+}
+function showDiagnostics(api) {
+    const config = loadConfig();
+    const status = getPeakHoursStatus();
+    const currentTime = new Date().toISOString();
+    const diagnostics = [
+        '=== Peak Hours Plugin Diagnostics ===',
+        `Plugin loaded: ${pluginLoaded}`,
+        `Plugin enabled: ${config.enabled}`,
+        `Update interval: ${config.updateIntervalMinutes} minutes`,
+        `Current time: ${currentTime}`,
+        `In peak hours: ${status.inPeakHours}`,
+        `Time until ${status.transitionType}: ${status.timeUntilTransition}`,
+        `====================================`
+    ].join('\n');
+    api.ui.toast({
+        message: diagnostics,
+        duration: 8000
+    });
+}
+async function tui(api, options, meta) {
+    pluginLoaded = true;
+    const config = loadConfig();
+    const updateInterval = config.updateIntervalMinutes * 60 * 1000; // Convert minutes to milliseconds
+    // Show plugin loaded message
+    api.ui.toast({
+        message: 'Peak Hours Plugin loaded successfully',
+        duration: 3000
+    });
+    try {
+        const commands = [
+            {
+                title: 'Show Peak Hours Status',
+                value: 'peak_hours',
+                description: 'Display current peak hours status and time until next transition',
+                category: 'Utilities',
+                slash: {
+                    name: 'peak_hours'
+                },
+                onSelect: () => {
+                    showPeakHoursToast(api);
+                }
+            },
+            {
+                title: 'Show Peak Hours Diagnostics',
+                value: 'peak_hours_status',
+                description: 'Display plugin diagnostics and configuration status',
+                category: 'Utilities',
+                slash: {
+                    name: 'peak_hours_status'
+                },
+                onSelect: () => {
+                    showDiagnostics(api);
+                }
+            }
+        ];
+        api.command.register(() => commands);
+    }
+    catch (error) {
+        api.ui.toast({
+            message: `Error registering peak_hours commands: ${error}`,
+            duration: 5000
+        });
+    }
+    if (!config.enabled) {
+        return;
+    }
+    const unsubscribe = api.event.on('session.created', () => {
+        showPeakHoursToast(api);
+        timerId = setInterval(() => {
+            showPeakHoursToast(api);
+        }, updateInterval);
+    });
+    api.lifecycle.onDispose(() => {
+        unsubscribe();
+        if (timerId) {
+            clearInterval(timerId);
+            timerId = null;
+        }
+        pluginLoaded = false;
+    });
+}
+const plugin = {
+    id: "icaruk.peak-hours",
+    tui
+};
+export default plugin;

package/dist/peak-hours.d.ts

@@ -0,0 +1,7 @@
+export interface PeakHoursStatus {
+    inPeakHours: boolean;
+    timeUntilTransition: string;
+    transitionType: 'start' | 'end';
+}
+export declare function getPeakHoursStatus(): PeakHoursStatus;
+export declare function formatPeakHoursMessage(status: PeakHoursStatus): string;

package/dist/peak-hours.js

@@ -0,0 +1,53 @@
+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();
+    let inPeakHours;
+    let transitionTime;
+    let transitionType;
+    if (currentHour >= peakHoursStart && currentHour < peakHoursEnd) {
+        inPeakHours = true;
+        transitionType = 'end';
+        transitionTime = currentTime.hour(peakHoursEnd).minute(0).second(0);
+    }
+    else {
+        inPeakHours = false;
+        transitionType = 'start';
+        const transitionDay = currentHour >= peakHoursEnd
+            ? currentTime.add(1, 'day')
+            : currentTime;
+        transitionTime = transitionDay.hour(peakHoursStart).minute(0).second(0);
+    }
+    const diff = transitionTime.diff(currentTime);
+    const hours = Math.floor(diff / (1000 * 60 * 60));
+    const minutes = Math.floor((diff % (1000 * 60 * 60)) / (1000 * 60));
+    let timeUntilTransition;
+    if (hours > 0 && minutes > 0) {
+        timeUntilTransition = `${hours} hours ${minutes} minutes`;
+    }
+    else if (hours > 0) {
+        timeUntilTransition = `${hours} hours`;
+    }
+    else {
+        timeUntilTransition = `${minutes} minutes`;
+    }
+    return {
+        inPeakHours,
+        timeUntilTransition,
+        transitionType
+    };
+}
+export function formatPeakHoursMessage(status) {
+    if (status.inPeakHours) {
+        return `Currently in peak hours. ${status.timeUntilTransition} remaining`;
+    }
+    else {
+        return `Currently in off-peak hours. ${status.timeUntilTransition} remaining`;
+    }
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+	"name": "@icaruk/zai-peak-hours",
+	"version": "0.0.1",
+	"type": "module",
+	"description": "OpenCode plugin to display z.ai peak hours information with automatic timezone detection",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"tui": "dist/index.js",
+	"exports": {
+		".": {
+			"import": "./dist/index.js",
+			"types": "./dist/index.d.ts"
+		}
+	},
+	"scripts": {
+		"build": "tsc",
+		"dev": "tsc --watch",
+		"prepublishOnly": "npm run build"
+	},
+	"keywords": [
+		"opencode",
+		"plugin",
+		"peak-hours",
+		"timezone",
+		"cli"
+	],
+	"author": "Icaruk",
+	"license": "MIT",
+	"dependencies": {
+		"@opencode-ai/plugin": "^1.4.0",
+		"dayjs": "^1.11.10"
+	},
+	"devDependencies": {
+		"@types/node": "^20.0.0",
+		"typescript": "^5.0.0"
+	},
+	"files": [
+		"dist",
+		"README.md",
+		"LICENSE"
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/Icaruk/zai-peak-hours.git"
+	}
+}