palmier 0.6.5 → 0.6.7

package/README.md

@@ -34,7 +34,7 @@ It runs on your machine as a background daemon and connects to a mobile-friendly
 
 ## How It Works
 
-Palmier runs as a background daemon (systemd on Linux, Task Scheduler on Windows). It invokes your agent CLIs directly, schedules tasks via native OS timers, and exposes an API that the PWA connects to — either directly over HTTP or remotely through a relay server.
+Palmier runs as a background daemon (systemd on Linux, Task Scheduler on Windows). It invokes your agent CLIs directly, schedules tasks via native OS timers, and exposes an API that the PWA connects to — either directly over HTTP or remotely through a relay server. Agents can interact with the user's mobile device during execution — requesting input, sending push notifications, and fetching GPS location.
 
 ```
 ┌──────────────┐         HTTP          ┌──────────────────┐

package/dist/agents/agent-instructions.md

@@ -18,18 +18,40 @@ If the task fails because a tool was denied or you lack the required permissions
 
 ## HTTP Endpoints
 
-The following HTTP endpoints are available at http://localhost:{{PORT}} during task execution. Use curl to call them.
+The following HTTP endpoints are available at http://localhost:{{PORT}} during task execution. Use curl to call them. All endpoints require `taskId` in the request body.
 
-**Requesting user input** — When you need information from the user (credentials, answers to questions, preferences, clarifications, etc.), do not guess, fail, or prompt via stdout, even in a non-interactive environment. Instead, POST to `/request-input` with:
+**`POST /request-input`** — Request input from the user. The request blocks until the user responds.
 ```json
-{"taskId":"{{TASK_ID}}","descriptions":["question 1","question 2"]}
+{"taskId": "{{TASK_ID}}", "description": "optional context", "questions": ["question 1", "question 2"]}
 ```
-The request blocks until the user responds. Response: `{"values":["answer1","answer2"]}` on success, or `{"aborted":true}` if the user declines.
+- `taskId` (required, string): The current task ID.
+- `questions` (required, string array): Questions to present to the user.
+- `description` (optional, string): Context or heading for the input request.
+- Response: `{"values": ["answer1", "answer2"]}` on success, or `{"aborted": true}` if the user declines.
+- When you need information from the user (credentials, answers to questions, preferences, clarifications, etc.), do not guess, fail, or prompt via stdout, even in a non-interactive environment. Use this endpoint instead.
 
-**Sending push notifications** — To notify the user, POST to `/notify` with:
+**`POST /request-confirmation`** — Request confirmation from the user. The request blocks until the user confirms or aborts.
 ```json
-{"taskId":"{{TASK_ID}}","title":"...","body":"..."}
+{"taskId": "{{TASK_ID}}", "description": "What the user is confirming"}
 ```
+- `taskId` (required, string): The current task ID.
+- `description` (required, string): What the user is confirming.
+- Response: `{"confirmed": true}` or `{"confirmed": false}`.
+
+**`POST /device-geolocation`** — Get the GPS location of the user's mobile device. Blocks until the device responds (up to 30 seconds).
+```json
+{"taskId": "{{TASK_ID}}"}
+```
+- `taskId` (required, string): The current task ID.
+- Response: `{"latitude": ..., "longitude": ..., "accuracy": ..., "timestamp": ...}` on success, or `{"error": "..."}` on failure.
+
+**`POST /notify`** — Send a push notification to the user's device.
+```json
+{"taskId": "{{TASK_ID}}", "title": "...", "body": "..."}
+```
+- `taskId` (required, string): The current task ID.
+- `title` (required, string): Notification title.
+- `body` (required, string): Notification body.
 
 ---
 

package/dist/agents/agent.js

@@ -14,6 +14,7 @@ import { Cursor } from "./cursor.js";
 import { Kiro } from "./kiro.js";
 import { Cline } from "./cline.js";
 import { Qoder } from "./qoder.js";
+import { Hermes } from "./hermes.js";
 const agentRegistry = {
     claude: new ClaudeAgent(),
     gemini: new GeminiAgent(),
@@ -31,6 +32,7 @@ const agentRegistry = {
     kiro: new Kiro(),
     cline: new Cline(),
     qoder: new Qoder(),
+    hermes: new Hermes(),
 };
 const agentLabels = {
     claude: "Claude Code",
@@ -46,9 +48,10 @@ const agentLabels = {
     deepagents: "Deep Agents CLI",
     aider: "Aider",
     cursor: "Cursor CLI",
-    kiro: "Kiro",
-    cline: "Cline",
-    qoder: "Qoder",
+    kiro: "Kiro CLI",
+    cline: "Cline CLI",
+    qoder: "Qoder CLI",
+    hermes: "Hermes Agent",
 };
 export async function detectAgents() {
     const detected = [];

package/dist/agents/hermes.d.ts

@@ -0,0 +1,9 @@
+import type { ParsedTask, RequiredPermission } from "../types.js";
+import type { AgentTool, CommandLine } from "./agent.js";
+export declare class Hermes implements AgentTool {
+    supportsPermissions: boolean;
+    getPlanGenerationCommandLine(prompt: string): CommandLine;
+    getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[] | "yolo"): CommandLine;
+    init(): Promise<boolean>;
+}
+//# sourceMappingURL=hermes.d.ts.map

package/dist/agents/hermes.js

@@ -0,0 +1,35 @@
+import { execSync } from "child_process";
+import { getAgentInstructions } from "./shared-prompt.js";
+import { SHELL } from "../platform/index.js";
+export class Hermes {
+    supportsPermissions = false;
+    getPlanGenerationCommandLine(prompt) {
+        return {
+            command: "hermes",
+            args: ["chat", "-q", prompt],
+        };
+    }
+    getTaskRunCommandLine(task, followupPrompt, extraPermissions) {
+        const yolo = extraPermissions === "yolo";
+        const prompt = followupPrompt ?? (getAgentInstructions(task.frontmatter.id, yolo || !this.supportsPermissions) + "\n\n" + (task.body || task.frontmatter.user_prompt));
+        const args = ["chat"];
+        if (yolo) {
+            args.push("--trust-all-tools");
+        }
+        if (followupPrompt) {
+            args.push("--continue");
+        } // continue mode for followups
+        args.push("-q", prompt);
+        return { command: "hermes", args };
+    }
+    async init() {
+        try {
+            execSync("hermes --version", { stdio: "ignore", shell: SHELL });
+        }
+        catch {
+            return false;
+        }
+        return true;
+    }
+}
+//# sourceMappingURL=hermes.js.map

package/dist/commands/plan-generation.md

@@ -16,6 +16,7 @@ task_name: <concise label, 3-6 words>
 - If the task produces formatted output (report, email, summary, etc.), specify the structure, sections, and tone.
 - When a step requires user input, simply state what information is needed from the user. Do **not** specify how to obtain it — the agent has its own tool for requesting user input.
 - Preserve relative time expressions (e.g., "today", "yesterday", "last week") exactly as written — do **not** resolve them to specific dates. The plan may be executed on a different day than it was generated.
+- If the task involves opening a web browser or application, include a final step to close it before finishing.
 
 ## Task Description
 

package/dist/commands/run.js

@@ -39,7 +39,7 @@ async function invokeAgentWithRetries(ctx, invokeTask) {
         console.log(`[invoke] ${command} ${displayArgs.join(" ")}${stdin ? ` (stdin: ${truncate(stdin, 100)})` : ""}`);
         const result = await spawnCommand(command, args, {
             cwd: getRunDir(ctx.taskDir, ctx.runId),
-            env: { ...ctx.guiEnv, ...agentEnv, PALMIER_TASK_ID: ctx.task.frontmatter.id, PALMIER_RUN_DIR: getRunDir(ctx.taskDir, ctx.runId), PALMIER_HTTP_PORT: String(ctx.config.httpPort ?? 9966) },
+            env: { ...ctx.guiEnv, ...agentEnv, PALMIER_RUN_DIR: getRunDir(ctx.taskDir, ctx.runId), PALMIER_HTTP_PORT: String(ctx.config.httpPort ?? 9966) },
             echoStdout: true,
             resolveOnFailure: true,
             stdin,
@@ -261,7 +261,7 @@ async function runCommandTriggeredMode(ctx) {
     await publishHostEvent(ctx.nc, ctx.config.hostId, ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
     const child = spawnStreamingCommand(commandStr, {
         cwd: getRunDir(ctx.taskDir, ctx.runId),
-        env: { ...ctx.guiEnv, PALMIER_TASK_ID: ctx.task.frontmatter.id, PALMIER_RUN_DIR: getRunDir(ctx.taskDir, ctx.runId), PALMIER_HTTP_PORT: String(ctx.config.httpPort ?? 9966) },
+        env: { ...ctx.guiEnv, PALMIER_RUN_DIR: getRunDir(ctx.taskDir, ctx.runId), PALMIER_HTTP_PORT: String(ctx.config.httpPort ?? 9966) },
     });
     let linesProcessed = 0;
     let invocationsSucceeded = 0;
@@ -424,7 +424,7 @@ async function requestConfirmation(config, task, taskDir) {
     const res = await fetch(`http://localhost:${port}/request-confirmation`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ taskId: task.frontmatter.id, taskName: task.frontmatter.name }),
+        body: JSON.stringify({ taskId: task.frontmatter.id, description: `Run task "${task.frontmatter.name || task.frontmatter.id}"?` }),
     });
     const body = await res.json();
     if (typeof body.confirmed !== "boolean") {

package/dist/location-device.d.ts

@@ -0,0 +1,8 @@
+export interface LocationDevice {
+    clientToken: string;
+    fcmToken: string;
+}
+export declare function getLocationDevice(): LocationDevice | null;
+export declare function setLocationDevice(clientToken: string, fcmToken: string): void;
+export declare function clearLocationDevice(): void;
+//# sourceMappingURL=location-device.d.ts.map

package/dist/location-device.js

@@ -0,0 +1,32 @@
+import * as fs from "fs";
+import * as path from "path";
+import { CONFIG_DIR } from "./config.js";
+const LOCATION_FILE = path.join(CONFIG_DIR, "location-device.json");
+export function getLocationDevice() {
+    try {
+        if (!fs.existsSync(LOCATION_FILE))
+            return null;
+        const raw = fs.readFileSync(LOCATION_FILE, "utf-8");
+        const data = JSON.parse(raw);
+        if (!data.clientToken || !data.fcmToken)
+            return null;
+        return data;
+    }
+    catch {
+        return null;
+    }
+}
+export function setLocationDevice(clientToken, fcmToken) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs.writeFileSync(LOCATION_FILE, JSON.stringify({ clientToken, fcmToken }, null, 2), "utf-8");
+}
+export function clearLocationDevice() {
+    try {
+        if (fs.existsSync(LOCATION_FILE))
+            fs.unlinkSync(LOCATION_FILE);
+    }
+    catch {
+        // ignore
+    }
+}
+//# sourceMappingURL=location-device.js.map

package/dist/mcp-handler.d.ts

@@ -0,0 +1,8 @@
+import { type ToolContext } from "./mcp-tools.js";
+export interface McpResponse {
+    body: object;
+    sessionId?: string;
+}
+export declare function getAgentName(sessionId: string): string | undefined;
+export declare function handleMcpRequest(body: string, sessionId: string | undefined, ctx: ToolContext): Promise<McpResponse>;
+//# sourceMappingURL=mcp-handler.d.ts.map

package/dist/mcp-handler.js

@@ -0,0 +1,110 @@
+import { randomUUID } from "crypto";
+import { agentTools, agentToolMap, ToolError } from "./mcp-tools.js";
+// Session-to-agent name map with 24h TTL
+const SESSION_TTL_MS = 24 * 60 * 60 * 1000;
+const sessionAgents = new Map();
+export function getAgentName(sessionId) {
+    const entry = sessionAgents.get(sessionId);
+    if (!entry)
+        return undefined;
+    if (Date.now() > entry.expiresAt) {
+        sessionAgents.delete(sessionId);
+        return undefined;
+    }
+    return entry.agentName;
+}
+function pruneExpiredSessions() {
+    const now = Date.now();
+    for (const [id, entry] of sessionAgents) {
+        if (now > entry.expiresAt)
+            sessionAgents.delete(id);
+    }
+}
+function rpcError(id, code, message) {
+    return { jsonrpc: "2.0", id, error: { code, message } };
+}
+function rpcResult(id, result) {
+    return { jsonrpc: "2.0", id, result };
+}
+export async function handleMcpRequest(body, sessionId, ctx) {
+    let req;
+    try {
+        req = JSON.parse(body);
+    }
+    catch {
+        return { body: rpcError(null, -32700, "Parse error") };
+    }
+    const id = req.id ?? null;
+    if (req.jsonrpc !== "2.0") {
+        return { body: rpcError(id, -32600, "Invalid Request: missing jsonrpc 2.0") };
+    }
+    const agent = sessionId ? getAgentName(sessionId) : undefined;
+    const sid = sessionId?.slice(0, 8) ?? "none";
+    const logPrefix = agent ? `[mcp] [${sid}] [${agent}]` : `[mcp] [${sid}]`;
+    console.log(`${logPrefix} ${req.method}${req.method === "tools/call" ? ` → ${req.params?.name}` : ""}`);
+    switch (req.method) {
+        case "initialize": {
+            const newSessionId = randomUUID();
+            const clientInfo = req.params?.clientInfo;
+            const agentName = clientInfo
+                ? `${clientInfo.name || "unknown"}${clientInfo.version ? ` ${clientInfo.version}` : ""}`
+                : undefined;
+            if (agentName) {
+                sessionAgents.set(newSessionId, { agentName, expiresAt: Date.now() + SESSION_TTL_MS });
+                pruneExpiredSessions();
+            }
+            console.log(`[mcp] [${newSessionId.slice(0, 8)}] Session initialized${agentName ? ` (${agentName})` : ""}`);
+            return {
+                body: rpcResult(id, {
+                    protocolVersion: "2025-03-26",
+                    capabilities: { tools: {} },
+                    serverInfo: { name: "palmier", version: "1.0.0" },
+                }),
+                sessionId: newSessionId,
+            };
+        }
+        case "tools/list": {
+            return {
+                body: rpcResult(id, {
+                    tools: agentTools.map((t) => ({
+                        name: t.name,
+                        description: t.description,
+                        inputSchema: t.inputSchema,
+                    })),
+                }),
+            };
+        }
+        case "tools/call": {
+            const name = req.params?.name;
+            const args = (req.params?.arguments ?? {});
+            if (!name)
+                return { body: rpcError(id, -32602, "Missing params.name") };
+            const tool = agentToolMap.get(name);
+            if (!tool)
+                return { body: rpcError(id, -32602, `Unknown tool: ${name}`) };
+            try {
+                const result = await tool.handler(args, ctx);
+                console.log(`${logPrefix} tools/call ${name} done:`, JSON.stringify(result).slice(0, 200));
+                return {
+                    body: rpcResult(id, {
+                        content: [{ type: "text", text: JSON.stringify(result) }],
+                    }),
+                };
+            }
+            catch (err) {
+                const message = err instanceof ToolError ? err.message : String(err);
+                console.error(`${logPrefix} tools/call ${name} error:`, message);
+                return {
+                    body: rpcResult(id, {
+                        content: [{ type: "text", text: JSON.stringify({ error: message }) }],
+                        isError: true,
+                    }),
+                };
+            }
+        }
+        default:
+            console.warn(`${logPrefix} Unknown method: ${req.method}`);
+            return { body: rpcError(id, -32601, `Method not found: ${req.method}`) };
+    }
+}
+//# sourceMappingURL=mcp-handler.js.map

package/dist/mcp-tools.d.ts

@@ -0,0 +1,22 @@
+import { type NatsConnection } from "nats";
+import type { HostConfig } from "./types.js";
+export declare class ToolError extends Error {
+    statusCode: number;
+    constructor(message: string, statusCode?: number);
+}
+export interface ToolContext {
+    config: HostConfig;
+    nc: NatsConnection | undefined;
+    publishEvent: (id: string, payload: Record<string, unknown>) => Promise<void>;
+    sessionId: string;
+    agentName?: string;
+}
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: object;
+    handler: (args: Record<string, unknown>, ctx: ToolContext) => Promise<unknown>;
+}
+export declare const agentTools: ToolDefinition[];
+export declare const agentToolMap: Map<string, ToolDefinition>;
+//# sourceMappingURL=mcp-tools.d.ts.map

package/dist/mcp-tools.js

@@ -0,0 +1,152 @@
+import { StringCodec } from "nats";
+import { registerPending } from "./pending-requests.js";
+import { getLocationDevice } from "./location-device.js";
+export class ToolError extends Error {
+    statusCode;
+    constructor(message, statusCode = 500) {
+        super(message);
+        this.statusCode = statusCode;
+    }
+}
+const notifyTool = {
+    name: "notify",
+    description: "Send a push notification to the user's device.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            title: { type: "string", description: "Notification title" },
+            body: { type: "string", description: "Notification body" },
+        },
+        required: ["title", "body"],
+    },
+    async handler(args, ctx) {
+        const { title, body } = args;
+        if (!title || !body)
+            throw new ToolError("title and body are required", 400);
+        if (!ctx.nc)
+            throw new ToolError("NATS not connected — push notifications require server mode", 503);
+        const sc = StringCodec();
+        const payload = { hostId: ctx.config.hostId, title, body };
+        if (ctx.sessionId)
+            payload.session_id = ctx.sessionId;
+        if (ctx.agentName)
+            payload.agent_name = ctx.agentName;
+        const subject = `host.${ctx.config.hostId}.push.send`;
+        const reply = await ctx.nc.request(subject, sc.encode(JSON.stringify(payload)), { timeout: 15_000 });
+        const result = JSON.parse(sc.decode(reply.data));
+        if (result.ok)
+            return { ok: true };
+        throw new ToolError(result.error ?? "Push notification failed", 502);
+    },
+};
+const requestInputTool = {
+    name: "request-input",
+    description: "Request input from the user. The request blocks until the user responds.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            description: { type: "string", description: "Context or heading for the input request" },
+            questions: {
+                type: "array",
+                items: { type: "string" },
+                description: "Questions to present to the user",
+                minItems: 1,
+            },
+        },
+        required: ["questions"],
+    },
+    async handler(args, ctx) {
+        const { description, questions } = args;
+        if (!questions?.length)
+            throw new ToolError("questions is required", 400);
+        const pendingPromise = registerPending(ctx.sessionId, "input", questions);
+        await ctx.publishEvent("_input", {
+            event_type: "input-request",
+            host_id: ctx.config.hostId,
+            session_id: ctx.sessionId,
+            agent_name: ctx.agentName,
+            description,
+            input_questions: questions,
+        });
+        const response = await pendingPromise;
+        if (response.length === 1 && response[0] === "aborted") {
+            await ctx.publishEvent("_input", { event_type: "input-resolved", host_id: ctx.config.hostId, session_id: ctx.sessionId, status: "aborted" });
+            return { aborted: true };
+        }
+        await ctx.publishEvent("_input", { event_type: "input-resolved", host_id: ctx.config.hostId, session_id: ctx.sessionId, status: "provided" });
+        return { values: response };
+    },
+};
+const requestConfirmationTool = {
+    name: "request-confirmation",
+    description: "Request confirmation from the user. The request blocks until the user confirms or aborts.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            description: { type: "string", description: "What the user is confirming" },
+        },
+        required: ["description"],
+    },
+    async handler(args, ctx) {
+        const { description } = args;
+        if (!description)
+            throw new ToolError("description is required", 400);
+        const pendingPromise = registerPending(ctx.sessionId, "confirmation");
+        await ctx.publishEvent("_confirm", {
+            event_type: "confirm-request",
+            host_id: ctx.config.hostId,
+            session_id: ctx.sessionId,
+            agent_name: ctx.agentName,
+            description,
+        });
+        const response = await pendingPromise;
+        const confirmed = response[0] === "confirmed";
+        await ctx.publishEvent("_confirm", {
+            event_type: "confirm-resolved",
+            host_id: ctx.config.hostId,
+            session_id: ctx.sessionId,
+            status: confirmed ? "confirmed" : "aborted",
+        });
+        return { confirmed };
+    },
+};
+const deviceGeolocationTool = {
+    name: "device-geolocation",
+    description: "Get the GPS location of the user's mobile device. Blocks until the device responds (up to 30 seconds).",
+    inputSchema: {
+        type: "object",
+        properties: {},
+    },
+    async handler(_args, ctx) {
+        if (!ctx.nc)
+            throw new ToolError("Not connected to server (NATS unavailable)", 503);
+        const locDevice = getLocationDevice();
+        if (!locDevice)
+            throw new ToolError("No device has location access enabled", 400);
+        const sc = StringCodec();
+        const ackReply = await ctx.nc.request(`host.${ctx.config.hostId}.fcm.geolocation`, sc.encode(JSON.stringify({ hostId: ctx.config.hostId, requestId: ctx.sessionId, fcmToken: locDevice.fcmToken })), { timeout: 5_000 });
+        const ack = JSON.parse(sc.decode(ackReply.data));
+        if (ack.error)
+            throw new ToolError(ack.error, 502);
+        const locationPromise = new Promise((resolve, reject) => {
+            const sub = ctx.nc.subscribe(`host.${ctx.config.hostId}.geolocation.${ctx.sessionId}`, { max: 1 });
+            const timer = setTimeout(() => {
+                sub.unsubscribe();
+                reject(new ToolError("Device did not respond within 30 seconds", 504));
+            }, 30_000);
+            (async () => {
+                for await (const msg of sub) {
+                    clearTimeout(timer);
+                    resolve(sc.decode(msg.data));
+                }
+            })();
+        });
+        const locationData = JSON.parse(await locationPromise);
+        if (locationData.error)
+            return { error: locationData.error };
+        return locationData;
+    },
+};
+export const agentTools = [notifyTool, requestInputTool, requestConfirmationTool, deviceGeolocationTool];
+export const agentToolMap = new Map(agentTools.map((t) => [t.name, t]));
+//# sourceMappingURL=mcp-tools.js.map