palmier 0.4.2 → 0.4.4

package/src/commands/serve.ts

@@ -4,7 +4,7 @@ import { loadConfig } from "../config.js";
 import { connectNats } from "../nats-client.js";
 import { createRpcHandler } from "../rpc-handler.js";
 import { startNatsTransport } from "../transports/nats-transport.js";
-import { getTaskDir, readTaskStatus, writeTaskStatus, appendHistory, parseTaskFile } from "../task.js";
+import { getTaskDir, readTaskStatus, writeTaskStatus, parseTaskFile, appendRunMessage } from "../task.js";
 import { publishHostEvent } from "../events.js";
 import { getPlatform } from "../platform/index.js";
 import { detectAgents } from "../agents/agent.js";
@@ -17,41 +17,11 @@ const POLL_INTERVAL_MS = 30_000;
 const DAEMON_PID_FILE = path.join(CONFIG_DIR, "daemon.pid");
 
 /**
- * Mark a stuck task as failed: update status.json, write RESULT, append history,
- * and broadcast the failure event.
- */
-async function markTaskFailed(
-  config: HostConfig,
-  nc: NatsConnection | undefined,
-  taskId: string,
-  reason: string,
-): Promise<void> {
-  const taskDir = getTaskDir(config.projectRoot, taskId);
-  const status = readTaskStatus(taskDir);
-  if (!status || status.running_state !== "started") return;
-
-  console.log(`[monitor] Task ${taskId} ${reason}, marking as failed.`);
-  const endTime = Date.now();
-  writeTaskStatus(taskDir, { running_state: "failed", time_stamp: endTime });
-
-  let taskName = taskId;
-  try {
-    const task = parseTaskFile(taskDir);
-    taskName = task.frontmatter.name || taskId;
-  } catch { /* use taskId as fallback */ }
-
-  const resultFileName = `RESULT-${endTime}.md`;
-  const content = `---\ntask_name: ${taskName}\nrunning_state: failed\nstart_time: ${status.time_stamp}\nend_time: ${endTime}\ntask_file: \n---\n${reason}`;
-  fs.writeFileSync(path.join(taskDir, resultFileName), content, "utf-8");
-  appendHistory(config.projectRoot, { task_id: taskId, result_file: resultFileName });
-
-  const payload: Record<string, unknown> = { event_type: "running-state", running_state: "failed", name: taskName };
-  await publishHostEvent(nc, config.hostId, taskId, payload);
-}
-
-/**
- * Scan all tasks for any stuck in "start" state whose process is no longer alive.
+ * Scan all tasks for any stuck in "started" state whose process is no longer alive.
  * Uses the system scheduler (Task Scheduler / systemd) as the authoritative source.
+ *
+ * Since run.ts creates the RESULT file and history entry at start, we just need to
+ * finalize the existing RESULT file, append a failed status entry, and broadcast.
  */
 async function checkStaleTasks(
   config: HostConfig,
@@ -75,7 +45,35 @@ async function checkStaleTasks(
     // Ask the system scheduler if the task is still running
     if (platform.isTaskRunning(taskId)) continue;
 
-    await markTaskFailed(config, nc, taskId, "Task process exited unexpectedly");
+    console.log(`[monitor] Task ${taskId} process exited unexpectedly, marking as failed.`);
+    const endTime = Date.now();
+    writeTaskStatus(taskDir, { running_state: "failed", time_stamp: endTime });
+
+    // Find the latest run directory (created by run.ts at start)
+    const runId = fs.readdirSync(taskDir)
+      .filter((f) => /^\d+$/.test(f) && fs.existsSync(path.join(taskDir, f, "TASKRUN.md")))
+      .sort()
+      .pop();
+
+    if (runId) {
+      appendRunMessage(taskDir, runId, {
+        role: "status",
+        time: endTime,
+        content: "",
+        type: "failed",
+      });
+    }
+
+    let taskName = taskId;
+    try {
+      taskName = parseTaskFile(taskDir).frontmatter.name || taskId;
+    } catch { /* use taskId as fallback */ }
+
+    await publishHostEvent(nc, config.hostId, taskId, {
+      event_type: "running-state",
+      running_state: "failed",
+      name: taskName,
+    });
   }
 }
 

package/src/index.ts

@@ -9,7 +9,8 @@ import { initCommand } from "./commands/init.js";
 import { infoCommand } from "./commands/info.js";
 import { runCommand } from "./commands/run.js";
 import { serveCommand } from "./commands/serve.js";
-import { mcpserverCommand } from "./commands/mcpserver.js";
+import { notifyCommand } from "./commands/notify.js";
+import { requestInputCommand } from "./commands/request-input.js";
 
 import { pairCommand } from "./commands/pair.js";
 import { lanCommand } from "./commands/lan.js";
@@ -62,10 +63,20 @@ program
   });
 
 program
-  .command("mcpserver")
-  .description("Start an MCP server exposing Palmier tools (stdio transport)")
-  .action(async () => {
-    await mcpserverCommand();
+  .command("notify")
+  .description("Send a push notification to the user")
+  .requiredOption("--title <title>", "Notification title")
+  .requiredOption("--body <body>", "Notification body text")
+  .action(async (opts: { title: string; body: string }) => {
+    await notifyCommand(opts);
+  });
+
+program
+  .command("request-input")
+  .description("Request input from the user (requires PALMIER_TASK_ID env var)")
+  .requiredOption("--description <desc...>", "Input descriptions to show the user")
+  .action(async (opts: { description: string[] }) => {
+    await requestInputCommand(opts);
   });
 
 program

package/src/platform/linux.ts

@@ -5,6 +5,8 @@ import { execSync, exec } from "child_process";
 import { promisify } from "util";
 import type { PlatformService } from "./platform.js";
 import type { HostConfig, ParsedTask } from "../types.js";
+import { loadConfig } from "../config.js";
+import { getTaskDir, readTaskStatus } from "../task.js";
 
 const execAsync = promisify(exec);
 
@@ -230,20 +232,28 @@ WantedBy=timers.target
   }
 
   isTaskRunning(taskId: string): boolean {
+    // Check systemd first (for scheduled/on-demand runs)
     const serviceName = getServiceName(taskId);
     try {
-      // is-active exits 0 only for "active". For oneshot services (Type=oneshot),
-      // the state is "activating" while running, which exits non-zero.
-      // Use show -p ActiveState to reliably get the state without exit code issues.
       const out = execSync(
         `systemctl --user show -p ActiveState --value ${serviceName}`,
         { encoding: "utf-8" },
       );
       const state = out.trim();
-      return state === "active" || state === "activating";
-    } catch {
-      return false;
-    }
+      if (state === "active" || state === "activating") return true;
+    } catch { /* service may not exist */ }
+
+    // Fall back to PID check (for follow-up runs spawned directly)
+    try {
+      const taskDir = getTaskDir(loadConfig().projectRoot, taskId);
+      const status = readTaskStatus(taskDir);
+      if (status?.pid) {
+        process.kill(status.pid, 0); // signal 0 = check if process exists
+        return true;
+      }
+    } catch { /* process not running or config unavailable */ }
+
+    return false;
   }
 
   getGuiEnv(): Record<string, string> {

package/src/platform/windows.ts

@@ -4,7 +4,8 @@ import { execFileSync } from "child_process";
 import { spawn as nodeSpawn } from "child_process";
 import type { PlatformService } from "./platform.js";
 import type { HostConfig, ParsedTask } from "../types.js";
-import { CONFIG_DIR } from "../config.js";
+import { CONFIG_DIR, loadConfig } from "../config.js";
+import { getTaskDir, readTaskStatus } from "../task.js";
 
 
 const TASK_PREFIX = "\\Palmier\\PalmierTask-";
@@ -12,14 +13,6 @@ const DAEMON_TASK_NAME = "PalmierDaemon";
 const DAEMON_PID_FILE = path.join(CONFIG_DIR, "daemon.pid");
 const DAEMON_VBS_FILE = path.join(CONFIG_DIR, "daemon.vbs");
 
-/**
- * Build the /tr value for schtasks: a single string with quoted paths
- * so Task Scheduler can invoke node with the palmier script + subcommand.
- */
-function schtasksTr(...subcommand: string[]): string {
-  const script = process.argv[1] || "palmier";
-  return `"${process.execPath}" "${script}" ${subcommand.join(" ")}`;
-}
 
 const DOW_NAMES = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"];
 
@@ -140,7 +133,7 @@ export class WindowsPlatform implements PlatformService {
     // Kill old daemon first, then spawn new one.
     if (oldPid) {
       try {
-        execFileSync("taskkill", ["/pid", oldPid, "/f"], { windowsHide: true, stdio: "pipe" });
+        execFileSync("taskkill", ["/pid", oldPid, "/f", "/t"], { windowsHide: true, stdio: "pipe" });
       } catch {
         // Process may have already exited
       }
@@ -168,7 +161,15 @@ export class WindowsPlatform implements PlatformService {
   installTaskTimer(config: HostConfig, task: ParsedTask): void {
     const taskId = task.frontmatter.id;
     const tn = schtasksTaskName(taskId);
-    const tr = schtasksTr("run", taskId);
+    const script = process.argv[1] || "palmier";
+
+    // Write a VBS launcher so the task runs without a visible console window
+    const vbsPath = path.join(CONFIG_DIR, `task-${taskId}.vbs`);
+    const vbs = `CreateObject("WScript.Shell").Run """${process.execPath}"" ""${script}"" run ${taskId}", 0, True`;
+    fs.writeFileSync(vbsPath, vbs, "utf-8");
+
+    const wscript = `${process.env.SYSTEMROOT || "C:\\Windows"}\\System32\\wscript.exe`;
+    const tr = `"${wscript}" "${vbsPath}"`;
 
     // Build trigger XML elements
     const triggerElements: string[] = [];
@@ -212,6 +213,7 @@ export class WindowsPlatform implements PlatformService {
     } catch {
       // Task might not exist — that's fine
     }
+    try { fs.unlinkSync(path.join(CONFIG_DIR, `task-${taskId}.vbs`)); } catch { /* ignore */ }
   }
 
   async startTask(taskId: string): Promise<void> {
@@ -225,6 +227,20 @@ export class WindowsPlatform implements PlatformService {
   }
 
   async stopTask(taskId: string): Promise<void> {
+    // Try to kill the entire process tree via the PID recorded in status.json.
+    // schtasks /end only kills the top-level process, leaving agent children orphaned.
+    try {
+      const taskDir = getTaskDir(loadConfig().projectRoot, taskId);
+      const status = readTaskStatus(taskDir);
+      if (status?.pid) {
+        execFileSync("taskkill", ["/pid", String(status.pid), "/f", "/t"], { windowsHide: true, stdio: "pipe" });
+        return;
+      }
+    } catch {
+      // PID may be stale or config unavailable; fall through to schtasks /end
+    }
+
+    // Fallback: schtasks /end (kills top-level process only)
     const tn = schtasksTaskName(taskId);
     try {
       execFileSync("schtasks", ["/end", "/tn", tn], { encoding: "utf-8", windowsHide: true });
@@ -235,16 +251,38 @@ export class WindowsPlatform implements PlatformService {
   }
 
   isTaskRunning(taskId: string): boolean {
+    // Check Task Scheduler first (for scheduled/on-demand runs)
     const tn = schtasksTaskName(taskId);
     try {
       const out = execFileSync("schtasks", ["/query", "/tn", tn, "/fo", "CSV", "/nh"], {
         encoding: "utf-8",
         windowsHide: true,
       });
-      return out.includes('"Running"');
-    } catch {
-      return false;
-    }
+      if (out.includes('"Running"')) return true;
+    } catch { /* task may not exist in scheduler */ }
+
+    // Fall back to PID check (for follow-up runs spawned directly, not via schtasks)
+    try {
+      const taskDir = getTaskDir(loadConfig().projectRoot, taskId);
+      const status = readTaskStatus(taskDir);
+      if (status?.pid) {
+        // tasklist exits 0 if the PID is found
+        execFileSync("tasklist", ["/fi", `PID eq ${status.pid}`, "/nh"], {
+          encoding: "utf-8",
+          windowsHide: true,
+          stdio: "pipe",
+        });
+        // tasklist always exits 0; check if output contains the PID
+        const out = execFileSync("tasklist", ["/fi", `PID eq ${status.pid}`, "/fo", "CSV", "/nh"], {
+          encoding: "utf-8",
+          windowsHide: true,
+          stdio: "pipe",
+        });
+        if (out.includes(`"${status.pid}"`)) return true;
+      }
+    } catch { /* ignore */ }
+
+    return false;
   }
 
   getGuiEnv(): Record<string, string> {