palmier 0.3.9 → 0.4.1

package/README.md

@@ -6,7 +6,7 @@
 
 **Website:** [palmier.me](https://www.palmier.me) | **App:** [app.palmier.me](https://app.palmier.me)
 
-A Node.js CLI that runs on your machine as a persistent daemon. It lets you create, schedule, and run AI agent tasks from your phone or browser, communicating via a cloud relay (NATS) and/or direct HTTP.
+A Node.js CLI that lets you run your own AI agents from your phone. It runs on your machine as a persistent daemon, letting you create, schedule, and monitor agent tasks from any device via a cloud relay (NATS) and/or direct HTTP.
 
 > **Important:** By using Palmier, you agree to the [Terms of Service](https://www.palmier.me/terms) and [Privacy Policy](https://www.palmier.me/privacy). See the [Disclaimer](#disclaimer) section below.
 

package/dist/agents/agent.js

@@ -15,7 +15,7 @@ const agentLabels = {
     gemini: "Gemini CLI",
     codex: "Codex CLI",
     openclaw: "OpenClaw",
-    copilot: "GitHub Copilot",
+    copilot: "Copilot CLI",
 };
 export async function detectAgents() {
     const detected = [];

package/dist/commands/mcpserver.js

@@ -4,6 +4,8 @@ import { z } from "zod";
 import { StringCodec } from "nats";
 import { loadConfig } from "../config.js";
 import { connectNats } from "../nats-client.js";
+import { getTaskDir, parseTaskFile } from "../task.js";
+import { requestUserInput, publishInputResolved } from "../user-input.js";
 export async function mcpserverCommand() {
     const config = loadConfig();
     const nc = await connectNats(config);
@@ -12,7 +14,7 @@ export async function mcpserverCommand() {
     // send-push-notification requires NATS — only register when server mode is enabled
     if (nc) {
         server.registerTool("send-push-notification", {
-            description: "Send a push notification to all paired devices via the Palmier platform",
+            description: "Send a push notification to the user",
             inputSchema: {
                 title: z.string().describe("Notification title"),
                 body: z.string().describe("Notification body text"),
@@ -49,6 +51,37 @@ export async function mcpserverCommand() {
             }
         });
     }
+    const taskId = process.env.PALMIER_TASK_ID;
+    if (taskId) {
+        const taskDir = getTaskDir(config.projectRoot, taskId);
+        const task = parseTaskFile(taskDir);
+        server.registerTool("request-user-input", {
+            description: "Request input from the user. The user will see the descriptions and can provide values or abort.",
+            inputSchema: {
+                descriptions: z.array(z.string()).describe("List of input descriptions to show the user"),
+            },
+        }, async (args) => {
+            try {
+                const response = await requestUserInput(nc, config, taskId, task.frontmatter.name, taskDir, args.descriptions);
+                await publishInputResolved(nc, config, taskId, response === "aborted" ? "aborted" : "provided");
+                if (response === "aborted") {
+                    return {
+                        content: [{ type: "text", text: "User aborted the input request." }],
+                    };
+                }
+                const lines = args.descriptions.map((desc, i) => `${desc}: ${response[i]}`).join("\n");
+                return {
+                    content: [{ type: "text", text: lines }],
+                };
+            }
+            catch (err) {
+                return {
+                    content: [{ type: "text", text: `Error requesting user input: ${err}` }],
+                    isError: true,
+                };
+            }
+        });
+    }
     const transport = new StdioServerTransport();
     await server.connect(transport);
     // Graceful shutdown

package/dist/commands/run.js

@@ -4,22 +4,24 @@ import * as readline from "readline";
 import { spawnCommand, spawnStreamingCommand } from "../spawn-command.js";
 import { loadConfig } from "../config.js";
 import { connectNats } from "../nats-client.js";
-import { parseTaskFile, getTaskDir, writeTaskFile, writeTaskStatus, readTaskStatus, appendHistory } from "../task.js";
+import { parseTaskFile, getTaskDir, writeTaskFile, writeTaskStatus, readTaskStatus, appendHistory, createResultFile } from "../task.js";
 import { getAgent } from "../agents/agent.js";
 import { getPlatform } from "../platform/index.js";
 import { TASK_SUCCESS_MARKER, TASK_FAILURE_MARKER, TASK_REPORT_PREFIX, TASK_PERMISSION_PREFIX, TASK_INPUT_PREFIX } from "../agents/shared-prompt.js";
 import { publishHostEvent } from "../events.js";
+import { waitForUserInput, requestUserInput, publishInputResolved } from "../user-input.js";
 /**
  * Write a time-stamped RESULT file with frontmatter.
  * Always generated, even for abort/fail.
  */
-function writeResult(taskDir, taskName, taskSnapshotName, runningState, startTime, endTime, output, reportFiles, requiredPermissions) {
-    const resultFileName = `RESULT-${endTime}.md`;
+/**
+ * Update an existing result file with the final outcome.
+ */
+function finalizeResultFile(taskDir, resultFileName, taskName, taskSnapshotName, runningState, startTime, endTime, output, reportFiles, requiredPermissions) {
     const reportLine = reportFiles.length > 0 ? `\nreport_files: ${reportFiles.join(", ")}` : "";
     const permLines = requiredPermissions.map((p) => `\nrequired_permission: ${p.name} | ${p.description}`).join("");
     const content = `---\ntask_name: ${taskName}\nrunning_state: ${runningState}\nstart_time: ${startTime}\nend_time: ${endTime}\ntask_file: ${taskSnapshotName}${reportLine}${permLines}\n---\n${output}`;
     fs.writeFileSync(path.join(taskDir, resultFileName), content, "utf-8");
-    return resultFileName;
 }
 /**
  * Invoke the agent CLI with a retry loop for permissions and user input.
@@ -66,7 +68,7 @@ async function invokeAgentWithRetry(ctx, invokeTask) {
         // Input retry
         const inputRequests = parseInputRequests(result.output);
         if (outcome === "failed" && inputRequests.length > 0) {
-            const response = await requestUserInput(ctx.nc, ctx.config, ctx.task, ctx.taskDir, inputRequests);
+            const response = await requestUserInput(ctx.nc, ctx.config, ctx.taskId, ctx.task.frontmatter.name, ctx.taskDir, inputRequests);
             await publishInputResolved(ctx.nc, ctx.config, ctx.taskId, response === "aborted" ? "aborted" : "provided");
             if (response === "aborted") {
                 return { output: result.output, outcome: "failed", reportFiles, requiredPermissions };
@@ -79,6 +81,18 @@ async function invokeAgentWithRetry(ctx, invokeTask) {
         return { output: result.output, outcome, reportFiles, requiredPermissions };
     }
 }
+/**
+ * Find an existing RESULT file with running_state=started (created by the RPC handler).
+ */
+function findStartedResultFile(taskDir) {
+    const files = fs.readdirSync(taskDir).filter((f) => f.startsWith("RESULT-") && f.endsWith(".md"));
+    for (const file of files) {
+        const content = fs.readFileSync(path.join(taskDir, file), "utf-8");
+        if (content.includes("running_state: started"))
+            return file;
+    }
+    return null;
+}
 /**
  * If the RPC handler already wrote "aborted" to status.json (e.g. via task.abort),
  * respect that instead of overwriting with the process's own outcome.
@@ -98,20 +112,28 @@ export async function runCommand(taskId) {
     const task = parseTaskFile(taskDir);
     console.log(`Running task: ${taskId}`);
     let nc;
-    const startTime = Date.now();
     const taskName = task.frontmatter.name;
+    // Check for an existing "started" result file (created by the RPC handler)
+    const existingResult = findStartedResultFile(taskDir);
+    const startTime = existingResult ? parseInt(existingResult.replace("RESULT-", "").replace(".md", ""), 10) : Date.now();
+    const resultFileName = existingResult ?? createResultFile(taskDir, taskName, startTime);
     // Snapshot the task file at run time
     const taskSnapshotName = `TASK-${startTime}.md`;
-    fs.copyFileSync(path.join(taskDir, "TASK.md"), path.join(taskDir, taskSnapshotName));
+    if (!fs.existsSync(path.join(taskDir, taskSnapshotName))) {
+        fs.copyFileSync(path.join(taskDir, "TASK.md"), path.join(taskDir, taskSnapshotName));
+    }
     const cleanup = async () => {
         if (nc && !nc.isClosed()) {
             await nc.drain();
         }
     };
+    if (!existingResult) {
+        appendHistory(config.projectRoot, { task_id: taskId, result_file: resultFileName });
+    }
     try {
         nc = await connectNats(config);
         // Mark as started immediately
-        await publishTaskEvent(nc, config, taskDir, taskId, "started", taskName);
+        await publishTaskEvent(nc, config, taskDir, taskId, "started", taskName, resultFileName);
         // If requires_confirmation, notify clients and wait
         if (task.frontmatter.requires_confirmation) {
             const confirmed = await requestConfirmation(nc, config, task, taskDir);
@@ -120,9 +142,8 @@ export async function runCommand(taskId) {
             if (!confirmed) {
                 console.log("Task aborted by user.");
                 const endTime = Date.now();
-                const resultFileName = writeResult(taskDir, taskName, taskSnapshotName, "aborted", startTime, endTime, "", [], []);
-                appendHistory(config.projectRoot, { task_id: taskId, result_file: resultFileName });
-                await publishTaskEvent(nc, config, taskDir, taskId, "aborted", taskName);
+                finalizeResultFile(taskDir, resultFileName, taskName, taskSnapshotName, "aborted", startTime, endTime, "", [], []);
+                await publishTaskEvent(nc, config, taskDir, taskId, "aborted", taskName, resultFileName);
                 await cleanup();
                 return;
             }
@@ -139,24 +160,23 @@ export async function runCommand(taskId) {
             // Command-triggered mode
             const result = await runCommandTriggeredMode(ctx);
             const outcome = resolveOutcome(taskDir, result.outcome);
-            const resultFileName = writeResult(taskDir, taskName, taskSnapshotName, outcome, startTime, result.endTime, result.output, [], []);
-            appendHistory(config.projectRoot, { task_id: taskId, result_file: resultFileName });
-            await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName);
+            finalizeResultFile(taskDir, resultFileName, taskName, taskSnapshotName, outcome, startTime, result.endTime, result.output, [], []);
+            await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName, resultFileName);
             console.log(`Task ${taskId} completed (command-triggered).`);
         }
         else {
             // Standard execution
             const result = await invokeAgentWithRetry(ctx, task);
             const outcome = resolveOutcome(taskDir, result.outcome);
-            const resultFileName = writeResult(taskDir, taskName, taskSnapshotName, outcome, startTime, Date.now(), result.output, result.reportFiles, result.requiredPermissions);
-            appendHistory(config.projectRoot, { task_id: taskId, result_file: resultFileName });
-            await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName);
+            finalizeResultFile(taskDir, resultFileName, taskName, taskSnapshotName, outcome, startTime, Date.now(), result.output, result.reportFiles, result.requiredPermissions);
+            await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName, resultFileName);
             if (result.reportFiles.length > 0) {
                 await publishHostEvent(nc, config.hostId, taskId, {
                     event_type: "report-generated",
                     name: taskName,
                     report_files: result.reportFiles,
                     running_state: outcome,
+                    result_file: resultFileName,
                 });
             }
             console.log(`Task ${taskId} completed.`);
@@ -167,9 +187,8 @@ export async function runCommand(taskId) {
         const endTime = Date.now();
         const outcome = resolveOutcome(taskDir, "failed");
         const errorMsg = err instanceof Error ? err.message : String(err);
-        const resultFileName = writeResult(taskDir, taskName, taskSnapshotName, outcome, startTime, endTime, errorMsg, [], []);
-        appendHistory(config.projectRoot, { task_id: taskId, result_file: resultFileName });
-        await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName);
+        finalizeResultFile(taskDir, resultFileName, taskName, taskSnapshotName, outcome, startTime, endTime, errorMsg, [], []);
+        await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName, resultFileName);
         process.exitCode = 1;
     }
     finally {
@@ -302,7 +321,7 @@ async function runCommandTriggeredMode(ctx) {
     ].join("\n");
     return { outcome: "finished", endTime, output: summary };
 }
-async function publishTaskEvent(nc, config, taskDir, taskId, eventType, taskName) {
+async function publishTaskEvent(nc, config, taskDir, taskId, eventType, taskName, resultFile) {
     writeTaskStatus(taskDir, {
         running_state: eventType,
         time_stamp: Date.now(),
@@ -310,6 +329,8 @@ async function publishTaskEvent(nc, config, taskDir, taskId, eventType, taskName
     const payload = { event_type: "running-state", running_state: eventType };
     if (taskName)
         payload.name = taskName;
+    if (resultFile)
+        payload.result_file = resultFile;
     await publishHostEvent(nc, config.hostId, taskId, payload);
 }
 /**
@@ -322,22 +343,6 @@ async function publishConfirmResolved(nc, config, taskId, status) {
         status,
     });
 }
-/**
- * Watch status.json until user_input is populated by an RPC call, then resolve.
- * All interactive request flows (confirmation, permission, user input) share this.
- */
-function waitForUserInput(taskDir) {
-    const statusPath = path.join(taskDir, "status.json");
-    return new Promise((resolve) => {
-        const watcher = fs.watch(statusPath, () => {
-            const status = readTaskStatus(taskDir);
-            if (!status || !status.user_input?.length)
-                return;
-            watcher.close();
-            resolve(status.user_input);
-        });
-    });
-}
 async function requestPermission(nc, config, task, taskDir, requiredPermissions) {
     const currentStatus = readTaskStatus(taskDir);
     writeTaskStatus(taskDir, { ...currentStatus, pending_permission: requiredPermissions });
@@ -362,30 +367,6 @@ async function publishPermissionResolved(nc, config, taskId, status) {
         status,
     });
 }
-async function requestUserInput(nc, config, task, taskDir, inputDescriptions) {
-    const currentStatus = readTaskStatus(taskDir);
-    writeTaskStatus(taskDir, { ...currentStatus, pending_input: inputDescriptions });
-    await publishHostEvent(nc, config.hostId, task.frontmatter.id, {
-        event_type: "input-request",
-        host_id: config.hostId,
-        input_descriptions: inputDescriptions,
-        name: task.frontmatter.name,
-    });
-    const userInput = await waitForUserInput(taskDir);
-    if (userInput.length === 1 && userInput[0] === "aborted") {
-        writeTaskStatus(taskDir, { running_state: "aborted", time_stamp: Date.now() });
-        return "aborted";
-    }
-    writeTaskStatus(taskDir, { running_state: "started", time_stamp: Date.now() });
-    return userInput;
-}
-async function publishInputResolved(nc, config, taskId, status) {
-    await publishHostEvent(nc, config.hostId, taskId, {
-        event_type: "input-resolved",
-        host_id: config.hostId,
-        status,
-    });
-}
 async function requestConfirmation(nc, config, task, taskDir) {
     const currentStatus = readTaskStatus(taskDir);
     writeTaskStatus(taskDir, { ...currentStatus, pending_confirmation: true });

package/dist/platform/windows.js

@@ -106,29 +106,38 @@ export class WindowsPlatform {
         console.log("\nHost initialization complete!");
     }
     async restartDaemon() {
-        // Kill the old daemon if we have its PID
-        if (fs.existsSync(DAEMON_PID_FILE)) {
-            const oldPid = fs.readFileSync(DAEMON_PID_FILE, "utf-8").trim();
+        const script = process.argv[1] || "palmier";
+        const oldPid = fs.existsSync(DAEMON_PID_FILE)
+            ? fs.readFileSync(DAEMON_PID_FILE, "utf-8").trim()
+            : null;
+        if (oldPid && oldPid === String(process.pid)) {
+            // We ARE the old daemon (auto-update) — spawn replacement then exit.
+            this.spawnDaemon(script);
+            process.exit(0);
+        }
+        // Kill old daemon first, then spawn new one.
+        if (oldPid) {
             try {
-                execFileSync("taskkill", ["/pid", oldPid, "/t", "/f"], { windowsHide: true });
+                execFileSync("taskkill", ["/pid", oldPid, "/f"], { windowsHide: true, stdio: "pipe" });
             }
             catch {
                 // Process may have already exited
             }
         }
-        const script = process.argv[1] || "palmier";
         this.spawnDaemon(script);
     }
     spawnDaemon(script) {
-        const child = nodeSpawn(process.execPath, [script, "serve"], {
+        // Write a VBS launcher that starts the daemon with no visible console window.
+        const vbs = `CreateObject("WScript.Shell").Run """${process.execPath}"" ""${script}"" serve", 0, False`;
+        fs.writeFileSync(DAEMON_VBS_FILE, vbs, "utf-8");
+        const wscript = `${process.env.SYSTEMROOT || "C:\\Windows"}\\System32\\wscript.exe`;
+        const child = nodeSpawn(wscript, [DAEMON_VBS_FILE], {
             detached: true,
             stdio: "ignore",
             windowsHide: true,
         });
-        if (child.pid) {
-            fs.writeFileSync(DAEMON_PID_FILE, String(child.pid), "utf-8");
-        }
         child.unref();
+        // PID file will be written by the serve command itself when it starts.
         console.log("Palmier daemon started.");
     }
     installTaskTimer(config, task) {

package/dist/rpc-handler.js

@@ -2,8 +2,9 @@ import { randomUUID } from "crypto";
 import * as fs from "fs";
 import * as path from "path";
 import { fileURLToPath } from "url";
+import { spawn } from "child_process";
 import { parse as parseYaml } from "yaml";
-import { listTasks, parseTaskFile, writeTaskFile, getTaskDir, readTaskStatus, writeTaskStatus, readHistory, deleteHistoryEntry, appendTaskList, removeFromTaskList } from "./task.js";
+import { listTasks, parseTaskFile, writeTaskFile, getTaskDir, readTaskStatus, writeTaskStatus, readHistory, deleteHistoryEntry, appendTaskList, removeFromTaskList, appendHistory, createResultFile } from "./task.js";
 import { getPlatform } from "./platform/index.js";
 import { spawnCommand } from "./spawn-command.js";
 import { getAgent } from "./agents/agent.js";
@@ -205,11 +206,49 @@ export function createRpcHandler(config, nc) {
                 removeFromTaskList(config.projectRoot, params.id);
                 return { ok: true, task_id: params.id };
             }
+            case "task.run_oneoff": {
+                const params = request.params;
+                const id = randomUUID();
+                const taskDir = getTaskDir(config.projectRoot, id);
+                const name = params.user_prompt.slice(0, 60);
+                const task = {
+                    frontmatter: {
+                        id,
+                        name,
+                        user_prompt: params.user_prompt,
+                        agent: params.agent,
+                        triggers: [],
+                        triggers_enabled: false,
+                        requires_confirmation: params.requires_confirmation ?? false,
+                        ...(params.command ? { command: params.command } : {}),
+                    },
+                    body: "",
+                };
+                writeTaskFile(taskDir, task);
+                // Do NOT append to tasks.jsonl — this is a one-off run
+                // Create initial result file so it appears in runs list immediately
+                const resultFileName = createResultFile(taskDir, name, Date.now());
+                appendHistory(config.projectRoot, { task_id: id, result_file: resultFileName });
+                // 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,
+                    stdio: "ignore",
+                    windowsHide: true,
+                });
+                child.unref();
+                return { ok: true, task_id: id, result_file: resultFileName };
+            }
             case "task.run": {
                 const params = request.params;
                 try {
+                    // Create initial result file so it appears in runs list immediately
+                    const runTaskDir = getTaskDir(config.projectRoot, params.id);
+                    const runTask = parseTaskFile(runTaskDir);
+                    const runResultFileName = createResultFile(runTaskDir, runTask.frontmatter.name, Date.now());
+                    appendHistory(config.projectRoot, { task_id: params.id, result_file: runResultFileName });
                     await getPlatform().startTask(params.id);
-                    return { ok: true, task_id: params.id };
+                    return { ok: true, task_id: params.id, result_file: runResultFileName };
                 }
                 catch (err) {
                     const e = err;

package/dist/task.d.ts

@@ -38,6 +38,12 @@ export declare function writeTaskStatus(taskDir: string, status: TaskStatus): vo
  * Returns undefined if the file doesn't exist.
  */
 export declare function readTaskStatus(taskDir: string): TaskStatus | undefined;
+/**
+ * Create the initial result file when a task starts running.
+ * Contains only start_time and running_state=started; no end_time or content yet.
+ * Returns the result file name.
+ */
+export declare function createResultFile(taskDir: string, taskName: string, startTime: number): string;
 /**
  * Append a history entry to the project-level history.jsonl file.
  */

package/dist/task.js

@@ -129,6 +129,18 @@ export function readTaskStatus(taskDir) {
         return undefined;
     }
 }
+/**
+ * Create the initial result file when a task starts running.
+ * Contains only start_time and running_state=started; no end_time or content yet.
+ * Returns the result file name.
+ */
+export function createResultFile(taskDir, taskName, startTime) {
+    const resultFileName = `RESULT-${startTime}.md`;
+    const taskSnapshotName = `TASK-${startTime}.md`;
+    const content = `---\ntask_name: ${taskName}\nrunning_state: started\nstart_time: ${startTime}\ntask_file: ${taskSnapshotName}\n---\n`;
+    fs.writeFileSync(path.join(taskDir, resultFileName), content, "utf-8");
+    return resultFileName;
+}
 /**
  * Append a history entry to the project-level history.jsonl file.
  */

package/dist/user-input.d.ts

@@ -0,0 +1,15 @@
+import type { HostConfig } from "./types.js";
+import type { NatsConnection } from "nats";
+/**
+ * Watch status.json until user_input is populated by an RPC call, then resolve.
+ */
+export declare function waitForUserInput(taskDir: string): Promise<string[]>;
+/**
+ * Send an input-request event and wait for the user's response.
+ */
+export declare function requestUserInput(nc: NatsConnection | undefined, config: HostConfig, taskId: string, taskName: string, taskDir: string, inputDescriptions: string[]): Promise<string[] | "aborted">;
+/**
+ * Notify clients that an input request has been resolved.
+ */
+export declare function publishInputResolved(nc: NatsConnection | undefined, config: HostConfig, taskId: string, status: "provided" | "aborted"): Promise<void>;
+//# sourceMappingURL=user-input.d.ts.map

package/dist/user-input.js

@@ -0,0 +1,50 @@
+import * as fs from "fs";
+import * as path from "path";
+import { readTaskStatus, writeTaskStatus } from "./task.js";
+import { publishHostEvent } from "./events.js";
+/**
+ * Watch status.json until user_input is populated by an RPC call, then resolve.
+ */
+export function waitForUserInput(taskDir) {
+    const statusPath = path.join(taskDir, "status.json");
+    return new Promise((resolve) => {
+        const watcher = fs.watch(statusPath, () => {
+            const status = readTaskStatus(taskDir);
+            if (!status || !status.user_input?.length)
+                return;
+            watcher.close();
+            resolve(status.user_input);
+        });
+    });
+}
+/**
+ * Send an input-request event and wait for the user's response.
+ */
+export async function requestUserInput(nc, config, taskId, taskName, taskDir, inputDescriptions) {
+    const currentStatus = readTaskStatus(taskDir);
+    writeTaskStatus(taskDir, { ...currentStatus, pending_input: inputDescriptions });
+    await publishHostEvent(nc, config.hostId, taskId, {
+        event_type: "input-request",
+        host_id: config.hostId,
+        input_descriptions: inputDescriptions,
+        name: taskName,
+    });
+    const userInput = await waitForUserInput(taskDir);
+    if (userInput.length === 1 && userInput[0] === "aborted") {
+        writeTaskStatus(taskDir, { running_state: "aborted", time_stamp: Date.now() });
+        return "aborted";
+    }
+    writeTaskStatus(taskDir, { running_state: "started", time_stamp: Date.now() });
+    return userInput;
+}
+/**
+ * Notify clients that an input request has been resolved.
+ */
+export async function publishInputResolved(nc, config, taskId, status) {
+    await publishHostEvent(nc, config.hostId, taskId, {
+        event_type: "input-resolved",
+        host_id: config.hostId,
+        status,
+    });
+}
+//# sourceMappingURL=user-input.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "palmier",
-  "version": "0.3.9",
+  "version": "0.4.1",
   "description": "Palmier host CLI - provisions, executes tasks, and serves NATS RPC",
   "license": "Apache-2.0",
   "author": "Hongxu Cai",

package/src/agents/agent.ts

@@ -43,7 +43,7 @@ const agentLabels: Record<string, string> = {
   gemini: "Gemini CLI",
   codex: "Codex CLI",
   openclaw: "OpenClaw",
-  copilot: "GitHub Copilot",
+  copilot: "Copilot CLI",
 };
 
 export interface DetectedAgent {

package/src/commands/mcpserver.ts

@@ -4,6 +4,8 @@ import { z } from "zod";
 import { StringCodec } from "nats";
 import { loadConfig } from "../config.js";
 import { connectNats } from "../nats-client.js";
+import { getTaskDir, parseTaskFile } from "../task.js";
+import { requestUserInput, publishInputResolved } from "../user-input.js";
 export async function mcpserverCommand(): Promise<void> {
   const config = loadConfig();
   const nc = await connectNats(config);
@@ -20,7 +22,7 @@ export async function mcpserverCommand(): Promise<void> {
     server.registerTool(
       "send-push-notification",
       {
-        description: "Send a push notification to all paired devices via the Palmier platform",
+        description: "Send a push notification to the user",
         inputSchema: {
           title: z.string().describe("Notification title"),
           body: z.string().describe("Notification body text"),
@@ -63,6 +65,44 @@ export async function mcpserverCommand(): Promise<void> {
     );
   }
 
+  const taskId = process.env.PALMIER_TASK_ID;
+  if (taskId) {
+    const taskDir = getTaskDir(config.projectRoot, taskId);
+    const task = parseTaskFile(taskDir);
+
+    server.registerTool(
+      "request-user-input",
+      {
+        description: "Request input from the user. The user will see the descriptions and can provide values or abort.",
+        inputSchema: {
+          descriptions: z.array(z.string()).describe("List of input descriptions to show the user"),
+        },
+      },
+      async (args) => {
+        try {
+          const response = await requestUserInput(nc, config, taskId, task.frontmatter.name, taskDir, args.descriptions);
+          await publishInputResolved(nc, config, taskId, response === "aborted" ? "aborted" : "provided");
+
+          if (response === "aborted") {
+            return {
+              content: [{ type: "text" as const, text: "User aborted the input request." }],
+            };
+          }
+
+          const lines = args.descriptions.map((desc: string, i: number) => `${desc}: ${response[i]}`).join("\n");
+          return {
+            content: [{ type: "text" as const, text: lines }],
+          };
+        } catch (err) {
+          return {
+            content: [{ type: "text" as const, text: `Error requesting user input: ${err}` }],
+            isError: true,
+          };
+        }
+      }
+    );
+  }
+
   const transport = new StdioServerTransport();
   await server.connect(transport);
 

package/src/commands/run.ts

@@ -4,12 +4,13 @@ import * as readline from "readline";
 import { spawnCommand, spawnStreamingCommand } from "../spawn-command.js";
 import { loadConfig } from "../config.js";
 import { connectNats } from "../nats-client.js";
-import { parseTaskFile, getTaskDir, writeTaskFile, writeTaskStatus, readTaskStatus, appendHistory } from "../task.js";
+import { parseTaskFile, getTaskDir, writeTaskFile, writeTaskStatus, readTaskStatus, appendHistory, createResultFile } from "../task.js";
 import { getAgent } from "../agents/agent.js";
 import { getPlatform } from "../platform/index.js";
 import { TASK_SUCCESS_MARKER, TASK_FAILURE_MARKER, TASK_REPORT_PREFIX, TASK_PERMISSION_PREFIX, TASK_INPUT_PREFIX } from "../agents/shared-prompt.js";
 import type { AgentTool } from "../agents/agent.js";
 import { publishHostEvent } from "../events.js";
+import { waitForUserInput, requestUserInput, publishInputResolved } from "../user-input.js";
 import type { HostConfig, ParsedTask, TaskRunningState, RequiredPermission } from "../types.js";
 import type { NatsConnection } from "nats";
 
@@ -17,8 +18,13 @@ import type { NatsConnection } from "nats";
  * Write a time-stamped RESULT file with frontmatter.
  * Always generated, even for abort/fail.
  */
-function writeResult(
+
+/**
+ * Update an existing result file with the final outcome.
+ */
+function finalizeResultFile(
   taskDir: string,
+  resultFileName: string,
   taskName: string,
   taskSnapshotName: string,
   runningState: string,
@@ -27,13 +33,11 @@ function writeResult(
   output: string,
   reportFiles: string[],
   requiredPermissions: RequiredPermission[],
-): string {
-  const resultFileName = `RESULT-${endTime}.md`;
+): void {
   const reportLine = reportFiles.length > 0 ? `\nreport_files: ${reportFiles.join(", ")}` : "";
   const permLines = requiredPermissions.map((p) => `\nrequired_permission: ${p.name} | ${p.description}`).join("");
   const content = `---\ntask_name: ${taskName}\nrunning_state: ${runningState}\nstart_time: ${startTime}\nend_time: ${endTime}\ntask_file: ${taskSnapshotName}${reportLine}${permLines}\n---\n${output}`;
   fs.writeFileSync(path.join(taskDir, resultFileName), content, "utf-8");
-  return resultFileName;
 }
 
 /**
@@ -115,7 +119,7 @@ async function invokeAgentWithRetry(
     // Input retry
     const inputRequests = parseInputRequests(result.output);
     if (outcome === "failed" && inputRequests.length > 0) {
-      const response = await requestUserInput(ctx.nc, ctx.config, ctx.task, ctx.taskDir, inputRequests);
+      const response = await requestUserInput(ctx.nc, ctx.config, ctx.taskId, ctx.task.frontmatter.name, ctx.taskDir, inputRequests);
       await publishInputResolved(ctx.nc, ctx.config, ctx.taskId, response === "aborted" ? "aborted" : "provided");
 
       if (response === "aborted") {
@@ -132,6 +136,18 @@ async function invokeAgentWithRetry(
   }
 }
 
+/**
+ * Find an existing RESULT file with running_state=started (created by the RPC handler).
+ */
+function findStartedResultFile(taskDir: string): string | null {
+  const files = fs.readdirSync(taskDir).filter((f) => f.startsWith("RESULT-") && f.endsWith(".md"));
+  for (const file of files) {
+    const content = fs.readFileSync(path.join(taskDir, file), "utf-8");
+    if (content.includes("running_state: started")) return file;
+  }
+  return null;
+}
+
 /**
  * If the RPC handler already wrote "aborted" to status.json (e.g. via task.abort),
  * respect that instead of overwriting with the process's own outcome.
@@ -152,12 +168,18 @@ export async function runCommand(taskId: string): Promise<void> {
   console.log(`Running task: ${taskId}`);
 
   let nc: NatsConnection | undefined;
-  const startTime = Date.now();
   const taskName = task.frontmatter.name;
 
+  // Check for an existing "started" result file (created by the RPC handler)
+  const existingResult = findStartedResultFile(taskDir);
+  const startTime = existingResult ? parseInt(existingResult.replace("RESULT-", "").replace(".md", ""), 10) : Date.now();
+  const resultFileName = existingResult ?? createResultFile(taskDir, taskName, startTime);
+
   // Snapshot the task file at run time
   const taskSnapshotName = `TASK-${startTime}.md`;
-  fs.copyFileSync(path.join(taskDir, "TASK.md"), path.join(taskDir, taskSnapshotName));
+  if (!fs.existsSync(path.join(taskDir, taskSnapshotName))) {
+    fs.copyFileSync(path.join(taskDir, "TASK.md"), path.join(taskDir, taskSnapshotName));
+  }
 
   const cleanup = async () => {
     if (nc && !nc.isClosed()) {
@@ -165,11 +187,15 @@ export async function runCommand(taskId: string): Promise<void> {
     }
   };
 
+  if (!existingResult) {
+    appendHistory(config.projectRoot, { task_id: taskId, result_file: resultFileName });
+  }
+
   try {
     nc = await connectNats(config);
 
     // Mark as started immediately
-    await publishTaskEvent(nc, config, taskDir, taskId, "started", taskName);
+    await publishTaskEvent(nc, config, taskDir, taskId, "started", taskName, resultFileName);
 
     // If requires_confirmation, notify clients and wait
     if (task.frontmatter.requires_confirmation) {
@@ -179,9 +205,8 @@ export async function runCommand(taskId: string): Promise<void> {
       if (!confirmed) {
         console.log("Task aborted by user.");
         const endTime = Date.now();
-        const resultFileName = writeResult(taskDir, taskName, taskSnapshotName, "aborted", startTime, endTime, "", [], []);
-        appendHistory(config.projectRoot, { task_id: taskId, result_file: resultFileName });
-        await publishTaskEvent(nc, config, taskDir, taskId, "aborted", taskName);
+        finalizeResultFile(taskDir, resultFileName, taskName, taskSnapshotName, "aborted", startTime, endTime, "", [], []);
+        await publishTaskEvent(nc, config, taskDir, taskId, "aborted", taskName, resultFileName);
         await cleanup();
         return;
       }
@@ -200,21 +225,16 @@ export async function runCommand(taskId: string): Promise<void> {
       // Command-triggered mode
       const result = await runCommandTriggeredMode(ctx);
       const outcome = resolveOutcome(taskDir, result.outcome);
-      const resultFileName = writeResult(
-        taskDir, taskName, taskSnapshotName, outcome,
-        startTime, result.endTime, result.output, [], [],
-      );
-      appendHistory(config.projectRoot, { task_id: taskId, result_file: resultFileName });
-      await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName);
+      finalizeResultFile(taskDir, resultFileName, taskName, taskSnapshotName, outcome, startTime, result.endTime, result.output, [], []);
+      await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName, resultFileName);
       console.log(`Task ${taskId} completed (command-triggered).`);
     } else {
       // Standard execution
       const result = await invokeAgentWithRetry(ctx, task);
       const outcome = resolveOutcome(taskDir, result.outcome);
 
-      const resultFileName = writeResult(taskDir, taskName, taskSnapshotName, outcome, startTime, Date.now(), result.output, result.reportFiles, result.requiredPermissions);
-      appendHistory(config.projectRoot, { task_id: taskId, result_file: resultFileName });
-      await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName);
+      finalizeResultFile(taskDir, resultFileName, taskName, taskSnapshotName, outcome, startTime, Date.now(), result.output, result.reportFiles, result.requiredPermissions);
+      await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName, resultFileName);
 
       if (result.reportFiles.length > 0) {
         await publishHostEvent(nc, config.hostId, taskId, {
@@ -222,6 +242,7 @@ export async function runCommand(taskId: string): Promise<void> {
           name: taskName,
           report_files: result.reportFiles,
           running_state: outcome,
+          result_file: resultFileName,
         });
       }
 
@@ -232,9 +253,8 @@ export async function runCommand(taskId: string): Promise<void> {
     const endTime = Date.now();
     const outcome = resolveOutcome(taskDir, "failed");
     const errorMsg = err instanceof Error ? err.message : String(err);
-    const resultFileName = writeResult(taskDir, taskName, taskSnapshotName, outcome, startTime, endTime, errorMsg, [], []);
-    appendHistory(config.projectRoot, { task_id: taskId, result_file: resultFileName });
-    await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName);
+    finalizeResultFile(taskDir, resultFileName, taskName, taskSnapshotName, outcome, startTime, endTime, errorMsg, [], []);
+    await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName, resultFileName);
     process.exitCode = 1;
   } finally {
     await cleanup();
@@ -388,6 +408,7 @@ async function publishTaskEvent(
   taskId: string,
   eventType: TaskRunningState,
   taskName?: string,
+  resultFile?: string,
 ): Promise<void> {
   writeTaskStatus(taskDir, {
     running_state: eventType,
@@ -396,6 +417,7 @@ async function publishTaskEvent(
 
   const payload: Record<string, unknown> = { event_type: "running-state", running_state: eventType };
   if (taskName) payload.name = taskName;
+  if (resultFile) payload.result_file = resultFile;
   await publishHostEvent(nc, config.hostId, taskId, payload);
 }
 
@@ -415,22 +437,6 @@ async function publishConfirmResolved(
   });
 }
 
-/**
- * Watch status.json until user_input is populated by an RPC call, then resolve.
- * All interactive request flows (confirmation, permission, user input) share this.
- */
-function waitForUserInput(taskDir: string): Promise<string[]> {
-  const statusPath = path.join(taskDir, "status.json");
-  return new Promise<string[]>((resolve) => {
-    const watcher = fs.watch(statusPath, () => {
-      const status = readTaskStatus(taskDir);
-      if (!status || !status.user_input?.length) return;
-      watcher.close();
-      resolve(status.user_input);
-    });
-  });
-}
-
 async function requestPermission(
   nc: NatsConnection | undefined,
   config: HostConfig,
@@ -470,45 +476,6 @@ async function publishPermissionResolved(
   });
 }
 
-async function requestUserInput(
-  nc: NatsConnection | undefined,
-  config: HostConfig,
-  task: ParsedTask,
-  taskDir: string,
-  inputDescriptions: string[],
-): Promise<string[] | "aborted"> {
-  const currentStatus = readTaskStatus(taskDir)!;
-  writeTaskStatus(taskDir, { ...currentStatus, pending_input: inputDescriptions });
-
-  await publishHostEvent(nc, config.hostId, task.frontmatter.id, {
-    event_type: "input-request",
-    host_id: config.hostId,
-    input_descriptions: inputDescriptions,
-    name: task.frontmatter.name,
-  });
-
-  const userInput = await waitForUserInput(taskDir);
-  if (userInput.length === 1 && userInput[0] === "aborted") {
-    writeTaskStatus(taskDir, { running_state: "aborted", time_stamp: Date.now() });
-    return "aborted";
-  }
-  writeTaskStatus(taskDir, { running_state: "started", time_stamp: Date.now() });
-  return userInput;
-}
-
-async function publishInputResolved(
-  nc: NatsConnection | undefined,
-  config: HostConfig,
-  taskId: string,
-  status: "provided" | "aborted",
-): Promise<void> {
-  await publishHostEvent(nc, config.hostId, taskId, {
-    event_type: "input-resolved",
-    host_id: config.hostId,
-    status,
-  });
-}
-
 async function requestConfirmation(
   nc: NatsConnection | undefined,
   config: HostConfig,

package/src/platform/windows.ts

@@ -126,30 +126,42 @@ export class WindowsPlatform implements PlatformService {
   }
 
   async restartDaemon(): Promise<void> {
-    // Kill the old daemon if we have its PID
-    if (fs.existsSync(DAEMON_PID_FILE)) {
-      const oldPid = fs.readFileSync(DAEMON_PID_FILE, "utf-8").trim();
+    const script = process.argv[1] || "palmier";
+    const oldPid = fs.existsSync(DAEMON_PID_FILE)
+      ? fs.readFileSync(DAEMON_PID_FILE, "utf-8").trim()
+      : null;
+
+    if (oldPid && oldPid === String(process.pid)) {
+      // We ARE the old daemon (auto-update) — spawn replacement then exit.
+      this.spawnDaemon(script);
+      process.exit(0);
+    }
+
+    // Kill old daemon first, then spawn new one.
+    if (oldPid) {
       try {
-        execFileSync("taskkill", ["/pid", oldPid, "/t", "/f"], { windowsHide: true });
+        execFileSync("taskkill", ["/pid", oldPid, "/f"], { windowsHide: true, stdio: "pipe" });
       } catch {
         // Process may have already exited
       }
     }
 
-    const script = process.argv[1] || "palmier";
     this.spawnDaemon(script);
   }
 
   private spawnDaemon(script: string): void {
-    const child = nodeSpawn(process.execPath, [script, "serve"], {
+    // Write a VBS launcher that starts the daemon with no visible console window.
+    const vbs = `CreateObject("WScript.Shell").Run """${process.execPath}"" ""${script}"" serve", 0, False`;
+    fs.writeFileSync(DAEMON_VBS_FILE, vbs, "utf-8");
+
+    const wscript = `${process.env.SYSTEMROOT || "C:\\Windows"}\\System32\\wscript.exe`;
+    const child = nodeSpawn(wscript, [DAEMON_VBS_FILE], {
       detached: true,
       stdio: "ignore",
       windowsHide: true,
     });
-    if (child.pid) {
-      fs.writeFileSync(DAEMON_PID_FILE, String(child.pid), "utf-8");
-    }
     child.unref();
+    // PID file will be written by the serve command itself when it starts.
     console.log("Palmier daemon started.");
   }
 

package/src/rpc-handler.ts

@@ -2,9 +2,10 @@ import { randomUUID } from "crypto";
 import * as fs from "fs";
 import * as path from "path";
 import { fileURLToPath } from "url";
+import { spawn } from "child_process";
 import { parse as parseYaml } from "yaml";
 import { type NatsConnection } from "nats";
-import { listTasks, parseTaskFile, writeTaskFile, getTaskDir, readTaskStatus, writeTaskStatus, readHistory, deleteHistoryEntry, appendTaskList, removeFromTaskList } from "./task.js";
+import { listTasks, parseTaskFile, writeTaskFile, getTaskDir, readTaskStatus, writeTaskStatus, readHistory, deleteHistoryEntry, appendTaskList, removeFromTaskList, appendHistory, createResultFile } from "./task.js";
 import { getPlatform } from "./platform/index.js";
 import { spawnCommand } from "./spawn-command.js";
 import { getAgent } from "./agents/agent.js";
@@ -243,11 +244,61 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
         return { ok: true, task_id: params.id };
       }
 
+      case "task.run_oneoff": {
+        const params = request.params as {
+          user_prompt: string;
+          agent: string;
+          requires_confirmation?: boolean;
+          command?: string;
+        };
+
+        const id = randomUUID();
+        const taskDir = getTaskDir(config.projectRoot, id);
+        const name = params.user_prompt.slice(0, 60);
+        const task: ParsedTask = {
+          frontmatter: {
+            id,
+            name,
+            user_prompt: params.user_prompt,
+            agent: params.agent,
+            triggers: [],
+            triggers_enabled: false,
+            requires_confirmation: params.requires_confirmation ?? false,
+            ...(params.command ? { command: params.command } : {}),
+          },
+          body: "",
+        };
+
+        writeTaskFile(taskDir, task);
+        // Do NOT append to tasks.jsonl — this is a one-off run
+
+        // Create initial result file so it appears in runs list immediately
+        const resultFileName = createResultFile(taskDir, name, Date.now());
+        appendHistory(config.projectRoot, { task_id: id, result_file: resultFileName });
+
+        // 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,
+          stdio: "ignore",
+          windowsHide: true,
+        });
+        child.unref();
+
+        return { ok: true, task_id: id, result_file: resultFileName };
+      }
+
       case "task.run": {
         const params = request.params as { id: string };
         try {
+          // Create initial result file so it appears in runs list immediately
+          const runTaskDir = getTaskDir(config.projectRoot, params.id);
+          const runTask = parseTaskFile(runTaskDir);
+          const runResultFileName = createResultFile(runTaskDir, runTask.frontmatter.name, Date.now());
+          appendHistory(config.projectRoot, { task_id: params.id, result_file: runResultFileName });
+
           await getPlatform().startTask(params.id);
-          return { ok: true, task_id: params.id };
+          return { ok: true, task_id: params.id, result_file: runResultFileName };
         } catch (err: unknown) {
           const e = err as { stderr?: string; message?: string };
           console.error(`task.run failed for ${params.id}: ${e.stderr || e.message}`);

package/src/task.ts

@@ -147,6 +147,23 @@ export function readTaskStatus(taskDir: string): TaskStatus | undefined {
   }
 }
 
+/**
+ * Create the initial result file when a task starts running.
+ * Contains only start_time and running_state=started; no end_time or content yet.
+ * Returns the result file name.
+ */
+export function createResultFile(
+  taskDir: string,
+  taskName: string,
+  startTime: number,
+): string {
+  const resultFileName = `RESULT-${startTime}.md`;
+  const taskSnapshotName = `TASK-${startTime}.md`;
+  const content = `---\ntask_name: ${taskName}\nrunning_state: started\nstart_time: ${startTime}\ntask_file: ${taskSnapshotName}\n---\n`;
+  fs.writeFileSync(path.join(taskDir, resultFileName), content, "utf-8");
+  return resultFileName;
+}
+
 /**
  * Append a history entry to the project-level history.jsonl file.
  */

package/src/user-input.ts

@@ -0,0 +1,67 @@
+import * as fs from "fs";
+import * as path from "path";
+import { readTaskStatus, writeTaskStatus } from "./task.js";
+import { publishHostEvent } from "./events.js";
+import type { HostConfig } from "./types.js";
+import type { NatsConnection } from "nats";
+
+/**
+ * Watch status.json until user_input is populated by an RPC call, then resolve.
+ */
+export function waitForUserInput(taskDir: string): Promise<string[]> {
+  const statusPath = path.join(taskDir, "status.json");
+  return new Promise<string[]>((resolve) => {
+    const watcher = fs.watch(statusPath, () => {
+      const status = readTaskStatus(taskDir);
+      if (!status || !status.user_input?.length) return;
+      watcher.close();
+      resolve(status.user_input);
+    });
+  });
+}
+
+/**
+ * Send an input-request event and wait for the user's response.
+ */
+export async function requestUserInput(
+  nc: NatsConnection | undefined,
+  config: HostConfig,
+  taskId: string,
+  taskName: string,
+  taskDir: string,
+  inputDescriptions: string[],
+): Promise<string[] | "aborted"> {
+  const currentStatus = readTaskStatus(taskDir)!;
+  writeTaskStatus(taskDir, { ...currentStatus, pending_input: inputDescriptions });
+
+  await publishHostEvent(nc, config.hostId, taskId, {
+    event_type: "input-request",
+    host_id: config.hostId,
+    input_descriptions: inputDescriptions,
+    name: taskName,
+  });
+
+  const userInput = await waitForUserInput(taskDir);
+  if (userInput.length === 1 && userInput[0] === "aborted") {
+    writeTaskStatus(taskDir, { running_state: "aborted", time_stamp: Date.now() });
+    return "aborted";
+  }
+  writeTaskStatus(taskDir, { running_state: "started", time_stamp: Date.now() });
+  return userInput;
+}
+
+/**
+ * Notify clients that an input request has been resolved.
+ */
+export async function publishInputResolved(
+  nc: NatsConnection | undefined,
+  config: HostConfig,
+  taskId: string,
+  status: "provided" | "aborted",
+): Promise<void> {
+  await publishHostEvent(nc, config.hostId, taskId, {
+    event_type: "input-resolved",
+    host_id: config.hostId,
+    status,
+  });
+}