pi-harness-runtime 1.1.341 → 1.1.344

package/README.md

@@ -25,6 +25,15 @@ Give the runtime a requirement. It keeps working, survives interruption, and ret
 pi install npm:pi-harness-runtime
 ```
 
+### Recommended Extensions
+
+This runtime works best with these extensions (auto-installed by pi-harness-runtime):
+
+```bash
+pi install npm:pi-mcp-adapter    # MCP protocol adapter for external tools
+pi install npm:@juicesharp/rpiv-todo  # Task tracking with bd sync
+```
+
 Requires Pi v0.37.3+.
 
 ### Headless Server Setup (herdr clipboard bridge)
@@ -679,6 +688,9 @@ Your local machine clipboard
 
 Get notified on your phone when tasks complete! LINE notifications via the LINE Messaging API.
 
+> **Self-Hosting Required**: LINE webhooks require your own server. This is NOT a hosted service.
+> You must **clone this repository** and deploy your own webhook server. See [LINE Voice/Webhook Setup](#line-voicewebhook-setup) below.
+
 #### Step-by-Step Setup
 
 **1. Create a LINE Messaging API channel**
@@ -754,6 +766,118 @@ Task: Implement login flow
 Job: feature-auth
 ```
 
+### LINE Voice/Webhook Setup (Voice Commands)
+
+> **Self-Hosting Required**: LINE voice messages require your own server with HTTPS.
+> This is NOT a hosted service. You must **clone this repository** and deploy your own webhook server.
+
+Voice messages from LINE are transcribed via OpenAI Whisper API and executed as commands.
+
+#### Requirements
+
+- **Own server** (VPS, cloud VM) with public IP
+- **Domain** with DNS A record pointing to your server
+- **SSL certificate** (Let's Encrypt via certbot)
+- **Clone this repository** on your server
+
+#### Setup Steps
+
+**1. Clone and Build**
+
+```bash
+# Clone on your server
+git clone https://github.com/ManotLuijiu/pi-harness-runtime.git
+cd pi-harness-runtime
+bun install
+bun run build
+```
+
+**2. Configure DNS**
+
+Create an A record: `line-api.your-domain.com` → `YOUR_SERVER_IP`
+
+**3. Setup Nginx + SSL**
+
+```bash
+# Install certbot
+sudo apt install certbot python3-certbot-nginx
+
+# Create nginx config
+sudo tee /etc/nginx/sites-available/line-api.your-domain.com > /dev/null << 'NGINX'
+server {
+    listen 80;
+    server_name line-api.your-domain.com;
+    location / {
+        proxy_pass http://127.0.0.1:3900;
+        proxy_http_version 1.1;
+        proxy_set_header Host $host;
+    }
+}
+NGINX
+
+# Enable and get SSL
+sudo ln -sf /etc/nginx/sites-available/line-api.your-domain.com /etc/nginx/sites-enabled/
+sudo certbot --nginx -d line-api.your-domain.com --noninteractive --agree-tos -m admin@your-domain.com --redirect
+```
+
+**4. Configure LINE Webhook**
+
+```bash
+# Set credentials
+mkdir -p ~/.pi-harness-runtime/keys
+
+# Get from LINE Developers Console > Messaging API > Basic settings
+cp YOUR_ACCESS_TOKEN ~/.pi-harness-runtime/keys/line-access-token.txt
+cp YOUR_CHANNEL_SECRET ~/.pi-harness-runtime/keys/line-channel-secret.txt
+
+# Get from LINE Developers Console > Messaging API > Webhook URL
+# Set to: https://line-api.your-domain.com/webhook/line
+```
+
+**5. Create Webhook Server**
+
+```bash
+# Create startup script
+mkdir -p ~/line-webhook
+cp pi-harness-runtime/packages/voice-api/dist/*.js ~/line-webhook/
+
+# Run server
+bun run ~/line-webhook/server.ts
+```
+
+**6. Set Webhook URL in LINE Console**
+
+1. Go to LINE Developers Console → Messaging API → Messaging settings
+2. Set Webhook URL: `https://line-api.your-domain.com/webhook/line`
+3. Click Verify
+
+#### Systemd Service (Auto-Restart)
+
+```bash
+sudo tee /etc/systemd/system/line-webhook.service > /dev/null << 'SERVICE'
+[Unit]
+Description=LINE Webhook Server for pi-harness
+After=network.target
+
+[Service]
+Type=simple
+User=YOUR_USER
+WorkingDirectory=/home/YOUR_USER/line-webhook
+ExecStart=/home/YOUR_USER/.bun/bin/bun run /home/YOUR_USER/line-webhook/server.ts
+Restart=always
+RestartSec=5
+StandardOutput=journal
+StandardError=journal
+
+[Install]
+WantedBy=multi-user.target
+SERVICE
+
+sudo systemctl daemon-reload
+sudo systemctl enable line-webhook.service
+sudo systemctl start line-webhook.service
+```
+
 ### Other Providers
 
 No setup needed. The runtime reads TUI messages and captures quota-exhaustion signals.
@@ -780,6 +904,9 @@ footer updates immediately and the data persists in `mirror.json`.
 
 Enable interactive Yes/No buttons in Telegram notifications for human approval.
 
+> **Self-Hosting Required**: Telegram webhooks require your own server with HTTPS.
+> This is NOT a hosted service. You must **clone this repository** and deploy your own webhook server.
+
 ### Architecture (Per-User Setup)
 
 ```

package/harness/notification-center.ts

@@ -0,0 +1,363 @@
+/**
+ * Multi-Channel Notification Center
+ * 
+ * Unified notification system supporting Telegram and LINE.
+ * Users can configure which channels to use and toggle them via inline buttons.
+ */
+
+import * as https from "https";
+
+export interface NotificationConfig {
+  telegram?: {
+    botToken: string;
+    chatId: string;
+    enabled: boolean;
+  };
+  line?: {
+    channelAccessToken: string;
+    userId: string;
+    enabled: boolean;
+  };
+}
+
+export interface NotificationEvent {
+  type: string;
+  emoji: string;
+  title: string;
+  message: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface NotificationButtons {
+  label: string;
+  action: string;
+  style?: "primary" | "secondary" | "danger";
+}
+
+const DEFAULT_CONFIG_FILE = `${process.env.HOME || "/home/frappe"}/.pi-harness-runtime/notification-config.json`;
+
+/**
+ * Load notification configuration
+ */
+function loadConfig(): NotificationConfig {
+  try {
+    const { existsSync, readFileSync } = require("fs");
+    if (existsSync(DEFAULT_CONFIG_FILE)) {
+      return JSON.parse(readFileSync(DEFAULT_CONFIG_FILE, "utf-8"));
+    }
+    } catch (e) {
+      console.error("Failed to save notification config:", e);
+    }
+  return {};
+}
+
+/**
+ * Save notification configuration
+ */
+function saveConfig(config: NotificationConfig): void {
+  try {
+    const { writeFileSync, mkdirSync, existsSync } = require("fs");
+    const dir = DEFAULT_CONFIG_FILE.substring(0, DEFAULT_CONFIG_FILE.lastIndexOf("/"));
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(DEFAULT_CONFIG_FILE, JSON.stringify(config, null, 2), "utf-8");
+  } catch (e) {
+    console.error("Failed to save notification config:", e);
+  }
+}
+
+/**
+ * Multi-Channel Notification Center
+ */
+export class NotificationCenter {
+  private config: NotificationConfig;
+  
+  constructor(config?: Partial<NotificationConfig>) {
+    this.config = loadConfig();
+    if (config?.telegram) {
+      this.config.telegram = { ...this.config.telegram, ...config.telegram };
+    }
+    if (config?.line) {
+      this.config.line = { ...this.config.line, ...config.line };
+    }
+  }
+
+  /**
+   * Update configuration
+   */
+  updateConfig(updates: Partial<NotificationConfig>): void {
+    this.config = { ...this.config, ...updates };
+    if (updates.telegram) {
+      this.config.telegram = { ...this.config.telegram!, ...updates.telegram };
+    }
+    if (updates.line) {
+      this.config.line = { ...this.config.line!, ...updates.line };
+    }
+    saveConfig(this.config);
+  }
+
+  /**
+   * Get current configuration
+   */
+  getConfig(): NotificationConfig {
+    return { ...this.config };
+  }
+
+  /**
+   * Send notification to all enabled channels
+   */
+  async notify(event: NotificationEvent): Promise<void> {
+    const { telegram, line } = this.config;
+    const promises: Promise<void>[] = [];
+
+    if (telegram?.enabled && telegram.botToken && telegram.chatId) {
+      promises.push(this.sendTelegram(event, telegram.botToken, telegram.chatId));
+    }
+
+    if (line?.enabled && line.channelAccessToken && line.userId) {
+      promises.push(this.sendLINE(event, line.channelAccessToken, line.userId));
+    }
+
+    await Promise.allSettled(promises);
+  }
+
+  /**
+   * Send notification with action buttons
+   */
+  async notifyWithButtons(
+    event: NotificationEvent,
+    buttons: NotificationButtons[]
+  ): Promise<void> {
+    const { telegram, line } = this.config;
+
+    if (telegram?.enabled && telegram.botToken && telegram.chatId) {
+      await this.sendTelegramWithButtons(event, buttons, telegram.botToken, telegram.chatId);
+    }
+
+    if (line?.enabled && line.channelAccessToken && line.userId) {
+      await this.sendLINEWithButtons(event, buttons, line.channelAccessToken, line.userId);
+    }
+  }
+
+  /**
+   * Send to Telegram
+   */
+  private async sendTelegram(
+    event: NotificationEvent,
+    botToken: string,
+    chatId: string
+  ): Promise<void> {
+    const text = `${event.emoji} ${event.title}\n\n${event.message}`;
+    
+    await this.telegramRequest(botToken, "sendMessage", {
+      chat_id: chatId,
+      text,
+      parse_mode: "Markdown",
+    });
+  }
+
+  /**
+   * Send to Telegram with inline buttons
+   */
+  private async sendTelegramWithButtons(
+    event: NotificationEvent,
+    buttons: NotificationButtons[],
+    botToken: string,
+    chatId: string
+  ): Promise<void> {
+    const text = `${event.emoji} ${event.title}\n\n${event.message}`;
+    const inlineButtons = buttons.map((btn) => ({
+      text: btn.label,
+      callback_data: btn.action,
+    }));
+
+    await this.telegramRequest(botToken, "sendMessage", {
+      chat_id: chatId,
+      text,
+      parse_mode: "Markdown",
+      reply_markup: {
+        inline_keyboard: [inlineButtons],
+      },
+    });
+  }
+
+  /**
+   * Telegram API request
+   */
+  private telegramRequest(botToken: string, method: string, body: Record<string, unknown>): Promise<void> {
+    return new Promise((resolve, _reject) => {
+      const data = JSON.stringify(body);
+      const options = {
+        hostname: "api.telegram.org",
+        path: `/bot${botToken}/${method}`,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(data),
+        },
+      };
+
+      const req = https.request(options, (res) => {
+        let response = "";
+        res.on("data", (chunk) => (response += chunk));
+        res.on("end", () => {
+          try {
+            const parsed = JSON.parse(response);
+            if (!parsed.ok) {
+              console.error(`Telegram API error: ${parsed.description}`);
+            }
+          } catch (e) {
+            console.error(`JSON parse error: ${e}`);
+          }
+          resolve();
+        });
+      });
+
+      req.on("error", (err: Error) => {
+        console.error(`Telegram API request error: ${err.message}`);
+        resolve();
+      });
+      req.write(data);
+      req.end();
+    });
+  }
+
+  /**
+   * Send to LINE
+   */
+  private async sendLINE(
+    event: NotificationEvent,
+    accessToken: string,
+    userId: string
+  ): Promise<void> {
+    const text = `${event.emoji} ${event.title}\n\n${event.message}`;
+
+    await this.lineRequest(accessToken, "push", {
+      to: userId,
+      messages: [{ type: "text", text }],
+    });
+  }
+
+  /**
+   * Send to LINE with quick reply buttons
+   */
+  private async sendLINEWithButtons(
+    event: NotificationEvent,
+    buttons: NotificationButtons[],
+    accessToken: string,
+    userId: string
+  ): Promise<void> {
+    const text = `${event.emoji} ${event.title}\n\n${event.message}`;
+    
+    const actions = buttons.map((btn) => ({
+      type: "message" as const,
+      label: btn.label,
+      text: btn.action,
+    }));
+
+    await this.lineRequest(accessToken, "push", {
+      to: userId,
+      messages: [
+        { type: "text", text },
+        {
+          type: "text",
+          text: "Quick actions:",
+          quickReply: {
+            items: actions.map((action) => ({
+              type: "action",
+              action,
+            })),
+          },
+        },
+      ],
+    });
+  }
+
+  /**
+   * LINE API request
+   */
+  private lineRequest(accessToken: string, method: string, body: Record<string, unknown>): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const data = JSON.stringify(body);
+      const options = {
+        hostname: "api.line.me",
+        path: `/v2/bot/message/${method}`,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${accessToken}`,
+          "Content-Length": Buffer.byteLength(data),
+        },
+      };
+
+      const req = https.request(options, (res) => {
+        let response = "";
+        res.on("data", (chunk) => (response += chunk));
+        res.on("end", () => {
+          if (res.statusCode !== 200) {
+            console.error(`LINE API error: ${res.statusCode} ${response}`);
+          }
+          resolve();
+        });
+      });
+
+      req.on("error", reject);
+      req.write(data);
+      req.end();
+    });
+  }
+
+  /**
+   * Toggle Telegram notifications
+   */
+  toggleTelegram(enabled: boolean): void {
+    if (!this.config.telegram) {
+      this.config.telegram = { botToken: "", chatId: "", enabled };
+    } else {
+      this.config.telegram.enabled = enabled;
+    }
+    saveConfig(this.config);
+  }
+
+  /**
+   * Toggle LINE notifications
+   */
+  toggleLINE(enabled: boolean): void {
+    if (!this.config.line) {
+      this.config.line = { channelAccessToken: "", userId: "", enabled };
+    } else {
+      this.config.line.enabled = enabled;
+    }
+    saveConfig(this.config);
+  }
+
+  /**
+   * Check if Telegram is enabled
+   */
+  isTelegramEnabled(): boolean {
+    return this.config.telegram?.enabled ?? false;
+  }
+
+  /**
+   * Check if LINE is enabled
+   */
+  isLINEEnabled(): boolean {
+    return this.config.line?.enabled ?? false;
+  }
+}
+
+// Export singleton
+let center: NotificationCenter | null = null;
+
+export function getNotificationCenter(): NotificationCenter {
+  if (!center) {
+    center = new NotificationCenter();
+  }
+  return center;
+}
+
+export function initNotificationCenter(config?: Partial<NotificationConfig>): NotificationCenter {
+  center = new NotificationCenter(config);
+  return center;
+}

package/index.ts

@@ -1078,16 +1078,17 @@ async function advanceCodexTask(
 async function initTelegram(pi: ExtensionAPI): Promise<void> {
 	addHarnessMessage("Telegram", "initializing", "wait");
 	try {
-		const {
-			NotificationCenter,
-			createConversationBridge,
-		} = await import("./packages/notification/dist/index.js");
+		const notifModule = await import("./packages/notification/dist/index.js");
+		const NotificationCenter = notifModule.NotificationCenter;
+		const createConversationBridge = notifModule.createConversationBridge;
 		const { readFileSync, existsSync } = await import("node:fs");
 		const home = process.env.HOME || process.env.USERPROFILE || "/home/frappe";
 		const keysDir = `${home}/.pi-harness-runtime/keys`;
 
 		const botTokenPath = `${keysDir}/telegram-bot-token.txt`;
 		const chatIdPath = `${keysDir}/telegram-chat-id.txt`;
+		const lineTokenPath = `${keysDir}/line-access-token.txt`;
+		const lineUserIdPath = `${keysDir}/line-user-id.txt`;
 
 		if (!existsSync(botTokenPath) || !existsSync(chatIdPath)) {
 			logStartup("[pi-harness] Telegram (@PiHarnessRuntimeBot) not configured:");
@@ -1107,6 +1108,11 @@ async function initTelegram(pi: ExtensionAPI): Promise<void> {
 		const botToken = readFileSync(botTokenPath, "utf8").trim();
 		const chatId = readFileSync(chatIdPath, "utf8").trim();
 
+		// Load LINE credentials
+		const hasLineCredentials = existsSync(lineTokenPath) && existsSync(lineUserIdPath);
+		const lineAccessToken = hasLineCredentials ? readFileSync(lineTokenPath, "utf8").trim() : null;
+		const lineUserId = hasLineCredentials ? readFileSync(lineUserIdPath, "utf8").trim() : null;
+
 		if (!botToken || !chatId) {
 			logStartup("[pi-harness] Telegram: bot token or chat ID is empty — skipping");
 			addHarnessMessage("Telegram", "bot token or chat ID is empty; notifications unavailable", "warn", [
@@ -1115,16 +1121,35 @@ async function initTelegram(pi: ExtensionAPI): Promise<void> {
 			return;
 		}
 
+		const channels: Array<{
+			id: string;
+			type: string;
+			enabled: boolean;
+			config: Record<string, unknown>;
+		}> = [
+			{
+				id: "telegram",
+				type: "telegram",
+				enabled: true,
+				config: { botToken, chatId },
+			},
+		];
+
+		// Add LINE channel if credentials exist
+		if (hasLineCredentials && lineAccessToken && lineUserId) {
+			channels.push({
+				id: "line",
+				type: "line" as const,
+				enabled: true,
+				config: { channelAccessToken: lineAccessToken, userId: lineUserId },
+			});
+			addHarnessMessage("LINE", "configured and enabled", "ok");
+		}
+
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
 		const center = new NotificationCenter({
 			enabled: true,
-			channels: [
-				{
-					id: "telegram",
-					type: "telegram",
-					enabled: true,
-					config: { botToken, chatId },
-				},
-			],
+			channels: channels as any,
 		});
 
 		await center.initialize();
@@ -1187,9 +1212,22 @@ async function initTelegram(pi: ExtensionAPI): Promise<void> {
 					(sharedState.todoContinuationController as any)?.explicitPause?.();
 					break;
 				default:
-					logToFile("[TelegramCallback]", `Unknown action: ${parsed.action}`);
-			}
-		});
+					// Check for channel toggle actions
+					if (parsed.action === "toggle_telegram") {
+						const telegramEnabled = (center as any).isChannelEnabled?.("telegram") ?? true;
+						(center as any).setChannelEnabled?.("telegram", !telegramEnabled);
+						logToFile("[TelegramCallback]", `Telegram ${!telegramEnabled ? "enabled" : "disabled"}`);
+						await acknowledge(`Telegram notifications ${!telegramEnabled ? "enabled" : "disabled"}`);
+					} else if (parsed.action === "toggle_line") {
+						const lineEnabled = (center as any).isChannelEnabled?.("line") ?? true;
+						(center as any).setChannelEnabled?.("line", !lineEnabled);
+						logToFile("[TelegramCallback]", `LINE ${!lineEnabled ? "enabled" : "disabled"}`);
+						await acknowledge(`LINE notifications ${!lineEnabled ? "enabled" : "disabled"}`);
+					} else {
+						logToFile("[TelegramCallback]", `Unknown action: ${parsed.action}`);
+					}
+				}
+			});
 
 		// Register message handler to forward Telegram messages to Pi
 		center.setMessageHandler(async (text: string, _chatId: string) => {
@@ -2396,6 +2434,61 @@ function initJobPipeWatcher(pi: ExtensionAPI): void {
 	logToFile("[JobPipe]", "Watching for Telegram approval commands via API (polling every 60s)");
 }
 
+// --- LINE Voice Queue Watcher: Listen for LINE voice commands ---------
+// Watches the LINE voice queue file and injects transcribed prompts into pi.
+//
+// Flow:
+//   User sends voice message in LINE
+//   → LINE sends webhook to our VPS
+//   → VPS transcribes via Whisper API
+//   → VPS writes command to line-voice-queue.jsonl
+//   → pi-harness polls this file
+//   → pi-harness injects prompt via steer
+function initLineVoiceQueue(pi: ExtensionAPI): void {
+	const homedir = process.env.HOME || process.env.USERPROFILE || "/home/frappe";
+	const queueFile = join(homedir, ".pi-harness-runtime", "line-voice-queue.jsonl");
+
+	const processLineVoiceQueue = async () => {
+		try {
+			const { existsSync, readFileSync, writeFileSync } = await import("node:fs");
+
+			if (!existsSync(queueFile)) {
+				return;
+			}
+
+			const content = readFileSync(queueFile, "utf-8");
+			const lines = content.split("\n").filter((l) => l.trim());
+
+			if (lines.length === 0) {
+				return;
+			}
+
+			// Clear queue
+			writeFileSync(queueFile, "", "utf-8");
+
+			for (const line of lines) {
+				try {
+					const cmd = JSON.parse(line) as { type: string; text: string; userId: string; timestamp: string };
+
+					if (cmd.type === "voice-prompt" && cmd.text) {
+						logToFile("[LineVoice]", `Injecting voice prompt: "${cmd.text}"`);
+						pi.sendUserMessage(cmd.text, { deliverAs: "steer" });
+						logToFile("[LineVoice]", "Voice prompt injected via steer");
+					}
+				} catch {
+					// Skip malformed lines
+				}
+			}
+		} catch {
+			// Ignore errors
+		}
+	};
+
+	// Poll every 5 seconds for new voice commands (voice is more time-sensitive than approvals)
+	setInterval(processLineVoiceQueue, 5_000);
+	logToFile("[LineVoice]", `Watching LINE voice queue: ${queueFile} (polling every 5s)`);
+}
+
 export default async function (pi: ExtensionAPI) {
 	const tracker = new UsageTracker();
 	const mirrorStore = new MirrorStore();
@@ -2442,6 +2535,9 @@ export default async function (pi: ExtensionAPI) {
 	// Collect promise so we can wait for initialization before showing startup notification
 	asyncInitPromises.push(initTelegram(pi));
 
+	// --- line-voice-queue: Watch for LINE voice commands ----
+	void initLineVoiceQueue(pi);
+
 		// --- codex-watcher: Auto-trigger Pi when Codex finishes a plan ---
 		// Flow: detect plan -> settle timer -> file stability check -> cwd match -> trigger
 		try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-harness-runtime",
-  "version": "1.1.341",
+  "version": "1.1.344",
   "description": "[BETA] Codex-style /usage status + autonomous coding harness for pi. Not production ready — expect breaking changes.",
   "type": "module",
   "scripts": {

package/packages/a2a-adapter/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/a2a-adapter",
-  "version": "1.1.341",
+  "version": "1.1.344",
   "type": "module",
   "description": "Google Agent-to-Agent (A2A) protocol adapter for pi-harness",
   "main": "dist/index.js",