@drewsepsi/nextpi 0.1.0

package/src/web-server.ts

@@ -0,0 +1,280 @@
+#!/usr/bin/env node
+import { createResearchAgent } from "./agent.js";
+import { createServer } from "http";
+import { readFileSync, existsSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const staticDir = join(__dirname, "..", "static");
+
+async function main() {
+  // Check for OpenRouter API key
+  if (!process.env.OPENROUTER_API_KEY) {
+    console.error("Error: OPENROUTER_API_KEY environment variable is required");
+    console.error("Set it with: export OPENROUTER_API_KEY=sk-or-v1-...");
+    process.exit(1);
+  }
+
+  const PORT = process.env.PORT || 3000;
+
+  // Create agent session
+  const session = await createResearchAgent();
+
+  // Track streaming state per client
+  const clients = new Map<string, any>();
+  let currentClientId: string | null = null;
+  let currentRes: any = null;
+
+  // Subscribe to agent events
+  session.subscribe((event) => {
+    if (!currentRes || currentRes.writableEnded) return;
+
+    switch (event.type) {
+      case "message_update":
+        if (event.assistantMessageEvent.type === "text_delta") {
+          currentRes.write(`data: ${JSON.stringify({ 
+            type: "content", 
+            content: event.assistantMessageEvent.delta 
+          })}\n\n`);
+        } else if (event.assistantMessageEvent.type === "thinking_delta") {
+          currentRes.write(`data: ${JSON.stringify({ 
+            type: "thinking", 
+            content: event.assistantMessageEvent.delta 
+          })}\n\n`);
+        }
+        break;
+
+      case "tool_execution_start":
+        currentRes.write(`data: ${JSON.stringify({ 
+          type: "tool_start", 
+          tool: event.toolName, 
+          args: event.args 
+        })}\n\n`);
+        break;
+
+      case "tool_execution_update":
+        // Stream partial tool output
+        if (event.partialResult?.content) {
+          const text = event.partialResult.content
+            .filter((c: any) => c.type === "text")
+            .map((c: any) => c.text)
+            .join("");
+          if (text) {
+            currentRes.write(`data: ${JSON.stringify({ 
+              type: "tool_output", 
+              chunk: text,
+              tool: event.toolName 
+            })}\n\n`);
+          }
+        }
+        break;
+
+      case "tool_execution_end":
+        // Extract output from tool result
+        let output = "";
+        let error = "";
+        if (event.result?.content) {
+          output = event.result.content
+            .filter((c: any) => c.type === "text")
+            .map((c: any) => c.text)
+            .join("");
+        }
+        if (event.isError && event.result?.error) {
+          error = event.result.error;
+        }
+        
+        currentRes.write(`data: ${JSON.stringify({ 
+          type: "tool_end", 
+          tool: event.toolName, 
+          isError: event.isError,
+          output: output.slice(0, 2000), // Limit output
+          error: error
+        })}\n\n`);
+        break;
+
+      case "agent_start":
+        currentRes.write(`data: ${JSON.stringify({ type: "start" })}\n\n`);
+        break;
+
+      case "agent_end":
+        currentRes.write(`data: ${JSON.stringify({ type: "end" })}\n\n`);
+        break;
+
+      case "compaction_start":
+        currentRes.write(`data: ${JSON.stringify({ type: "compacting" })}\n\n`);
+        break;
+
+      case "auto_retry_start":
+        currentRes.write(`data: ${JSON.stringify({ 
+          type: "retry", 
+          attempt: event.attempt,
+          maxAttempts: event.maxAttempts,
+          delayMs: event.delayMs,
+          errorMessage: event.errorMessage
+        })}\n\n`);
+        break;
+
+      case "auto_retry_end":
+        currentRes.write(`data: ${JSON.stringify({ 
+          type: event.success ? "retry_success" : "retry_failed",
+          attempt: event.attempt,
+          finalError: event.finalError
+        })}\n\n`);
+        break;
+    }
+  });
+
+  const server = createServer(async (req, res) => {
+    const url = new URL(req.url || "/", `http://localhost:${PORT}`);
+    const pathname = url.pathname;
+
+    // CORS headers
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+
+    if (req.method === "OPTIONS") {
+      res.writeHead(200);
+      res.end();
+      return;
+    }
+
+    // API endpoints
+    // SSE endpoint for streaming responses
+    if (pathname === "/api/stream" && req.method === "GET") {
+      const clientId = url.searchParams.get("clientId") || "default";
+      currentClientId = clientId;
+      currentRes = res;
+      
+      res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive",
+      });
+
+      // Send initial connection message
+      res.write(`data: ${JSON.stringify({ type: "connected" })}\n\n`);
+
+      req.on("close", () => {
+        if (currentClientId === clientId) {
+          currentClientId = null;
+          currentRes = null;
+        }
+      });
+      return;
+    }
+
+    if (pathname === "/api/chat" && req.method === "POST") {
+      let body = "";
+      req.on("data", chunk => body += chunk);
+      req.on("end", async () => {
+        try {
+          const { message } = JSON.parse(body);
+          
+          // Send the prompt - SSE will stream responses
+          await session.prompt(message);
+          
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ success: true }));
+        } catch (err: any) {
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: err.message }));
+        }
+      });
+      return;
+    }
+
+    if (pathname === "/api/session" && req.method === "GET") {
+      const tokenCount = session.messages.reduce((sum, msg) => {
+        let text = "";
+        if (msg.role === "user") {
+          if (typeof msg.content === "string") {
+            text = msg.content;
+          } else if (Array.isArray(msg.content)) {
+            text = msg.content.map(c => c.type === "text" ? c.text : "").join("");
+          }
+        } else if (msg.role === "assistant") {
+          text = msg.content.map(c => c.type === "text" ? c.text : "").join("");
+        } else if (msg.role === "toolResult") {
+          text = msg.content.map(c => c.type === "text" ? c.text : "").join("");
+        }
+        return sum + Math.ceil(text.length / 4);
+      }, 0);
+
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({
+        model: session.model?.id,
+        messages: session.messages.length,
+        tokens: tokenCount,
+        tools: session.getActiveToolNames(),
+      }));
+      return;
+    }
+
+    if (pathname === "/api/reset" && req.method === "POST") {
+      session.sessionManager.newSession();
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: true }));
+      return;
+    }
+
+    // Serve static files
+    if (pathname === "/" || pathname === "/index.html") {
+      const htmlPath = join(staticDir, "index.html");
+      if (existsSync(htmlPath)) {
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(readFileSync(htmlPath));
+      } else {
+        res.writeHead(500, { "Content-Type": "text/plain" });
+        res.end("Error: index.html not found");
+      }
+      return;
+    }
+
+    if (pathname === "/styles.css") {
+      const cssPath = join(staticDir, "styles.css");
+      if (existsSync(cssPath)) {
+        res.writeHead(200, { 
+          "Content-Type": "text/css",
+          "Cache-Control": "max-age=3600"
+        });
+        res.end(readFileSync(cssPath));
+      } else {
+        res.writeHead(404);
+        res.end("CSS not found");
+      }
+      return;
+    }
+
+    if (pathname === "/app.js") {
+      const jsPath = join(staticDir, "app.js");
+      if (existsSync(jsPath)) {
+        res.writeHead(200, { 
+          "Content-Type": "application/javascript",
+          "Cache-Control": "max-age=3600"
+        });
+        res.end(readFileSync(jsPath));
+      } else {
+        res.writeHead(404);
+        res.end("JS not found");
+      }
+      return;
+    }
+
+    res.writeHead(404);
+    res.end("Not found");
+  });
+
+  server.listen(PORT, () => {
+    console.log(`[NextPi] Web UI running`);
+    console.log(`  Model: ${session.model?.id}`);
+    console.log(`  Tools: ${session.getActiveToolNames().join(", ")}`);
+    console.log(`  URL: http://localhost:${PORT}`);
+  });
+}
+
+main().catch((err) => {
+  console.error("Fatal error:", err);
+  process.exit(1);
+});

package/tsconfig.json

@@ -0,0 +1,34 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./*"]
+    }
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts"
+  ],
+  "exclude": ["node_modules"]
+}