palmier 0.6.0 → 0.6.2

package/palmier-server/pwa/vite.config.ts

@@ -0,0 +1,47 @@
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+import { VitePWA } from "vite-plugin-pwa";
+
+export default defineConfig({
+  server: {
+    host: true,
+    proxy: {
+      "/api": process.env.API_URL || "http://localhost:3000"
+    },
+  },
+  plugins: [
+    react(),
+    VitePWA({
+      strategies: "injectManifest",
+      srcDir: "src",
+      filename: "service-worker.ts",
+      registerType: "autoUpdate",
+      devOptions: {
+        enabled: true,
+        type: "module",
+      },
+      includeAssets: ["favicon.ico", "apple-touch-icon.png"],
+      manifest: {
+        name: "Palmier",
+        short_name: "Palmier",
+        description: "Control AI agents running on your machine from any device. Schedule tasks, monitor runs, and stay in control.",
+        start_url: "/",
+        display: "standalone",
+        background_color: "#ffffff",
+        theme_color: "#2E5CE5",
+        icons: [
+          {
+            src: "pwa-192x192.png",
+            sizes: "192x192",
+            type: "image/png",
+          },
+          {
+            src: "pwa-512x512.png",
+            sizes: "512x512",
+            type: "image/png",
+          },
+        ],
+      },
+    }),
+  ],
+});

package/palmier-server/server/.env.example

@@ -0,0 +1,16 @@
+PORT=3000
+
+# PostgreSQL
+DATABASE_URL=postgresql://user:password@localhost:5432/palmier
+
+# NATS
+NATS_URL=nats://localhost:4222
+NATS_HOST_URL=nats://192.168.1.100:4222
+# Production: wss://nats.palmier.me  LAN dev: ws://192.168.1.100:9222
+NATS_WS_URL=ws://192.168.1.100:9222
+NATS_TOKEN=
+
+# Web Push (generate with: npx web-push generate-vapid-keys)
+VAPID_PUBLIC_KEY=
+VAPID_PRIVATE_KEY=
+VAPID_MAILTO=mailto:admin@example.com

package/palmier-server/server/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "palmier-server",
+  "version": "0.0.1",
+  "private": true,
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "build": "tsc",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "bcrypt": "^5.1.1",
+    "cors": "^2.8.5",
+    "dotenv": "^16.4.7",
+    "express": "^4.21.2",
+    "helmet": "^8.0.0",
+    "jsonwebtoken": "^9.0.2",
+    "nats": "^2.29.1",
+    "pg": "^8.13.1",
+    "uuid": "^11.0.5",
+    "web-push": "^3.6.7"
+  },
+  "devDependencies": {
+    "@types/bcrypt": "^5.0.2",
+    "@types/cors": "^2.8.17",
+    "@types/express": "^5.0.0",
+    "@types/jsonwebtoken": "^9.0.7",
+    "@types/pg": "^8.11.10",
+    "@types/uuid": "^10.0.0",
+    "@types/web-push": "^3.6.4",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.3"
+  }
+}

package/palmier-server/server/src/db.ts

@@ -0,0 +1,34 @@
+import pg from "pg";
+
+const { Pool } = pg;
+
+export const pool = new Pool({
+  connectionString: process.env.DATABASE_URL,
+});
+
+export async function initDb(): Promise<void> {
+  const client = await pool.connect();
+  try {
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS hosts (
+          id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+          name VARCHAR(255),
+          created_at TIMESTAMPTZ DEFAULT NOW()
+      );
+    `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS push_subscriptions (
+          id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+          host_id UUID NOT NULL REFERENCES hosts(id) ON DELETE CASCADE,
+          endpoint TEXT NOT NULL,
+          p256dh TEXT NOT NULL,
+          auth TEXT NOT NULL,
+          created_at TIMESTAMPTZ DEFAULT NOW(),
+          UNIQUE(host_id, endpoint)
+      );
+    `);
+    console.log("Database tables initialized.");
+  } finally {
+    client.release();
+  }
+}

package/palmier-server/server/src/index.ts

@@ -0,0 +1,219 @@
+import "dotenv/config";
+import fs from "fs";
+import path from "path";
+import express from "express";
+import helmet from "helmet";
+import { pool, initDb } from "./db.js";
+import { connectNats, getNatsConnection } from "./nats.js";
+import { sendPushToHost } from "./push.js";
+
+import { StringCodec } from "nats";
+
+import hostsRoutes from "./routes/hosts.js";
+import pushRoutes from "./routes/push.js";
+
+const PORT = parseInt(process.env.PORT || "3000", 10);
+
+async function main(): Promise<void> {
+  // Initialize database tables
+  await initDb();
+
+  // Connect to NATS
+  await connectNats();
+  const sc = StringCodec();
+
+  // Subscribe to unified host-event pub/sub for push notifications
+  (async () => {
+    try {
+      const conn = await getNatsConnection();
+      const sub = conn.subscribe("host-event.>");
+      console.log("Listening for host-event notifications");
+
+      for await (const msg of sub) {
+        try {
+          // Subject: host-event.<host_id>.<task_id>
+          const tokens = msg.subject.split(".");
+          if (tokens.length < 3) continue;
+          const hostId = tokens[1];
+          const taskId = tokens.slice(2).join(".");
+
+          const data = JSON.parse(sc.decode(msg.data)) as {
+            event_type: string;
+            running_state?: string;
+            name?: string;
+            run_id?: string;
+            required_permissions?: Array<{ name: string; description: string }>;
+            input_descriptions?: string[];
+            result_file?: string;
+          };
+
+          if (data.event_type === "confirm-request") {
+            await sendPushToHost(hostId, {
+              type: "confirm",
+              task_id: taskId,
+              host_id: hostId,
+            });
+          } else if (data.event_type === "confirm-resolved") {
+            await sendPushToHost(hostId, {
+              type: "confirm-dismiss",
+              task_id: taskId,
+              host_id: hostId,
+            });
+          } else if (data.event_type === "permission-request") {
+            const taskLabel = data.name
+              ? data.name.length > 60 ? data.name.slice(0, 60) + "…" : data.name
+              : "A task";
+            await sendPushToHost(hostId, {
+              type: "permission",
+              title: "Permission Required",
+              body: `${taskLabel} needs additional permissions to continue.`,
+              task_id: taskId,
+              host_id: hostId,
+            });
+          } else if (data.event_type === "permission-resolved") {
+            await sendPushToHost(hostId, {
+              type: "permission-dismiss",
+              task_id: taskId,
+              host_id: hostId,
+            });
+          } else if (data.event_type === "input-request") {
+            const taskLabel = data.name
+              ? data.name.length > 60 ? data.name.slice(0, 60) + "…" : data.name
+              : "A task";
+            await sendPushToHost(hostId, {
+              type: "input",
+              title: "Input Required",
+              body: `${taskLabel} needs your input to continue.`,
+              task_id: taskId,
+              host_id: hostId,
+            });
+          } else if (data.event_type === "input-resolved") {
+            await sendPushToHost(hostId, {
+              type: "input-dismiss",
+              task_id: taskId,
+              host_id: hostId,
+            });
+          } else if (data.event_type === "report-generated" || (data.event_type === "running-state" && data.running_state === "failed")) {
+            const label = data.name;
+            const taskLabel = label
+              ? label.length > 60 ? label.slice(0, 60) + "…" : label
+              : "Task";
+            const isFailure = data.running_state === "failed";
+            const body = isFailure ? `${taskLabel} — failed` : `${taskLabel} — report ready`;
+            await sendPushToHost(hostId, {
+              type: isFailure ? "fail" : "complete",
+              title: "Palmier",
+              body,
+              task_id: taskId,
+              host_id: hostId,
+              run_id: data.run_id,
+              result_file: data.result_file,
+            });
+          }
+        } catch (err) {
+          console.error("[host-event→Push] Error:", err);
+        }
+      }
+    } catch (err) {
+      console.error("Failed to subscribe to host-event:", err);
+    }
+  })();
+
+  // Subscribe to push notification requests from hosts
+  (async () => {
+    try {
+      const conn = await getNatsConnection();
+      const sub = conn.subscribe("host.*.push.send");
+      console.log("Listening for push notification requests");
+
+      for await (const msg of sub) {
+        try {
+          const data = JSON.parse(sc.decode(msg.data)) as {
+            hostId: string;
+            title: string;
+            body: string;
+            task_id?: string;
+          };
+
+          // Validate hostId in subject matches payload
+          const subjectHostId = msg.subject.split(".")[1];
+          if (data.hostId !== subjectHostId) {
+            if (msg.reply) {
+              msg.respond(sc.encode(JSON.stringify({ error: "hostId mismatch" })));
+            }
+            continue;
+          }
+
+          console.log(`[Push] Sending notification for host ${data.hostId}`);
+          await sendPushToHost(data.hostId, {
+            type: "notification",
+            title: data.title,
+            body: data.body,
+            ...(data.task_id ? { task_id: data.task_id } : {}),
+          });
+
+          if (msg.reply) {
+            msg.respond(sc.encode(JSON.stringify({ ok: true })));
+          }
+        } catch (err) {
+          console.error("[Push] Error sending notification:", err);
+          if (msg.reply) {
+            msg.respond(sc.encode(JSON.stringify({ error: String(err) })));
+          }
+        }
+      }
+    } catch (err) {
+      console.error("Failed to subscribe to push requests:", err);
+    }
+  })();
+
+  // Create Express app
+  const app = express();
+
+  app.use(
+    helmet({
+      contentSecurityPolicy: false,
+    })
+  );
+  app.use(express.json());
+
+  // Mount routes
+  app.use("/api/hosts", hostsRoutes);
+  app.use("/api/push", pushRoutes);
+
+  // Public NATS config endpoint (used by PWA for pairing)
+  app.get("/api/config", (_req, res) => {
+    res.json({
+      natsWsUrl: process.env.NATS_WS_URL || "",
+      natsToken: process.env.NATS_TOKEN || "",
+    });
+  });
+
+  // Health check
+  app.get("/health", async (_req, res) => {
+    try {
+      await pool.query("SELECT 1");
+      res.json({ status: "ok" });
+    } catch {
+      res.status(503).json({ status: "unhealthy" });
+    }
+  });
+
+  // Serve built PWA static files (production only)
+  const pwaDistPath = path.resolve(process.cwd(), "../pwa/dist");
+  if (fs.existsSync(pwaDistPath)) {
+    app.use(express.static(pwaDistPath));
+    app.get("*", (_req, res) => {
+      res.sendFile(path.join(pwaDistPath, "index.html"));
+    });
+  }
+
+  app.listen(PORT, () => {
+    console.log(`Palmier server listening on port ${PORT}`);
+  });
+}
+
+main().catch((err) => {
+  console.error("Failed to start server:", err);
+  process.exit(1);
+});

package/palmier-server/server/src/nats.ts

@@ -0,0 +1,25 @@
+import { connect, NatsConnection } from "nats";
+
+let nc: NatsConnection | null = null;
+
+export async function connectNats(): Promise<NatsConnection> {
+  if (nc) return nc;
+
+  const url = process.env.NATS_URL || "nats://localhost:4222";
+  const token = process.env.NATS_TOKEN;
+
+  nc = await connect({
+    servers: url,
+    ...(token ? { token } : {}),
+  });
+
+  console.log(`Connected to NATS at ${url}`);
+  return nc;
+}
+
+export async function getNatsConnection(): Promise<NatsConnection> {
+  if (!nc) {
+    return connectNats();
+  }
+  return nc;
+}

package/palmier-server/server/src/push.ts

@@ -0,0 +1,68 @@
+import webPush from "web-push";
+import { pool } from "./db.js";
+
+let configured = false;
+
+function ensureConfigured(): void {
+  if (configured) return;
+
+  const publicKey = process.env.VAPID_PUBLIC_KEY;
+  const privateKey = process.env.VAPID_PRIVATE_KEY;
+  const mailto = process.env.VAPID_MAILTO || "mailto:admin@example.com";
+
+  if (!publicKey || !privateKey) {
+    console.warn("VAPID keys not configured. Web Push will not work.");
+    return;
+  }
+
+  webPush.setVapidDetails(mailto, publicKey, privateKey);
+  configured = true;
+}
+
+export async function sendPushToHost(
+  hostId: string,
+  payload: object | string
+): Promise<void> {
+  ensureConfigured();
+  if (!configured) {
+    console.warn("[Push] VAPID not configured, skipping push for host", hostId);
+    return;
+  }
+
+  const result = await pool.query(
+    "SELECT endpoint, p256dh, auth FROM push_subscriptions WHERE host_id = $1",
+    [hostId]
+  );
+
+  const body = typeof payload === "string" ? payload : JSON.stringify(payload);
+
+  const sendPromises = result.rows.map(async (row) => {
+    const subscription: webPush.PushSubscription = {
+      endpoint: row.endpoint,
+      keys: {
+        p256dh: row.p256dh,
+        auth: row.auth,
+      },
+    };
+
+    try {
+      await webPush.sendNotification(subscription, body);
+    } catch (err: any) {
+      if (err.statusCode === 410 || err.statusCode === 404) {
+        // Subscription expired or invalid, remove it
+        await pool.query(
+          "DELETE FROM push_subscriptions WHERE host_id = $1 AND endpoint = $2",
+          [hostId, row.endpoint]
+        );
+        console.log(`Removed stale push subscription for host ${hostId}`);
+      } else {
+        console.error(
+          `Failed to send push to ${row.endpoint}:`,
+          err.message
+        );
+      }
+    }
+  });
+
+  await Promise.allSettled(sendPromises);
+}

package/palmier-server/server/src/routes/hosts.ts

@@ -0,0 +1,45 @@
+import { Router, Request, Response } from "express";
+import type { Router as RouterType } from "express";
+import { pool } from "../db.js";
+
+const router: RouterType = Router();
+
+// POST /api/hosts/register - Register a host (called by palmier init).
+// If the request includes a hostId that already exists, the row is reused
+// so re-initializing a host doesn't create a duplicate entry.
+router.post("/register", async (req: Request, res: Response) => {
+  try {
+    const requestedId: string | undefined = req.body?.hostId;
+
+    let hostId: string;
+    if (requestedId) {
+      // Reuse existing row or create one with the requested id.
+      await pool.query(
+        `INSERT INTO hosts (id) VALUES ($1) ON CONFLICT (id) DO NOTHING`,
+        [requestedId],
+      );
+      hostId = requestedId;
+    } else {
+      const result = await pool.query(
+        "INSERT INTO hosts DEFAULT VALUES RETURNING id"
+      );
+      hostId = result.rows[0].id;
+    }
+
+    const natsUrl = process.env.NATS_HOST_URL || process.env.NATS_URL || "nats://localhost:4222";
+    const natsWsUrl = process.env.NATS_WS_URL || "";
+    const natsToken = process.env.NATS_TOKEN || "";
+
+    res.status(201).json({
+      hostId,
+      natsUrl,
+      natsWsUrl,
+      natsToken,
+    });
+  } catch (err) {
+    console.error("Register host error:", err);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+export default router;

package/palmier-server/server/src/routes/push.ts

@@ -0,0 +1,100 @@
+import { Router, Request, Response } from "express";
+import type { Router as RouterType } from "express";
+import { pool } from "../db.js";
+import { getNatsConnection } from "../nats.js";
+import { StringCodec } from "nats";
+
+const router: RouterType = Router();
+
+// POST /api/push/subscribe - Upsert push subscription (keyed by hostId)
+router.post("/subscribe", async (req: Request, res: Response) => {
+  try {
+    const { hostId, endpoint, keys } = req.body;
+
+    if (!hostId || !endpoint || !keys || !keys.p256dh || !keys.auth) {
+      res.status(400).json({
+        error: "hostId, endpoint, keys.p256dh, and keys.auth are required",
+      });
+      return;
+    }
+
+    await pool.query(
+      `INSERT INTO push_subscriptions (host_id, endpoint, p256dh, auth)
+       VALUES ($1, $2, $3, $4)
+       ON CONFLICT (host_id, endpoint)
+       DO UPDATE SET p256dh = EXCLUDED.p256dh, auth = EXCLUDED.auth`,
+      [hostId, endpoint, keys.p256dh, keys.auth]
+    );
+
+    res.status(201).json({ message: "Push subscription saved" });
+  } catch (err) {
+    console.error("Push subscribe error:", err);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+// DELETE /api/push/subscribe - Delete push subscription by endpoint
+router.delete("/subscribe", async (req: Request, res: Response) => {
+  try {
+    const { hostId, endpoint } = req.body;
+
+    if (!hostId || !endpoint) {
+      res.status(400).json({ error: "hostId and endpoint are required" });
+      return;
+    }
+
+    const result = await pool.query(
+      "DELETE FROM push_subscriptions WHERE host_id = $1 AND endpoint = $2 RETURNING id",
+      [hostId, endpoint]
+    );
+
+    if (result.rows.length === 0) {
+      res.status(404).json({ error: "Subscription not found" });
+      return;
+    }
+
+    res.json({ message: "Push subscription removed" });
+  } catch (err) {
+    console.error("Push unsubscribe error:", err);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+// GET /api/push/vapid-key - Public endpoint
+router.get("/vapid-key", (_req, res: Response) => {
+  const publicKey = process.env.VAPID_PUBLIC_KEY || "";
+  res.json({ publicKey });
+});
+
+// POST /api/push/respond - Respond to a pending confirmation via NATS request-reply
+router.post("/respond", async (req: Request, res: Response) => {
+  try {
+    const { task_id, host_id, response } = req.body;
+
+    if (!task_id || !host_id || !response) {
+      res.status(400).json({
+        error: "task_id, host_id, and response are required",
+      });
+      return;
+    }
+
+    const conn = await getNatsConnection();
+    const sc = StringCodec();
+    const subject = `host.${host_id}.rpc.task.user_input`;
+    const payload = sc.encode(JSON.stringify({ id: task_id, value: [response] }));
+
+    const reply = await conn.request(subject, payload, { timeout: 5000 });
+    const result = JSON.parse(sc.decode(reply.data));
+
+    res.json({ message: "Confirmation response recorded", ...result });
+  } catch (err: any) {
+    console.error("Push respond error:", err);
+    if (err.code === "503" || err.message?.includes("timeout")) {
+      res.status(504).json({ error: "Host did not respond" });
+      return;
+    }
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+export default router;

package/palmier-server/server/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2023",
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "lib": ["ES2023"],
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}