palmier 0.8.0 → 0.8.3

package/src/rpc-handler.ts

@@ -12,14 +12,12 @@ import { getAgent } from "./agents/agent.js";
 import { validateClient } from "./client-store.js";
 import { publishHostEvent } from "./events.js";
 import { getCapabilityDevice, setCapabilityDevice, clearCapabilityDevice, type DeviceCapability } from "./device-capabilities.js";
+import { listApps } from "./app-registry.js";
 import { currentVersion, performUpdate } from "./update-checker.js";
 import { parseReportFiles, parseTaskOutcome, stripPalmierMarkers } from "./commands/run.js";
 import { clearTaskQueue } from "./event-queues.js";
 import type { HostConfig, ParsedTask, RpcMessage, ConversationMessage } from "./types.js";
 
-/**
- * Parse RESULT frontmatter and conversation messages.
- */
 export function parseResultFrontmatter(raw: string): Record<string, unknown> {
   const fmMatch = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
   if (!fmMatch) return { messages: [] };
@@ -33,19 +31,16 @@ export function parseResultFrontmatter(raw: string): Record<string, unknown> {
 
   const messages = parseConversationMessages(fmMatch[2]);
 
-  // Derive state from status messages — just look at the last one
   const statusMessages = messages.filter((m: ConversationMessage) => m.role === "status");
   const lastStatus = statusMessages[statusMessages.length - 1];
   const startedMsg = statusMessages.find((m: ConversationMessage) => m.type === "started");
   const terminalStates = ["finished", "failed", "aborted"];
   const terminalMsg = [...statusMessages].reverse().find((m: ConversationMessage) => terminalStates.includes(m.type ?? ""));
 
-  // If last status is "started" (or continuation like "confirmation"/"monitoring"),
-  // determine if it's a task run or follow-up
   const activeStates = ["started", "monitoring", "confirmation"];
   let runningState: string | undefined;
   if (lastStatus?.type === "monitoring") {
-    // Only show monitoring if no assistant/user message came after it
+    // Show "monitoring" only if no assistant/user message followed it.
     const lastStatusIdx = messages.lastIndexOf(lastStatus);
     const hasMessageAfter = messages.slice(lastStatusIdx + 1).some((m: ConversationMessage) => m.role === "assistant" || m.role === "user");
     runningState = hasMessageAfter ? "started" : "monitoring";
@@ -65,16 +60,13 @@ export function parseResultFrontmatter(raw: string): Record<string, unknown> {
   };
 }
 
-/**
- * Parse conversation messages from the body of a RESULT file.
- */
 function parseConversationMessages(body: string): ConversationMessage[] {
   const delimiterRegex = /<!-- palmier:message\s+(.*?)\s*-->/g;
   const messages: ConversationMessage[] = [];
   const matches = [...body.matchAll(delimiterRegex)];
 
   if (matches.length === 0) {
-    // No delimiters — treat entire body as single assistant message if non-empty
+    // No delimiters — treat entire body as a single assistant message.
     const content = body.trim();
     if (content) {
       messages.push({ role: "assistant", time: 0, content });
@@ -106,10 +98,6 @@ function parseAttr(attrs: string, name: string): string | undefined {
   return match ? match[1] : undefined;
 }
 
-/**
- * Generate a concise task name from a user prompt using the given agent.
- * Falls back to the raw prompt on failure.
- */
 async function generateName(
   projectRoot: string,
   userPrompt: string,
@@ -136,9 +124,6 @@ async function generateName(
 /** Active follow-up child processes, keyed by "taskId:runId". */
 const activeFollowups = new Map<string, ChildProcess>();
 
-/**
- * Create a transport-agnostic RPC handler bound to the given config.
- */
 export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
   function flattenTask(task: ParsedTask) {
     const taskDir = getTaskDir(config.projectRoot, task.frontmatter.id);
@@ -150,8 +135,8 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
   }
 
   async function handleRpc(request: RpcMessage): Promise<unknown> {
-    // Client token validation: skip for trusted localhost requests and
-    // task.user_input (server-originated push responses; gated by getPending instead)
+    // task.user_input comes from server-originated push responses; it's gated
+    // by getPending() rather than a client token.
     const skipAuth = request.method === "task.user_input";
     if (!skipAuth && !request.localhost && (!request.clientToken || !validateClient(request.clientToken))) {
       return { error: "Unauthorized" };
@@ -159,12 +144,9 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
 
     switch (request.method) {
       case "host.info": {
-        // Bootstrap metadata the PWA needs on connect, independent of which tab
-        // is active. Includes any prompts already waiting so a reconnecting
-        // PWA can render their modals without replaying events.
         const capabilities: Record<string, string | null> = {};
-        for (const cap of ["location", "notifications", "sms", "contacts", "calendar", "alert", "battery", "dnd", "email"] as const) {
-          capabilities[cap] = getCapabilityDevice(cap)?.clientToken ?? null;
+        for (const capability of ["location", "notifications", "sms-read", "sms-send", "contacts", "calendar", "alarm", "battery", "dnd", "send-email"] as const) {
+          capabilities[capability] = getCapabilityDevice(capability)?.clientToken ?? null;
         }
         return {
           agents: config.agents ?? [],
@@ -250,11 +232,9 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
         const taskDir = getTaskDir(config.projectRoot, params.id);
         const existing = parseTaskFile(taskDir);
 
-        // Detect whether name needs regeneration
         const promptChanged = params.user_prompt !== undefined && params.user_prompt !== existing.frontmatter.user_prompt;
         const agentChanged = params.agent !== undefined && params.agent !== existing.frontmatter.agent;
 
-        // Merge updates
         if (params.user_prompt !== undefined) existing.frontmatter.user_prompt = params.user_prompt;
         if (params.agent !== undefined) existing.frontmatter.agent = params.agent;
         if (params.schedule_type !== undefined) {
@@ -287,7 +267,6 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
           }
         }
 
-        // Regenerate name when prompt or agent changes
         if (promptChanged || agentChanged) {
           existing.frontmatter.name = existing.frontmatter.user_prompt.length <= 50
             ? existing.frontmatter.user_prompt
@@ -296,8 +275,8 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
 
         writeTaskFile(taskDir, existing);
 
-        // Update timers — installTaskTimer overwrites in-place (schtasks /f,
-        // systemd unit rewrite) without killing a running task process.
+        // installTaskTimer overwrites in-place (schtasks /f, systemd unit rewrite)
+        // without killing a running task process.
         getPlatform().installTaskTimer(config, existing);
 
         return flattenTask(existing);
@@ -341,13 +320,11 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
         };
 
         writeTaskFile(taskDir, task);
-        // Do NOT append to tasks.jsonl — this is a one-off run
+        // One-off run: do NOT append to tasks.jsonl.
 
-        // Create initial result file so it appears in runs list immediately
         const runId = createRunDir(taskDir, name, Date.now(), params.agent);
         appendHistory(config.projectRoot, { task_id: id, run_id: runId });
 
-        // Spawn `palmier run <id>` directly as a detached process
         const script = process.argv[1] || "palmier";
         const child = spawn(process.execPath, [script, "run", id], {
           detached: true,
@@ -365,13 +342,11 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
           const runTaskDir = getTaskDir(config.projectRoot, params.id);
           const platform = getPlatform();
 
-          // If the task is already running, kill the stale process and start fresh
           if (platform.isTaskRunning(params.id)) {
             console.log(`[task.run] Task ${params.id} is already running, killing stale process`);
             await platform.stopTask(params.id);
           }
 
-          // Create initial result file so it appears in runs list immediately
           const runTask = parseTaskFile(runTaskDir);
           const taskRunId = createRunDir(runTaskDir, runTask.frontmatter.name, Date.now(), runTask.frontmatter.agent);
           appendHistory(config.projectRoot, { task_id: params.id, run_id: taskRunId });
@@ -399,7 +374,6 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
         const followupTask = parseTaskFile(followupTaskDir);
         const followupRunDir = getRunDir(followupTaskDir, params.run_id);
 
-        // Append user message + started status
         appendRunMessage(followupTaskDir, params.run_id, {
           role: "user",
           time: Date.now(),
@@ -413,13 +387,11 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
         });
         await publishHostEvent(nc, config.hostId, params.id, { event_type: "result-updated", run_id: params.run_id });
 
-        // Fire-and-forget: invoke agent inline as a child of the serve process
         const followupAgent = getAgent(followupTask.frontmatter.agent);
         const { command: cmd, args: cmdArgs, stdin, env: followupAgentEnv } = followupAgent.getTaskRunCommandLine(
           followupTask, params.message, followupTask.frontmatter.yolo_mode ? "yolo" : followupTask.frontmatter.permissions,
         );
 
-        // Spawn directly via crossSpawn so we can track and kill the child
         const child = crossSpawn(cmd, cmdArgs, {
           cwd: followupRunDir,
           stdio: [stdin != null ? "pipe" : "ignore", "pipe", "pipe"],
@@ -429,14 +401,13 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
         if (stdin != null) child.stdin!.end(stdin);
         activeFollowups.set(followupKey, child);
 
-        // Collect output
         const chunks: Buffer[] = [];
         child.stdout?.on("data", (d: Buffer) => chunks.push(d));
         child.stderr?.on("data", (d: Buffer) => process.stderr.write(d));
 
         child.on("close", async (code: number | null) => {
           activeFollowups.delete(followupKey);
-          // If killed by stop_followup, the stopped status is already written
+          // stop_followup already wrote the stopped status.
           if (child.killed) return;
 
           const output = Buffer.concat(chunks).toString("utf-8");
@@ -484,7 +455,6 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
           return { error: "No active follow-up for this run" };
         }
 
-        // Kill the child process tree
         if (process.platform === "win32" && child.pid) {
           try {
             const { execFileSync } = await import("child_process");
@@ -494,7 +464,7 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
           child.kill();
         }
 
-        // Append stopped status (child.killed prevents the close handler from writing)
+        // child.killed stops the close handler from double-writing the status.
         const stopTaskDir = getTaskDir(config.projectRoot, params.id);
         appendRunMessage(stopTaskDir, params.run_id, {
           role: "status",
@@ -510,17 +480,16 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
       case "task.abort": {
         const params = request.params as { id: string };
         const abortTaskDir = getTaskDir(config.projectRoot, params.id);
-        // Read the PID before overwriting status — stopTask needs it to
-        // kill the entire process tree on Windows.
+        // Read PID before overwriting — stopTask needs it to kill the
+        // process tree on Windows.
         const abortPrevStatus = readTaskStatus(abortTaskDir);
-        // Write abort status BEFORE killing so the dying process's signal
-        // handler can detect this was RPC-initiated and skip publishing.
+        // Write abort status before killing so the dying process's signal
+        // handler sees this was RPC-initiated and skips publishing.
         writeTaskStatus(abortTaskDir, {
           running_state: "aborted",
           time_stamp: Date.now(),
           ...(abortPrevStatus?.pid ? { pid: abortPrevStatus.pid } : {}),
         });
-        // Append aborted status to the latest run
         try {
           const runDirs = fs.readdirSync(abortTaskDir)
             .filter((f) => /^\d+$/.test(f) && fs.existsSync(path.join(abortTaskDir, f, "TASKRUN.md")))
@@ -543,7 +512,6 @@ 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 if LAN server is running)
         const abortPayload: Record<string, unknown> = { event_type: "running-state", running_state: "aborted" };
         await publishHostEvent(nc, config.hostId, params.id, abortPayload);
         return { ok: true, task_id: params.id };
@@ -694,6 +662,10 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
         return { ok: true };
       }
 
+      case "device.notifications.apps": {
+        return { apps: listApps() };
+      }
+
       default:
         return { error: `Unknown method: ${request.method}` };
     }

package/src/spawn-command.ts

@@ -18,19 +18,12 @@ export interface SpawnStreamingOptions {
 }
 
 /**
- * Spawn a command with shell interpretation, returning the ChildProcess
- * with stdout piped for line-by-line reading.
- *
- * Unlike spawnCommand(), this does NOT collect output into a buffer —
- * the caller reads from child.stdout directly (e.g. via readline).
- *
- * shell: true is required so users can write piped commands like
- * "tail -f log | grep ERROR".
- *
- * stdin is "pipe" (kept open, never written to) rather than "ignore"
- * (/dev/null). Some long-running commands exit when stdin is closed/EOF.
- * This differs from spawnCommand() which uses "ignore" because agent
- * CLIs like `claude -p` hang on an open stdin pipe.
+ * Spawn with shell interpretation for piped commands like "tail -f log | grep".
+ * Returns the ChildProcess with stdout piped so the caller can read it directly
+ * (contrast with spawnCommand which buffers). stdin is "pipe" (held open, not
+ * written to): some long-running commands exit on stdin EOF. Agent CLIs like
+ * `claude -p` conversely hang on an open stdin, which is why spawnCommand
+ * defaults to "ignore".
  */
 export function spawnStreamingCommand(
   command: string,
@@ -60,18 +53,10 @@ export interface SpawnCommandOptions {
 }
 
 /**
- * Spawn a command with additional arguments.
- *
- * Uses cross-spawn to correctly resolve .cmd shims and escape arguments
- * on Windows without shell: true (which mishandles special characters).
- *
- * On other platforms the command is executed directly (no shell), so no
- * escaping is needed.
- *
- * stdin is set to "ignore" by default (equivalent to < /dev/null) because
- * tools like `claude -p` hang indefinitely on an open stdin pipe.
- * When opts.stdin is provided, stdin is set to "pipe" and the string is
- * written to the process before closing the pipe.
+ * cross-spawn resolves .cmd shims and escapes args on Windows without shell:true
+ * (which mishandles special characters). stdin defaults to "ignore" because
+ * tools like `claude -p` hang on an open stdin pipe; pass opts.stdin to write
+ * a string and then close the pipe.
  */
 export interface SpawnCommandResult {
   output: string;
@@ -84,8 +69,7 @@ export function spawnCommand(
   opts: SpawnCommandOptions,
 ): Promise<SpawnCommandResult> {
   return new Promise<SpawnCommandResult>((resolve, reject) => {
-    // Collapse newlines to spaces — cmd.exe can't handle literal newlines
-    // in arguments, and CLI prompts don't need them.
+    // cmd.exe can't handle literal newlines in arguments.
     const finalArgs = process.platform === "win32"
       ? args.map((a) => a.replace(/[\r\n]+/g, " "))
       : args;

package/src/task.ts

@@ -3,9 +3,6 @@ import * as path from "path";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 import type { ParsedTask, TaskFrontmatter, TaskStatus, HistoryEntry, ConversationMessage } from "./types.js";
 
-/**
- * Parse a TASK.md file from the given task directory.
- */
 export function parseTaskFile(taskDir: string): ParsedTask {
   const filePath = path.join(taskDir, "TASK.md");
 
@@ -17,9 +14,6 @@ export function parseTaskFile(taskDir: string): ParsedTask {
   return parseTaskContent(content);
 }
 
-/**
- * Parse TASK.md content string into frontmatter + body.
- */
 export function parseTaskContent(content: string): ParsedTask {
   const fmRegex = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
   const match = content.match(fmRegex);
@@ -41,10 +35,6 @@ export function parseTaskContent(content: string): ParsedTask {
   return { frontmatter };
 }
 
-/**
- * Write a TASK.md file to the given task directory.
- * Creates the directory if it doesn't exist.
- */
 export function writeTaskFile(taskDir: string, task: ParsedTask): void {
   fs.mkdirSync(taskDir, { recursive: true });
 
@@ -55,18 +45,11 @@ export function writeTaskFile(taskDir: string, task: ParsedTask): void {
   fs.writeFileSync(filePath, content, "utf-8");
 }
 
-/**
- * Append a task ID to the project-level tasks.jsonl file.
- */
 export function appendTaskList(projectRoot: string, taskId: string): void {
   const listPath = path.join(projectRoot, "tasks.jsonl");
   fs.appendFileSync(listPath, JSON.stringify({ task_id: taskId }) + "\n", "utf-8");
 }
 
-/**
- * Remove a task ID from the project-level tasks.jsonl file.
- * Returns true if the entry was found and removed.
- */
 export function removeFromTaskList(projectRoot: string, taskId: string): boolean {
   const listPath = path.join(projectRoot, "tasks.jsonl");
   if (!fs.existsSync(listPath)) return false;
@@ -91,9 +74,6 @@ export function removeFromTaskList(projectRoot: string, taskId: string): boolean
   return true;
 }
 
-/**
- * List all tasks referenced in tasks.jsonl.
- */
 export function listTasks(projectRoot: string): ParsedTask[] {
   const listPath = path.join(projectRoot, "tasks.jsonl");
   if (!fs.existsSync(listPath)) return [];
@@ -118,25 +98,15 @@ export function listTasks(projectRoot: string): ParsedTask[] {
   return tasks.reverse();
 }
 
-/**
- * Get the directory path for a task by its ID.
- */
 export function getTaskDir(projectRoot: string, taskId: string): string {
   return path.join(projectRoot, "tasks", taskId);
 }
 
-/**
- * Write task status to status.json in the task directory.
- */
 export function writeTaskStatus(taskDir: string, status: TaskStatus): void {
   const filePath = path.join(taskDir, "status.json");
   fs.writeFileSync(filePath, JSON.stringify(status), "utf-8");
 }
 
-/**
- * Read task status from status.json in the task directory.
- * Returns undefined if the file doesn't exist.
- */
 export function readTaskStatus(taskDir: string): TaskStatus | undefined {
   const filePath = path.join(taskDir, "status.json");
   try {
@@ -146,10 +116,7 @@ export function readTaskStatus(taskDir: string): TaskStatus | undefined {
   }
 }
 
-/**
- * Create a run directory with an initial TASKRUN.md file.
- * Returns the run ID (timestamp string used as directory name).
- */
+/** Returns the run ID (timestamp string used as directory name). */
 export function createRunDir(
   taskDir: string,
   taskName: string,
@@ -165,16 +132,10 @@ export function createRunDir(
   return runId;
 }
 
-/**
- * Get the path to a run directory.
- */
 export function getRunDir(taskDir: string, runId: string): string {
   return path.join(taskDir, runId);
 }
 
-/**
- * Append a conversation message to a run's TASKRUN.md file.
- */
 export function appendRunMessage(
   taskDir: string,
   runId: string,
@@ -189,10 +150,6 @@ export function appendRunMessage(
   fs.appendFileSync(path.join(taskDir, runId, "TASKRUN.md"), entry, "utf-8");
 }
 
-/**
- * Begin a streaming assistant message — writes the delimiter only.
- * Returns a writer that appends content chunks and finalizes the message.
- */
 export function beginStreamingMessage(
   taskDir: string,
   runId: string,
@@ -217,7 +174,7 @@ export class StreamingMessageWriter {
     fs.appendFileSync(this.filePath, "\n\n", "utf-8");
     if (attachments?.length) {
       const raw = fs.readFileSync(this.filePath, "utf-8");
-      // Find the last assistant delimiter (may differ from the original if spliceUserMessage created a new one)
+      // spliceUserMessage may have created a newer assistant delimiter.
       const pattern = /<!-- palmier:message role="assistant" time="\d+" -->/g;
       let lastMatch: RegExpExecArray | null = null;
       let m;
@@ -233,12 +190,10 @@ export class StreamingMessageWriter {
 }
 
 /**
- * Splice a user message into a running assistant stream.
- * Ends the current assistant block, writes the user message,
- * then opens a new assistant block — all as direct file appends.
- * The existing StreamingMessageWriter keeps working because its
- * write() is just appendFileSync, so subsequent chunks land in
- * the new assistant block.
+ * Splice a user message into a running assistant stream: close the current
+ * assistant block, write the user message, open a new assistant block. Direct
+ * appends only, so an existing StreamingMessageWriter keeps working — its
+ * subsequent chunks land in the new block.
  */
 export function spliceUserMessage(
   taskDir: string,
@@ -248,22 +203,15 @@ export function spliceUserMessage(
   assistantAppend?: string,
 ): void {
   const filePath = path.join(taskDir, runId, "TASKRUN.md");
-  // 1. Optionally append to the current assistant block (e.g. the input questions)
   if (assistantAppend) {
     fs.appendFileSync(filePath, assistantAppend, "utf-8");
   }
-  // 2. End the current assistant block
   fs.appendFileSync(filePath, "\n\n", "utf-8");
-  // 3. Write the user message
   appendRunMessage(taskDir, runId, userMsg);
-  // 4. Open a new assistant block for subsequent agent output
   const delimiter = `<!-- palmier:message role="assistant" time="${Date.now()}" -->`;
   fs.appendFileSync(filePath, `${delimiter}\n\n`, "utf-8");
 }
 
-/**
- * Read conversation messages from a run's TASKRUN.md file.
- */
 export function readRunMessages(taskDir: string, runId: string): ConversationMessage[] {
   const raw = fs.readFileSync(path.join(taskDir, runId, "TASKRUN.md"), "utf-8");
   const fmMatch = raw.match(/^---\n[\s\S]*?\n---\n([\s\S]*)$/);
@@ -298,18 +246,11 @@ export function readRunMessages(taskDir: string, runId: string): ConversationMes
   return messages;
 }
 
-/**
- * Append a history entry to the project-level history.jsonl file.
- */
 export function appendHistory(projectRoot: string, entry: HistoryEntry): void {
   const historyPath = path.join(projectRoot, "history.jsonl");
   fs.appendFileSync(historyPath, JSON.stringify(entry) + "\n", "utf-8");
 }
 
-/**
- * Delete a history entry and its associated run directory.
- * Returns true if the entry was found and removed.
- */
 export function deleteHistoryEntry(
   projectRoot: string,
   taskId: string,
@@ -337,7 +278,6 @@ export function deleteHistoryEntry(
 
   fs.writeFileSync(historyPath, remaining.length > 0 ? remaining.join("\n") + "\n" : "", "utf-8");
 
-  // Delete the run directory
   const runDir = path.join(projectRoot, "tasks", taskId, runId);
   if (fs.existsSync(runDir)) {
     fs.rmSync(runDir, { recursive: true, force: true });
@@ -346,10 +286,7 @@ export function deleteHistoryEntry(
   return true;
 }
 
-/**
- * Read history entries from history.jsonl with pagination.
- * Returns entries sorted most-recent-first.
- */
+/** Returns entries most-recent-first. */
 export function readHistory(
   projectRoot: string,
   opts: { offset?: number; limit?: number; task_id?: string },