opencode-mobile 1.0.0

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "opencode-mobile",
+  "version": "1.0.0",
+  "description": "Mobile push notification plugin for OpenCode - enables push notifications via Expo for mobile devices",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "push-notifications.ts"
+  ],
+  "keywords": [
+    "opencode",
+    "plugin",
+    "push-notifications",
+    "mobile",
+    "expo"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/doza62/opencode-mobile"
+  },
+  "homepage": "https://github.com/doza62/opencode-mobile#readme",
+  "bugs": {
+    "url": "https://github.com/doza62/opencode-mobile/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@ngrok/ngrok": "^1.7.0",
+    "@opencode-ai/plugin": "^1.1.12",
+    "cloudflared": "^0.1.1",
+    "cloudflared-tunnel": "^1.0.3",
+    "localtunnel": "^2.0.2",
+    "ngrok": "^5.0.0-beta.2",
+    "qrcode": "^1.5.4",
+    "qrcode-terminal": "^0.12.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.9",
+    "@types/qrcode": "^1.5.6",
+    "@types/qrcode-terminal": "^0.12.2",
+    "typescript": "^5.8.2"
+  },
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  }
+}

package/push-notifications.ts

@@ -0,0 +1,346 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as net from "net";
+
+declare const Bun: any;
+
+import type { Plugin } from "@opencode-ai/plugin";
+import { startTunnel, stopTunnel, displayQRCode as displayQR, getTunnelDetails } from "./src/tunnel";
+import { getNextAvailablePort } from "./src/utils/port";
+import type { PushToken, Notification, NotificationEvent, PluginContext } from "./src/push";
+import { loadTokens, saveTokens, truncate } from "./src/push/token-store";
+import { formatNotification } from "./src/push/formatter";
+import { sendPush } from "./src/push/sender";
+
+import { createLogger, configureLogger } from "./sdk-logger";
+
+const CONFIG_DIR = path.join(process.env.HOME || "", ".config/opencode");
+
+// Simple console logging (no client.log dependency)
+const logger = createLogger("PushPlugin");
+const TOKEN_FILE = path.join(CONFIG_DIR, "push-tokens.json");
+
+let tokenServerStarted = false;
+let pluginInitialized = false;
+let bunServer: any = null;
+let bunServerPort: number | null = null;
+
+async function startTokenServer(
+  openCodeUrl: string,
+  port: number,
+): Promise<void> {
+  if (tokenServerStarted) return;
+
+  const cors = {
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "GET, POST, DELETE, OPTIONS",
+    "Access-Control-Allow-Headers": "Content-Type, x-opencode-directory",
+  };
+
+  bunServer = Bun.serve({
+    port: port,
+    hostname: "0.0.0.0",
+    idleTimeout: 0, // Disable timeout for SSE connections
+    async fetch(req: Request) {
+      const url = new URL(req.url);
+      if (req.method === "OPTIONS")
+        return new Response(null, { status: 204, headers: cors });
+
+      if (url.pathname === "/push-token" && req.method === "POST") {
+        const body = (await req.json()) as {
+          token?: string;
+          platform?: string;
+          deviceId?: string;
+        };
+        const { token, platform, deviceId } = body;
+        if (!token || !deviceId)
+          return new Response(JSON.stringify({ error: "Missing fields" }), {
+            status: 400,
+            headers: cors,
+          });
+
+        // Validate platform field
+        const validPlatform = (platform && (platform === "ios" || platform === "android")) 
+          ? platform 
+          : "ios";
+
+        const tokens = loadTokens();
+        const idx = tokens.findIndex((t) => t.deviceId === deviceId);
+        const newToken: PushToken = {
+          token,
+          platform: validPlatform,
+          deviceId,
+          registeredAt: new Date().toISOString(),
+        };
+        if (idx >= 0) tokens[idx] = newToken;
+        else tokens.push(newToken);
+        saveTokens(tokens);
+        return new Response(JSON.stringify({ success: true }), {
+          status: 200,
+          headers: cors,
+        });
+      }
+
+      if (url.pathname === "/push-token" && req.method === "DELETE") {
+        const body = (await req.json()) as { deviceId?: string };
+        const { deviceId } = body;
+        saveTokens(loadTokens().filter((t) => t.deviceId !== deviceId));
+        return new Response(JSON.stringify({ success: true }), {
+          status: 200,
+          headers: cors,
+        });
+      }
+
+      if (url.pathname === "/push-token" && req.method === "GET") {
+        return new Response(JSON.stringify({ count: loadTokens().length }), {
+          status: 200,
+          headers: cors,
+        });
+      }
+
+      if (url.pathname === "/push-token/test" && req.method === "POST") {
+        await sendPush({
+          title: "Test",
+          body: "Push notifications working!",
+          data: { type: "test", serverUrl: openCodeUrl },
+        });
+        return new Response(JSON.stringify({ success: true }), {
+          status: 200,
+          headers: cors,
+        });
+      }
+
+      // Return tunnel information
+      if (url.pathname === "/tunnel" && req.method === "GET") {
+        const details = getTunnelDetails();
+        return new Response(JSON.stringify(details, null, 2), {
+          status: 200,
+          headers: { ...cors, "Content-Type": "application/json" },
+        });
+      }
+
+      // Proxy everything else directly to OpenCode server (transparent)
+      const pathname = url.pathname + url.search;
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 10000); // 10 second timeout
+        const proxyReq = new Request(`${openCodeUrl}${pathname}`, {
+          method: req.method,
+          headers: req.headers,
+          body: req.body,
+          redirect: "follow",
+          signal: controller.signal,
+        });
+        try {
+          return await fetch(proxyReq);
+        } catch (e: any) {
+          if (e.name === 'AbortError') {
+            return new Response("Gateway timeout", { status: 504, headers: cors });
+          }
+          throw e;
+        } finally {
+          clearTimeout(timeoutId);
+        }
+      } catch (e) {
+        logger.error("Proxy error:", e);
+        return new Response("Proxy error", { status: 502, headers: cors });
+      }
+    },
+  });
+
+  tokenServerStarted = true;
+}
+
+
+function stopAll(): void {
+  logger.info("Shutting down...");
+
+  stopTunnel();
+  if (bunServer) {
+    logger.info("Stopping Bun server...");
+    bunServer.stop();
+    bunServer = null;
+  }
+  tokenServerStarted = false;
+  logger.info("Shutdown complete");
+}
+
+export const PushNotificationPlugin: Plugin = async (ctx) => {
+  if (pluginInitialized) {
+    return { event: async ({ event }) => {} };
+  }
+  pluginInitialized = true;
+
+  // Skip tunnel setup in server mode (no --serve flag)
+  const processArgs = process.argv.slice(2).join(' ');
+  const hasServeFlag = processArgs.includes('--serve') || processArgs.includes('serve');
+  
+  if (!hasServeFlag) {
+    return {
+      event: async ({ event }) => {},
+    };
+  }
+
+  const serverPort = parseInt(String((ctx as any).serverUrl?.port || 4096), 10);
+  logger.info(`App started. Creating tunnel with ngrok to port ${serverPort}`);
+
+  // Test logging with different levels
+  logger.debug("Detailed development info - appears only with --log-level DEBUG");
+  logger.info("Standard operational message - appears with --log-level INFO, WARN, ERROR");
+  logger.warn("Non-critical issue warning - appears with --log-level WARN, ERROR");
+  logger.error("Critical failure message - appears only with --log-level ERROR");
+
+  // Get server port from ctx, find next available for push-token
+  const pushTokenPort = await getNextAvailablePort(serverPort + 1);
+  bunServerPort = pushTokenPort;
+  const openCodeUrl = `http://127.0.0.1:${serverPort}`;
+  
+  logger.info(`Token API: http://127.0.0.1:${pushTokenPort} → ${openCodeUrl}`);
+
+  try {
+    await startTokenServer(openCodeUrl, pushTokenPort);
+    
+    let tunnelInfo: any;
+    let ngrokFailed = false;
+    
+    try {
+      // Create tunnel directly to OpenCode server (transparent proxy)
+      tunnelInfo = await startTunnel({ port: serverPort, provider: "ngrok" });
+    } catch (ngrokError: any) {
+      const errorMsg = ngrokError.message.toLowerCase();
+      const isAuthIssue = errorMsg.includes("invalid tunnel configuration") || 
+                          errorMsg.includes("authtoken") ||
+                          errorMsg.includes("authentication") ||
+                          errorMsg.includes("auth token") ||
+                          errorMsg.includes("session failed") ||
+                          errorMsg.includes("connect to api.ngrok.com");
+      
+      if (isAuthIssue) {
+        logger.info("Ngrok needs authtoken (ERR_NGROK_4018)");
+        
+        const readline = await import("readline");
+        const rl = readline.createInterface({
+          input: process.stdin,
+          output: process.stdout,
+        });
+        
+        const newToken = await new Promise<string | null>((resolve) => {
+          rl.question("[?] Enter ngrok authtoken (or Enter to skip): ", async (token) => {
+            rl.close();
+            resolve(token && token.trim().length > 25 ? token.trim() : null);
+          });
+        });
+        
+        if (newToken) {
+          logger.info("Writing ngrok config...");
+          
+          // Basic validation - ngrok authtokens are typically 50+ characters
+          if (!newToken || newToken.length < 25) {
+            logger.error("Invalid authtoken format");
+            ngrokFailed = true;
+          } else {
+            try {
+              const { writeFileSync, existsSync, mkdirSync } = fs;
+              const configPath = `${process.env.HOME}/Library/Application Support/ngrok/ngrok.yml`;
+              const configDir = `${process.env.HOME}/Library/Application Support/ngrok`;
+              
+              if (!existsSync(configDir)) {
+                mkdirSync(configDir, { recursive: true });
+              }
+              
+              // Escape any special characters that could break YAML
+              const escapedToken = newToken.replace(/[:\[\]{}|>&*?!@]/g, '\\$&');
+              const v3Config = `version: "3"
+
+agent:
+  authtoken: ${escapedToken}
+`;
+              writeFileSync(configPath, v3Config, { mode: 0o600 });
+              logger.info(`Config: ${configPath}`);
+              
+              // Retry with new authtoken (pass it directly to ngrok.connect)
+              tunnelInfo = await startTunnel({ 
+                port: serverPort, 
+                provider: "ngrok",
+                authToken: newToken 
+              });
+              logger.info("Ngrok tunnel active!");
+            } catch (retryError: any) {
+              logger.error(`Retry failed: ${retryError.message}`);
+              ngrokFailed = true;
+            }
+          }
+        } else {
+          ngrokFailed = true;
+        }
+      } else {
+        ngrokFailed = true;
+      }
+      
+      if (ngrokFailed) {
+        logger.info("Trying localtunnel...");
+        try {
+          tunnelInfo = await startTunnel({ port: serverPort, provider: "localtunnel" });
+        } catch (localtunnelError: any) {
+          logger.error("Localtunnel failed:", localtunnelError.message);
+          throw new Error("All tunnel providers failed");
+        }
+      }
+    }
+    
+    if (!tunnelInfo) {
+      throw new Error("Failed to establish tunnel");
+    }
+    
+    await displayQR(tunnelInfo.url);
+
+    return {
+      event: async ({ event }) => {
+        // Format notification from event
+        const notification = formatNotification(event, tunnelInfo.url, ctx);
+        
+        if (!notification) {
+          // No notification needed for this event type
+          return;
+        }
+
+        // Log the raw event that triggered this push
+        const eventAny = event as any;
+        logger.info("Raw event received", {
+          type: event.type,
+          sessionID: eventAny.sessionID || eventAny.sessionId,
+          timestamp: eventAny.timestamp,
+          properties: event.properties
+        });
+
+        // Log the formatted notification
+        logger.info("Sending push notification", {
+          title: notification.title,
+          body: notification.body,
+          sessionId: notification.data?.sessionId,
+          type: notification.data?.type
+        });
+
+        // Send the push notification
+        await sendPush(notification);
+        
+        logger.debug("Push notification sent successfully");
+      },
+    };
+  } catch (error: any) {
+    logger.error("Failed:", error.message);
+    return { event: async ({ event }) => {} };
+  }
+};
+
+process.on("SIGTERM", () => {
+  stopAll();
+});
+process.on("SIGINT", () => {
+  stopAll();
+});
+process.on("SIGHUP", () => {
+  stopAll();
+});
+
+export default PushNotificationPlugin;