palmier 0.6.6 → 0.6.8

package/palmier-server/pwa/src/components/TaskListView.tsx

@@ -26,16 +26,17 @@ interface TaskListViewProps {
   onViewRun(taskId: string, runId?: string): void;
   onUpdateRequired?(required: boolean): void;
   onVersion?(version: string | null): void;
+  onLocationClientToken?(token: string | null): void;
 }
 
-export default function TaskListView({ connected, hostId, request, subscribeEvents, onViewRun, onUpdateRequired, onVersion }: TaskListViewProps) {
+export default function TaskListView({ connected, hostId, request, subscribeEvents, onViewRun, onUpdateRequired, onVersion, onLocationClientToken }: TaskListViewProps) {
   const [tasks, setTasks] = useState<Task[]>([]);
   const [loadingTasks, setLoadingTasks] = useState(false);
   const [taskError, setTaskError] = useState<string | null>(null);
   const [taskEvents, setTaskStatuss] = useState<Map<string, TaskStatus>>(new Map());
-  const [pendingConfirms, setPendingConfirms] = useState<Set<string>>(new Set());
+  const [pendingConfirms, setPendingConfirms] = useState<Map<string, { description: string; agentName?: string }>>(new Map());
   const [pendingPermissions, setPendingPermissions] = useState<Map<string, RequiredPermission[]>>(new Map());
-  const [pendingInputs, setPendingInputs] = useState<Map<string, string[]>>(new Map());
+  const [pendingInputs, setPendingInputs] = useState<Map<string, { questions: string[]; description?: string; agentName?: string }>>(new Map());
   const [inputValues, setInputValues] = useState<Map<string, string[]>>(new Map());
 
   const [showForm, setShowForm] = useState(false);
@@ -52,20 +53,20 @@ export default function TaskListView({ connected, hostId, request, subscribeEven
     setLoadingTasks(true);
     setTaskError(null);
     try {
-      const result = await request<{ tasks?: (Task & { status?: TaskStatus })[]; agents?: AgentInfo[]; version?: string | null; host_platform?: string }>("task.list");
+      const result = await request<{ tasks?: (Task & { status?: TaskStatus })[]; agents?: AgentInfo[]; version?: string | null; host_platform?: string; location_client_token?: string | null }>("task.list");
       const taskList = result.tasks ?? [];
       const initialEvents = new Map<string, TaskStatus>();
-      const initialConfirms = new Set<string>();
+      const initialConfirms = new Map<string, { description: string; agentName?: string }>();
       const initialPerms = new Map<string, RequiredPermission[]>();
-      const initialInputs = new Map<string, string[]>();
+      const initialInputs = new Map<string, { questions: string[]; description?: string; agentName?: string }>();
       const initialInputVals = new Map<string, string[]>();
       for (const t of taskList) {
         if (t.status) {
           initialEvents.set(t.id, t.status);
-          if (t.status.pending_confirmation) initialConfirms.add(t.id);
+          // pending_confirmation no longer comes from task.list (confirmation is sessionId-based now)
           if (t.status.pending_permission?.length) initialPerms.set(t.id, t.status.pending_permission);
           if (t.status.pending_input?.length) {
-            initialInputs.set(t.id, t.status.pending_input);
+            initialInputs.set(t.id, { questions: t.status.pending_input });
             initialInputVals.set(t.id, new Array(t.status.pending_input.length).fill(""));
           }
         }
@@ -81,6 +82,7 @@ export default function TaskListView({ connected, hostId, request, subscribeEven
       setAgentLabels(result.agents ?? []);
       const version = result.version ?? null;
       onVersion?.(version);
+      onLocationClientToken?.(result.location_client_token ?? null);
       onUpdateRequired?.(!!version && isOlderThan(version, MIN_HOST_VERSION));
     } catch (err) {
       const errMsg = err instanceof Error ? err.message : String(err);
@@ -109,43 +111,81 @@ export default function TaskListView({ connected, hostId, request, subscribeEven
       if (tokens.length < 3) return;
       const taskId = tokens.slice(2).join(".");
 
-      let eventType: string | undefined;
+      let parsed: Record<string, unknown> = {};
       try {
-        const parsed = JSON.parse(sc.decode(msg.data)) as { event_type?: string };
-        eventType = parsed.event_type;
+        parsed = JSON.parse(sc.decode(msg.data)) as Record<string, unknown>;
       } catch { return; }
+      const eventType = parsed.event_type as string | undefined;
+      const sessionId = parsed.session_id as string | undefined;
 
-      // Handle confirm-resolved: close pending confirmation dialog
-      if (eventType === "confirm-resolved") {
-        setPendingConfirms((prev) => {
-          if (!prev.has(taskId)) return prev;
-          const next = new Set(prev);
-          next.delete(taskId);
-          return next;
-        });
+      // Handle input-request: show standalone input dialog (keyed by sessionId)
+      if (eventType === "input-request" && sessionId) {
+        const questions = parsed.input_questions as string[];
+        const agentName = parsed.agent_name as string | undefined;
+        const description = parsed.description as string | undefined;
+        if (questions?.length) {
+          setPendingInputs((prev) => {
+            if (prev.has(sessionId)) return prev;
+            const next = new Map(prev);
+            next.set(sessionId, { questions, description, agentName });
+            return next;
+          });
+          setInputValues((prev) => {
+            if (prev.has(sessionId)) return prev;
+            const next = new Map(prev);
+            next.set(sessionId, new Array(questions.length).fill(""));
+            return next;
+          });
+        }
         return;
       }
 
-      // Handle permission-resolved: close pending permission dialog
-      if (eventType === "permission-resolved") {
-        setPendingPermissions((prev) => {
-          if (!prev.has(taskId)) return prev;
+      // Handle input-resolved: close pending input dialog
+      if (eventType === "input-resolved" && sessionId) {
+        setPendingInputs((prev) => {
+          if (!prev.has(sessionId)) return prev;
           const next = new Map(prev);
-          next.delete(taskId);
+          next.delete(sessionId);
+          return next;
+        });
+        setInputValues((prev) => {
+          const next = new Map(prev);
+          next.delete(sessionId);
           return next;
         });
         return;
       }
 
-      // Handle input-resolved: close pending input dialog
-      if (eventType === "input-resolved") {
-        setPendingInputs((prev) => {
-          if (!prev.has(taskId)) return prev;
+      // Handle confirm-request: show standalone confirmation dialog (keyed by sessionId)
+      if (eventType === "confirm-request" && sessionId) {
+        const description = parsed.description as string;
+        const agentName = parsed.agent_name as string | undefined;
+        if (description) {
+          setPendingConfirms((prev) => {
+            if (prev.has(sessionId)) return prev;
+            const next = new Map(prev);
+            next.set(sessionId, { description, agentName });
+            return next;
+          });
+        }
+        return;
+      }
+
+      // Handle confirm-resolved: close pending confirmation dialog
+      if (eventType === "confirm-resolved" && sessionId) {
+        setPendingConfirms((prev) => {
+          if (!prev.has(sessionId)) return prev;
           const next = new Map(prev);
-          next.delete(taskId);
+          next.delete(sessionId);
           return next;
         });
-        setInputValues((prev) => {
+        return;
+      }
+
+      // Handle permission-resolved: close pending permission dialog
+      if (eventType === "permission-resolved") {
+        setPendingPermissions((prev) => {
+          if (!prev.has(taskId)) return prev;
           const next = new Map(prev);
           next.delete(taskId);
           return next;
@@ -157,14 +197,6 @@ export default function TaskListView({ connected, hostId, request, subscribeEven
         const status = await request<TaskStatus & { error?: string }>("task.status", { id: taskId }, { timeout: 5000 });
         if (status.error) return;
         setTaskStatuss((prev) => { const next = new Map(prev); next.set(taskId, status); return next; });
-        if (status.pending_confirmation) {
-          setPendingConfirms((prev) => {
-            if (prev.has(taskId)) return prev;
-            const next = new Set(prev);
-            next.add(taskId);
-            return next;
-          });
-        }
         if (status.pending_permission?.length) {
           setPendingPermissions((prev) => {
             if (prev.has(taskId)) return prev;
@@ -173,28 +205,14 @@ export default function TaskListView({ connected, hostId, request, subscribeEven
             return next;
           });
         }
-        if (status.pending_input?.length) {
-          setPendingInputs((prev) => {
-            if (prev.has(taskId)) return prev;
-            const next = new Map(prev);
-            next.set(taskId, status.pending_input!);
-            return next;
-          });
-          setInputValues((prev) => {
-            if (prev.has(taskId)) return prev;
-            const next = new Map(prev);
-            next.set(taskId, new Array(status.pending_input!.length).fill(""));
-            return next;
-          });
-        }
       } catch { /* skip */ }
     });
     return unsubscribe;
   }, [connected, hostId, subscribeEvents, request]);
 
-  async function respondToConfirm(taskId: string, response: "confirmed" | "aborted") {
+  async function respondToConfirm(sessionId: string, response: "confirmed" | "aborted") {
     try {
-      await request("task.user_input", { id: taskId, value: [response] });
+      await request("task.user_input", { id: sessionId, value: [response] });
     } catch (err) {
       console.error("[TaskListView] Failed to respond to confirmation:", err);
     }
@@ -208,9 +226,9 @@ export default function TaskListView({ connected, hostId, request, subscribeEven
     }
   }
 
-  async function respondToInput(taskId: string, values: string[]) {
+  async function respondToInput(sessionId: string, values: string[]) {
     try {
-      await request("task.user_input", { id: taskId, value: values });
+      await request("task.user_input", { id: sessionId, value: values });
     } catch (err) {
       console.error("[TaskListView] Failed to respond to input request:", err);
     }
@@ -300,20 +318,19 @@ export default function TaskListView({ connected, hostId, request, subscribeEven
       )}
 
       {createPortal(<>
-      {[...pendingConfirms].map((taskId) => {
-        const task = tasks.find((t) => t.id === taskId);
+      {[...pendingConfirms.entries()].map(([sessionId, { description, agentName }]) => {
+        const subtitle = agentName || tasks.find((t) => t.id === sessionId)?.name;
         return (
-          <div key={taskId} className="confirm-modal-overlay">
+          <div key={sessionId} className="confirm-modal-overlay">
             <div className="confirm-modal">
-              <h2 className="confirm-modal-title">Task Confirmation</h2>
-              <p className="confirm-modal-message">
-                Run task "<strong>{task?.name || task?.user_prompt || taskId}</strong>"?
-              </p>
+              <h2 className="confirm-modal-title">Confirmation Required</h2>
+              {subtitle && <p className="confirm-modal-subtitle">{subtitle}</p>}
+              <p className="confirm-modal-message">{description}</p>
               <div className="confirm-modal-actions">
-                <button className="btn btn-primary" onClick={() => respondToConfirm(taskId, "confirmed")}>
+                <button className="btn btn-primary" onClick={() => respondToConfirm(sessionId, "confirmed")}>
                   Confirm
                 </button>
-                <button className="btn btn-secondary" onClick={() => respondToConfirm(taskId, "aborted")}>
+                <button className="btn btn-secondary" onClick={() => respondToConfirm(sessionId, "aborted")}>
                   Abort
                 </button>
               </div>
@@ -358,18 +375,17 @@ export default function TaskListView({ connected, hostId, request, subscribeEven
         );
       })}
 
-      {[...pendingInputs.entries()].map(([taskId, descriptions]) => {
-        const task = tasks.find((t) => t.id === taskId);
-        const values = inputValues.get(taskId) ?? new Array(descriptions.length).fill("");
+      {[...pendingInputs.entries()].map(([sessionId, { questions, description, agentName }]) => {
+        const values = inputValues.get(sessionId) ?? new Array(questions.length).fill("");
+        const subtitle = agentName || tasks.find((t) => t.id === sessionId)?.name;
         return (
-          <div key={taskId} className="confirm-modal-overlay">
+          <div key={sessionId} className="confirm-modal-overlay">
             <div className="confirm-modal input-modal">
               <h2 className="confirm-modal-title">Input Required</h2>
-              <p className="confirm-modal-message">
-                <strong>{task?.name || task?.user_prompt || taskId}</strong>
-              </p>
+              {subtitle && <p className="confirm-modal-subtitle">{subtitle}</p>}
+              {description && <p className="confirm-modal-message">{description}</p>}
               <div className="input-list">
-                {descriptions.map((desc, i) => (
+                {questions.map((desc: string, i: number) => (
                   <div key={i} className="input-item">
                     <label className="input-label">{desc}</label>
                     <input
@@ -379,9 +395,9 @@ export default function TaskListView({ connected, hostId, request, subscribeEven
                       onChange={(e) => {
                         setInputValues((prev) => {
                           const next = new Map(prev);
-                          const arr = [...(next.get(taskId) ?? [])];
+                          const arr = [...(next.get(sessionId) ?? [])];
                           arr[i] = e.target.value;
-                          next.set(taskId, arr);
+                          next.set(sessionId, arr);
                           return next;
                         });
                       }}
@@ -394,16 +410,16 @@ export default function TaskListView({ connected, hostId, request, subscribeEven
                 <button
                   className="btn btn-primary"
                   disabled={values.some((v) => !v.trim())}
-                  onClick={() => respondToInput(taskId, values)}
+                  onClick={() => respondToInput(sessionId, values)}
                 >
                   Submit
                 </button>
               </div>
               <button
                 className="permission-abort-link"
-                onClick={() => respondToInput(taskId, ["aborted"])}
+                onClick={() => respondToInput(sessionId, ["aborted"])}
               >
-                Cancel & Abort Task
+                Cancel
               </button>
             </div>
           </div>

package/palmier-server/pwa/src/constants.ts

@@ -1,2 +1,2 @@
 /** Bump when a breaking host change is made. */
-export const MIN_HOST_VERSION = "0.6.4";
+export const MIN_HOST_VERSION = "0.6.7";

package/palmier-server/pwa/src/contexts/HostConnectionContext.tsx

@@ -8,6 +8,7 @@ import {
   type ReactNode,
 } from "react";
 import { connect, StringCodec, type NatsConnection, type Subscription } from "nats.ws";
+import { SERVER_URL } from "../api";
 import { useHostStore } from "./HostStoreContext";
 import type { PairedHost } from "../types";
 
@@ -89,7 +90,7 @@ export function HostConnectionProvider({ children }: { children: ReactNode }) {
 
     async function init() {
       try {
-        const res = await fetch("/api/config");
+        const res = await fetch(`${SERVER_URL}/api/config`);
         if (!res.ok) {
           console.error("[NATS] Failed to fetch config");
           return;

package/palmier-server/pwa/src/hooks/usePushSubscription.ts

@@ -1,4 +1,5 @@
 import { useEffect, useRef } from "react";
+import { Capacitor } from "@capacitor/core";
 import { useHostStore } from "../contexts/HostStoreContext";
 import { apiPost, apiGet } from "../api";
 
@@ -8,6 +9,8 @@ export function usePushSubscription() {
   const subscribedRef = useRef<string | null>(null);
 
   useEffect(() => {
+    // Native app uses FCM for notifications, not Web Push
+    if (Capacitor.isNativePlatform()) return;
     // Skip push subscription for direct-only (LAN) hosts — no cloud server to relay through
     if (!activeHost || activeHost.directUrl || subscribedRef.current === activeHost.hostId) return;
 

package/palmier-server/pwa/src/pages/Dashboard.tsx

@@ -47,6 +47,7 @@ export default function Dashboard() {
   const [updating, setUpdating] = useState(false);
   const [updateError, setUpdateError] = useState<string | null>(null);
   const [daemonVersion, setDaemonVersion] = useState<string | null>(null);
+  const [locationClientToken, setLocationClientToken] = useState<string | null>(null);
 
   // Register push subscription for the active host
   usePushSubscription();
@@ -83,14 +84,15 @@ export default function Dashboard() {
 
   const hasHosts = pairedHosts.length > 0;
   const showTaskContent = hasHosts && connected && activeHostId && !unauthorized;
+  const activeClientToken = pairedHosts.find((h) => h.hostId === activeHostId)?.clientToken ?? null;
 
   return (
     <div className="dashboard">
-      {isDesktop && <HostMenu daemonVersion={daemonVersion} />}
+      {isDesktop && <HostMenu daemonVersion={daemonVersion} locationClientToken={locationClientToken} activeClientToken={activeClientToken} request={request} onLocationClientTokenChange={setLocationClientToken} />}
 
       <div className="dashboard-content">
         <div className="tab-bar">
-          {!isDesktop && <HostMenu daemonVersion={daemonVersion} />}
+          {!isDesktop && <HostMenu daemonVersion={daemonVersion} locationClientToken={locationClientToken} activeClientToken={activeClientToken} request={request} onLocationClientTokenChange={setLocationClientToken} />}
           <TabBar />
         </div>
 
@@ -139,6 +141,7 @@ export default function Dashboard() {
                 onViewRun={handleViewRun}
                 onUpdateRequired={setUpdateRequired}
                 onVersion={setDaemonVersion}
+                onLocationClientToken={setLocationClientToken}
               />
             </div>
             {isRunDetail ? (

package/palmier-server/pwa/src/pages/PairHost.tsx

@@ -1,7 +1,10 @@
 import { useState } from "react";
 import { useNavigate } from "react-router-dom";
 import { connect, StringCodec } from "nats.ws";
+import { Capacitor } from "@capacitor/core";
+import { Preferences } from "@capacitor/preferences";
 import { useHostStore } from "../contexts/HostStoreContext";
+import { SERVER_URL } from "../api";
 import type { PairedHost } from "../types";
 
 interface PairResponse {
@@ -49,7 +52,7 @@ export default function PairHost() {
         response = await res.json() as PairResponse;
       } else {
         // Server mode — pair via NATS
-        const configRes = await fetch("/api/config");
+        const configRes = await fetch(`${SERVER_URL}/api/config`);
         if (!configRes.ok) throw new Error("Failed to fetch server config");
         const config = await configRes.json() as { natsWsUrl: string; natsToken: string };
         if (!config.natsWsUrl) throw new Error("Server has no NATS WebSocket URL configured");
@@ -78,6 +81,12 @@ export default function PairHost() {
       };
 
       addPairedHost(host);
+
+      // Write hostId to native SharedPreferences for FCM token registration
+      if (Capacitor.isNativePlatform()) {
+        await Preferences.set({ key: "hostId", value: response.hostId });
+      }
+
       navigate("/");
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);

package/palmier-server/pwa/src/service-worker.ts

@@ -33,14 +33,15 @@ self.addEventListener("push", (event) => {
   // Silent dismiss: close matching notification without showing a new one
   if (type === "confirm-dismiss" || type === "permission-dismiss" || type === "input-dismiss") {
     const data = payload.data ?? payload;
-    const taskId = (data as Record<string, unknown>).task_id;
     const dataHostId = (data as Record<string, unknown>).host_id;
+    const requestId = (data as Record<string, unknown>).session_id;
+    const taskId = (data as Record<string, unknown>).task_id; // permission-dismiss still uses task_id
     event.waitUntil(
       self.registration.getNotifications().then((notifications) => {
         for (const n of notifications) {
-          if (n.data?.task_id === taskId && n.data?.host_id === dataHostId) {
-            n.close();
-          }
+          if (n.data?.host_id !== dataHostId) continue;
+          if (requestId && n.data?.session_id === requestId) { n.close(); continue; }
+          if (taskId && n.data?.task_id === taskId) { n.close(); } // permission only
         }
       })
     );
@@ -85,7 +86,7 @@ self.addEventListener("notificationclick", (event) => {
   const data = notification.data ?? {};
   const action = event.action;
 
-  if (action && data.type === "confirm" && data.task_id && data.host_id) {
+  if (action && data.type === "confirm" && data.session_id && data.host_id) {
     const response = action === "confirm" ? "confirmed" : "aborted";
 
     event.waitUntil(
@@ -93,8 +94,7 @@ self.addEventListener("notificationclick", (event) => {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({
-          type: data.type,
-          task_id: data.task_id,
+          session_id: data.session_id,
           host_id: data.host_id,
           response,
         }),

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

@@ -14,3 +14,7 @@ NATS_TOKEN=
 VAPID_PUBLIC_KEY=
 VAPID_PRIVATE_KEY=
 VAPID_MAILTO=mailto:admin@example.com
+
+# Firebase Admin SDK (for FCM push to Android devices)
+# Download from: Firebase Console → Project Settings → Service accounts → Generate new private key
+GOOGLE_APPLICATION_CREDENTIALS=./palmier-firebase-adminsdk.json

package/palmier-server/server/package.json

@@ -12,6 +12,7 @@
     "cors": "^2.8.5",
     "dotenv": "^16.4.7",
     "express": "^4.21.2",
+    "firebase-admin": "^13.8.0",
     "helmet": "^8.0.0",
     "jsonwebtoken": "^9.0.2",
     "nats": "^2.29.1",

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

@@ -27,6 +27,16 @@ export async function initDb(): Promise<void> {
           UNIQUE(host_id, endpoint)
       );
     `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS fcm_tokens (
+          id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+          host_id UUID NOT NULL REFERENCES hosts(id) ON DELETE CASCADE,
+          fcm_token TEXT NOT NULL,
+          device_label VARCHAR(255),
+          updated_at TIMESTAMPTZ DEFAULT NOW(),
+          UNIQUE(host_id, fcm_token)
+      );
+    `);
     console.log("Database tables initialized.");
   } finally {
     client.release();

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

@@ -0,0 +1,74 @@
+import admin from "firebase-admin";
+import { pool } from "./db.js";
+
+let initialized = false;
+
+function ensureInitialized(): boolean {
+  if (initialized) return true;
+
+  if (!process.env.GOOGLE_APPLICATION_CREDENTIALS) {
+    console.warn("GOOGLE_APPLICATION_CREDENTIALS not set. FCM will not work.");
+    return false;
+  }
+
+  admin.initializeApp({
+    credential: admin.credential.applicationDefault(),
+  });
+  initialized = true;
+  return true;
+}
+
+export async function sendFcmToClients(
+  hostId: string,
+  data: Record<string, string>
+): Promise<void> {
+  if (!ensureInitialized()) {
+    console.warn("[FCM] Not initialized, skipping message for host", hostId);
+    return;
+  }
+
+  const result = await pool.query(
+    "SELECT fcm_token FROM fcm_tokens WHERE host_id = $1",
+    [hostId]
+  );
+
+  if (result.rows.length === 0) {
+    console.warn(`[FCM] No FCM tokens registered for host ${hostId}`);
+    return;
+  }
+
+  const sendPromises = result.rows.map(async (row) => {
+    try {
+      await admin.messaging().send({
+        token: row.fcm_token,
+        data,
+      });
+    } catch (err: any) {
+      if (
+        err.code === "messaging/registration-token-not-registered" ||
+        err.code === "messaging/invalid-registration-token"
+      ) {
+        await pool.query(
+          "DELETE FROM fcm_tokens WHERE host_id = $1 AND fcm_token = $2",
+          [hostId, row.fcm_token]
+        );
+        console.log(`[FCM] Removed stale token for host ${hostId}`);
+      } else {
+        console.error(`[FCM] Failed to send to token:`, err.message);
+      }
+    }
+  });
+
+  await Promise.allSettled(sendPromises);
+}
+
+export async function sendFcmToDevice(
+  fcmToken: string,
+  data: Record<string, string>
+): Promise<void> {
+  if (!ensureInitialized()) {
+    throw new Error("FCM not initialized");
+  }
+
+  await admin.messaging().send({ token: fcmToken, data });
+}