palmier 0.2.6 → 0.2.7

package/src/rpc-handler.ts

@@ -1,5 +1,4 @@
 import { randomUUID } from "crypto";
-import * as os from "os";
 import * as fs from "fs";
 import * as path from "path";
 import { fileURLToPath } from "url";
@@ -20,18 +19,6 @@ const PLAN_GENERATION_PROMPT = fs.readFileSync(
   "utf-8",
 );
 
-function detectLanIp(): string {
-  const interfaces = os.networkInterfaces();
-  for (const name of Object.keys(interfaces)) {
-    for (const iface of interfaces[name] ?? []) {
-      if (iface.family === "IPv4" && !iface.internal) {
-        return iface.address;
-      }
-    }
-  }
-  return "127.0.0.1";
-}
-
 /**
  * Parse RESULT frontmatter into a metadata object.
  */
@@ -238,10 +225,9 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
 
         writeTaskFile(taskDir, existing);
 
-        // Reinstall service and timers
-        const platform = getPlatform();
-        platform.removeTaskTimer(params.id);
-        platform.installTaskTimer(config, existing);
+        // Update timers — installTaskTimer overwrites in-place (schtasks /f,
+        // systemd unit rewrite) without killing a running task process.
+        getPlatform().installTaskTimer(config, existing);
 
         return flattenTask(existing);
       }
@@ -283,10 +269,9 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
           console.error(`task.abort failed for ${params.id}: ${e.stderr || e.message}`);
           return { error: `Failed to abort task: ${e.stderr || e.message}` };
         }
-        // Notify connected clients (NATS + HTTP SSE)
+        // Notify connected clients (NATS + HTTP SSE if LAN server is running)
         const abortPayload: Record<string, unknown> = { event_type: "running-state", running_state: "aborted" };
-        const useHttp = (config.mode ?? "nats") === "lan" || (config.mode ?? "nats") === "auto";
-        await publishHostEvent(nc, config, params.id, abortPayload, useHttp);
+        await publishHostEvent(nc, config.hostId, params.id, abortPayload);
         return { ok: true, task_id: params.id };
       }
 
@@ -394,17 +379,6 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
         return { ok: true, task_id: params.task_id, result_file: params.result_file };
       }
 
-      case "host.directInfo": {
-        if (config.mode === "lan" || config.mode === "auto") {
-          const ip = detectLanIp();
-          return {
-            directUrl: `http://${ip}:${config.directPort ?? 7400}`,
-            directToken: config.directToken,
-          };
-        }
-        return { directUrl: null, directToken: null };
-      }
-
       default:
         return { error: `Unknown method: ${request.method}` };
     }

package/src/transports/http-transport.ts

@@ -3,6 +3,95 @@ import * as os from "os";
 import { validateSession, addSession } from "../session-store.js";
 import type { HostConfig, RpcMessage } from "../types.js";
 
+const PWA_ORIGIN = "https://app.palmier.me";
+
+// ── In-memory PWA asset cache ──────────────────────────────────────────
+
+interface CachedAsset {
+  data: Buffer;
+  contentType: string;
+}
+
+const CONTENT_TYPES: Record<string, string> = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript",
+  ".css": "text/css",
+  ".json": "application/json",
+
+  ".png": "image/png",
+  ".ico": "image/x-icon",
+  ".woff2": "font/woff2",
+  ".woff": "font/woff",
+  ".svg": "image/svg+xml",
+};
+
+function guessContentType(urlPath: string): string {
+  const ext = urlPath.match(/\.[^.]+$/)?.[0] ?? "";
+  return CONTENT_TYPES[ext] ?? "application/octet-stream";
+}
+
+async function fetchBuffer(url: string): Promise<Buffer> {
+  const res = await fetch(url);
+  if (!res.ok) throw new Error(`${res.status} ${res.statusText} for ${url}`);
+  return Buffer.from(await res.arrayBuffer());
+}
+
+/**
+ * Download the PWA from palmier.me into memory.
+ * Parses index.html for asset references, then fetches each one.
+ */
+async function downloadPwaAssets(): Promise<Map<string, CachedAsset>> {
+  const assets = new Map<string, CachedAsset>();
+
+  // 1. Fetch index.html
+  const html = await fetchBuffer(`${PWA_ORIGIN}/`);
+  assets.set("/", { data: html, contentType: "text/html; charset=utf-8" });
+
+  const htmlStr = html.toString("utf-8");
+
+  // 2. Extract references from HTML (src="..." and href="...")
+  // Skip service worker and manifest — they require HTTPS which LAN mode doesn't use
+  const SKIP = new Set(["/registerSW.js", "/service-worker.js", "/manifest.webmanifest"]);
+  const refRegex = /(?:src|href)="([^"]+)"/g;
+  const htmlRefs = new Set<string>();
+  let match;
+  while ((match = refRegex.exec(htmlStr)) !== null) {
+    const ref = match[1];
+    if (ref.startsWith("/") && !ref.startsWith("//") && !SKIP.has(ref)) {
+      htmlRefs.add(ref);
+    }
+  }
+
+  // 3. Fetch all HTML-referenced assets
+  for (const ref of htmlRefs) {
+    try {
+      const data = await fetchBuffer(`${PWA_ORIGIN}${ref}`);
+      assets.set(ref, { data, contentType: guessContentType(ref) });
+
+      // 4. Parse CSS for font url() references
+      if (ref.endsWith(".css")) {
+        const cssStr = data.toString("utf-8");
+        const urlRegex = /url\(["']?([^"')]+)["']?\)/g;
+        let cssMatch;
+        while ((cssMatch = urlRegex.exec(cssStr)) !== null) {
+          let fontRef = cssMatch[1];
+          if (fontRef.startsWith("data:")) continue;
+          // Resolve relative URLs against the CSS file's directory
+          if (!fontRef.startsWith("/")) {
+            const cssDir = ref.substring(0, ref.lastIndexOf("/") + 1);
+            fontRef = cssDir + fontRef;
+          }
+          htmlRefs.add(fontRef);
+        }
+      }
+    } catch (err) {
+      console.warn(`[pwa] Failed to fetch ${ref}: ${err}`);
+    }
+  }
+
+  return assets;
+}
+
 type SseClient = http.ServerResponse;
 
 interface PendingPair {
@@ -30,10 +119,27 @@ export function detectLanIp(): string {
 export async function startHttpTransport(
   config: HostConfig,
   handleRpc: (req: RpcMessage) => Promise<unknown>,
+  port: number,
+  pairingCode?: string,
+  onReady?: () => void,
 ): Promise<void> {
-  const port = config.directPort ?? 7400;
+  // Download PWA assets into memory before starting the server
+  console.log("[http] Downloading PWA assets...");
+  const pwaAssets = await downloadPwaAssets();
+  console.log(`[http] Cached ${pwaAssets.size} PWA assets in memory.`);
+
   const sseClients = new Set<SseClient>();
 
+  // If a pairing code is provided (from `palmier lan`), pre-register it
+  if (pairingCode) {
+    const EXPIRY_MS = 24 * 60 * 60 * 1000; // 24 hours — stays valid while lan server runs
+    const timer = setTimeout(() => { pendingPairs.delete(pairingCode); }, EXPIRY_MS);
+    pendingPairs.set(pairingCode, {
+      resolve: () => {},
+      timer,
+    });
+  }
+
   function broadcastSseEvent(data: unknown) {
     const payload = `data: ${JSON.stringify(data)}\n\n`;
     for (const client of sseClients) {
@@ -41,11 +147,6 @@ export async function startHttpTransport(
     }
   }
 
-  function setCorsHeaders(res: http.ServerResponse) {
-    res.setHeader("Access-Control-Allow-Origin", "*");
-    res.setHeader("Access-Control-Allow-Headers", "Authorization, Content-Type");
-    res.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS");
-  }
 
   function checkAuth(req: http.IncomingMessage): boolean {
     const auth = req.headers.authorization;
@@ -80,15 +181,6 @@ export async function startHttpTransport(
   }
 
   const server = http.createServer(async (req, res) => {
-    setCorsHeaders(res);
-
-    // Handle CORS preflight
-    if (req.method === "OPTIONS") {
-      res.writeHead(204);
-      res.end();
-      return;
-    }
-
     const url = new URL(req.url ?? "/", `http://localhost:${port}`);
     const pathname = url.pathname;
 
@@ -184,7 +276,6 @@ export async function startHttpTransport(
           hostId: config.hostId,
           sessionToken: session.token,
           directUrl: `http://${ip}:${port}`,
-          directToken: config.directToken,
         };
 
         // Resolve the long-poll and clean up
@@ -199,7 +290,21 @@ export async function startHttpTransport(
       return;
     }
 
-    // All other endpoints require auth
+    // Serve cached PWA assets for non-API routes (no auth required)
+    const isApiRoute = pathname === "/events" || pathname.startsWith("/rpc/");
+    if (!isApiRoute) {
+      // SPA fallback: serve index.html for unrecognized paths
+      const asset = pwaAssets.get(pathname) ?? (pathname !== "/" ? pwaAssets.get("/") : undefined);
+      if (asset) {
+        res.writeHead(200, { "Content-Type": asset.contentType });
+        res.end(asset.data);
+      } else {
+        sendJson(res, 404, { error: "Not found" });
+      }
+      return;
+    }
+
+    // API endpoints require auth
     if (!checkAuth(req)) {
       sendJson(res, 401, { error: "Unauthorized" });
       return;
@@ -211,7 +316,6 @@ export async function startHttpTransport(
         "Content-Type": "text/event-stream",
         "Cache-Control": "no-cache",
         Connection: "keep-alive",
-        "Access-Control-Allow-Origin": "*",
       });
       res.write(":ok\n\n");
 
@@ -267,7 +371,7 @@ export async function startHttpTransport(
   return new Promise<void>((resolve, reject) => {
     server.listen(port, () => {
       console.log(`[http] Listening on port ${port}`);
-      console.log(`[http] SSE clients can connect to /events`);
+      onReady?.();
 
       // Graceful shutdown
       const shutdown = () => {

package/src/types.ts

@@ -1,17 +1,13 @@
 export interface HostConfig {
   hostId: string;
   projectRoot: string;
-  mode: "nats" | "lan" | "auto";
 
-  // NATS fields (required when mode === "nats" or "auto")
+  // NATS (always enabled)
+  nats?: boolean;
   natsUrl?: string;
   natsWsUrl?: string;
   natsToken?: string;
 
-  // Direct/LAN fields (required when mode === "lan" or "auto")
-  directPort?: number;
-  directToken?: string;
-
   // Detected agent CLIs
   agents?: Array<{ key: string; label: string }>;
 }