palmier 0.2.5 → 0.2.7

package/src/commands/serve.ts

@@ -1,26 +1,105 @@
+import * as fs from "fs";
+import * as path from "path";
 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 { startHttpTransport } from "../transports/http-transport.js";
+import { getTaskDir, readTaskStatus, writeTaskStatus, appendHistory, parseTaskFile } from "../task.js";
+import { publishHostEvent } from "../events.js";
+import { getPlatform } from "../platform/index.js";
+import type { HostConfig } from "../types.js";
+import { CONFIG_DIR } from "../config.js";
+import type { NatsConnection } from "nats";
+
+const POLL_INTERVAL_MS = 30_000;
+const DAEMON_PID_FILE = path.join(CONFIG_DIR, "daemon.pid");
 
 /**
- * Start the persistent RPC handler using the configured transport(s).
+ * 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.
+ * Uses the system scheduler (Task Scheduler / systemd) as the authoritative source.
+ */
+async function checkStaleTasks(
+  config: HostConfig,
+  nc: NatsConnection | undefined,
+): Promise<void> {
+  const tasksJsonl = path.join(config.projectRoot, "tasks.jsonl");
+  if (!fs.existsSync(tasksJsonl)) return;
+
+  const platform = getPlatform();
+  const lines = fs.readFileSync(tasksJsonl, "utf-8").split("\n").filter(Boolean);
+  for (const line of lines) {
+    let taskId: string;
+    try {
+      taskId = (JSON.parse(line) as { task_id: string }).task_id;
+    } catch { continue; }
+
+    const taskDir = getTaskDir(config.projectRoot, taskId);
+    const status = readTaskStatus(taskDir);
+    if (!status || status.running_state !== "started") continue;
+
+    // Ask the system scheduler if the task is still running
+    if (platform.isTaskRunning(taskId)) continue;
+
+    await markTaskFailed(config, nc, taskId, "Task process exited unexpectedly");
+  }
+}
+
+/**
+ * Start the persistent RPC handler (NATS only).
  */
 export async function serveCommand(): Promise<void> {
   const config = loadConfig();
-  const handleRpc = createRpcHandler(config);
-
-  const mode = config.mode ?? "nats";
-  console.log(`Starting in ${mode} mode...`);
-
-  if (mode === "auto") {
-    await Promise.all([
-      startNatsTransport(config, handleRpc),
-      startHttpTransport(config, handleRpc),
-    ]);
-  } else if (mode === "lan") {
-    await startHttpTransport(config, handleRpc);
-  } else {
-    await startNatsTransport(config, handleRpc);
-  }
+
+  // Write PID so `palmier restart` can find us regardless of how we were started
+  fs.writeFileSync(DAEMON_PID_FILE, String(process.pid), "utf-8");
+
+  console.log("Starting...");
+
+  const nc = await connectNats(config);
+
+  // Reconcile any tasks stuck from before daemon started
+  await checkStaleTasks(config, nc);
+
+  // Poll for crashed tasks every 30 seconds
+  setInterval(() => {
+    checkStaleTasks(config, nc).catch((err) => {
+      console.error("[monitor] Error checking stale tasks:", err);
+    });
+  }, POLL_INTERVAL_MS);
+
+  const handleRpc = createRpcHandler(config, nc);
+  await startNatsTransport(config, handleRpc, nc);
 }

package/src/config.ts

@@ -21,30 +21,15 @@ export function loadConfig(): HostConfig {
   const raw = fs.readFileSync(CONFIG_FILE, "utf-8");
   const config = JSON.parse(raw) as HostConfig;
 
-  // Default mode to "nats" for backward compatibility
-  if (!config.mode) {
-    config.mode = "nats";
-  }
-
   if (!config.hostId) {
     throw new Error("Invalid host config: missing hostId");
   }
 
-  const mode = config.mode;
-  if (mode === "nats" || mode === "auto") {
-    if (!config.natsUrl || !config.natsToken) {
-      throw new Error(`Invalid host config: mode "${mode}" requires natsUrl and natsToken`);
-    }
-  }
-  if (mode === "lan" || mode === "auto") {
-    if (!config.directToken) {
-      throw new Error(`Invalid host config: mode "${mode}" requires directToken`);
-    }
-    if (!config.directPort) {
-      config.directPort = 7400;
-    }
+  if (!config.natsUrl || !config.natsToken) {
+    throw new Error("Invalid host config: missing natsUrl or natsToken");
   }
 
+  config.nats = true;
   return config;
 }
 

package/src/cross-spawn.d.ts

@@ -0,0 +1,5 @@
+declare module "cross-spawn" {
+  import type { ChildProcess, SpawnOptions } from "child_process";
+  function spawn(command: string, args?: string[], options?: SpawnOptions): ChildProcess;
+  export default spawn;
+}

package/src/events.ts

@@ -0,0 +1,51 @@
+import * as fs from "fs";
+import * as path from "path";
+import { StringCodec, type NatsConnection } from "nats";
+import { CONFIG_DIR } from "./config.js";
+
+const sc = StringCodec();
+const LAN_LOCKFILE = path.join(CONFIG_DIR, "lan.json");
+
+/**
+ * Read the LAN lockfile to determine if `palmier lan` is running.
+ */
+function getLanPort(): number | null {
+  try {
+    const raw = fs.readFileSync(LAN_LOCKFILE, "utf-8");
+    return (JSON.parse(raw) as { port: number }).port;
+  } catch { return null; }
+}
+
+/**
+ * Broadcast an event to connected clients via NATS and HTTP SSE (if LAN server is running).
+ *
+ * - NATS: publishes to `host-event.{hostId}.{taskId}`
+ * - HTTP: POSTs to the LAN server's `/internal/event` endpoint (auto-detected via lockfile)
+ */
+export async function publishHostEvent(
+  nc: NatsConnection | undefined,
+  hostId: string,
+  taskId: string,
+  payload: Record<string, unknown>,
+): Promise<void> {
+  const subject = `host-event.${hostId}.${taskId}`;
+
+  if (nc) {
+    nc.publish(subject, sc.encode(JSON.stringify(payload)));
+    console.log(`[nats] ${subject} →`, payload);
+  }
+
+  const lanPort = getLanPort();
+  if (lanPort) {
+    try {
+      await fetch(`http://localhost:${lanPort}/internal/event`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ task_id: taskId, ...payload }),
+      });
+      console.log(`[http] host-event: ${taskId} →`, payload);
+    } catch {
+      // LAN server may have shut down — ignore
+    }
+  }
+}

package/src/index.ts

@@ -12,6 +12,8 @@ import { serveCommand } from "./commands/serve.js";
 import { mcpserverCommand } from "./commands/mcpserver.js";
 import { agentsCommand } from "./commands/agents.js";
 import { pairCommand } from "./commands/pair.js";
+import { lanCommand } from "./commands/lan.js";
+import { restartCommand } from "./commands/restart.js";
 import { sessionsListCommand, sessionsRevokeCommand, sessionsRevokeAllCommand } from "./commands/sessions.js";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -52,6 +54,13 @@ program
     await serveCommand();
   });
 
+program
+  .command("restart")
+  .description("Restart the palmier serve daemon")
+  .action(async () => {
+    await restartCommand();
+  });
+
 program
   .command("mcpserver")
   .description("Start an MCP server exposing Palmier tools (stdio transport)")
@@ -73,6 +82,14 @@ program
     await pairCommand();
   });
 
+program
+  .command("lan")
+  .description("Start an on-demand LAN server for direct HTTP connections")
+  .option("-p, --port <port>", "Port to listen on", "7400")
+  .action(async (opts: { port: string }) => {
+    await lanCommand({ port: parseInt(opts.port, 10) });
+  });
+
 const sessionsCmd = program
   .command("sessions")
   .description("Manage paired client sessions");

package/src/platform/linux.ts

@@ -112,6 +112,11 @@ WantedBy=default.target
     console.log("\nHost initialization complete!");
   }
 
+  async restartDaemon(): Promise<void> {
+    execSync("systemctl --user restart palmier.service", { stdio: "inherit" });
+    console.log("Palmier daemon restarted.");
+  }
+
   installTaskTimer(config: HostConfig, task: ParsedTask): void {
     fs.mkdirSync(UNIT_DIR, { recursive: true });
 
@@ -125,6 +130,7 @@ Description=Palmier Task: ${taskId}
 
 [Service]
 Type=oneshot
+TimeoutStartSec=infinity
 ExecStart=${palmierBin} run ${taskId}
 WorkingDirectory=${config.projectRoot}
 Environment=PATH=${process.env.PATH || "/usr/local/bin:/usr/bin:/bin"}
@@ -133,7 +139,8 @@ Environment=PATH=${process.env.PATH || "/usr/local/bin:/usr/bin:/bin"}
     fs.writeFileSync(path.join(UNIT_DIR, serviceName), serviceContent, "utf-8");
     daemonReload();
 
-    // Only create and enable a timer if there are actual triggers
+    // Only create and enable a timer if triggers exist and are enabled
+    if (!task.frontmatter.triggers_enabled) return;
     const triggers = task.frontmatter.triggers || [];
     const onCalendarLines: string[] = [];
     for (const trigger of triggers) {
@@ -193,6 +200,23 @@ WantedBy=timers.target
     await execAsync(`systemctl --user stop ${serviceName}`);
   }
 
+  isTaskRunning(taskId: string): boolean {
+    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;
+    }
+  }
+
   getGuiEnv(): Record<string, string> {
     const uid = process.getuid?.();
     const runtimeDir =

package/src/platform/platform.ts

@@ -8,6 +8,9 @@ export interface PlatformService {
   /** Install the main `palmier serve` daemon to start at boot. */
   installDaemon(config: HostConfig): void;
 
+  /** Restart the `palmier serve` daemon. */
+  restartDaemon(): Promise<void>;
+
   /** Install a scheduled trigger (timer) for a task. */
   installTaskTimer(config: HostConfig, task: ParsedTask): void;
 
@@ -20,6 +23,9 @@ export interface PlatformService {
   /** Abort/stop a running task. */
   stopTask(taskId: string): Promise<void>;
 
+  /** Check if a task is currently running via the system scheduler. */
+  isTaskRunning(taskId: string): boolean;
+
   /** Return env vars needed for GUI access (Linux: DISPLAY, etc.). */
   getGuiEnv(): Record<string, string>;
 }

package/src/platform/windows.ts

@@ -1,27 +1,23 @@
 import * as fs from "fs";
 import * as path from "path";
-import { execSync, exec, spawn as nodeSpawn } from "child_process";
-import { promisify } from "util";
+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 { getTaskDir } from "../task.js";
-import { loadConfig } from "../config.js";
+import { CONFIG_DIR } from "../config.js";
 
-const execAsync = promisify(exec);
 
-const TASK_PREFIX = "PalmierTask-";
+const TASK_PREFIX = "\\Palmier\\PalmierTask-";
 const DAEMON_TASK_NAME = "PalmierDaemon";
-const SHELL = "cmd.exe";
+const DAEMON_PID_FILE = path.join(CONFIG_DIR, "daemon.pid");
 
 /**
- * Resolve the full command to invoke palmier, accounting for the fact that
- * on Windows, globally-installed npm packages are .cmd shims.
+ * Build the /tr value for schtasks: a single string with quoted paths
+ * so Task Scheduler can invoke node with the palmier script + subcommand.
  */
-function getPalmierCommand(): string {
-  // process.argv[1] is the script path; wrap with node so it works as
-  // a Task Scheduler command without relying on file associations.
+function schtasksTr(...subcommand: string[]): string {
   const script = process.argv[1] || "palmier";
-  return `"${process.execPath}" "${script}"`;
+  return `"${process.execPath}" "${script}" ${subcommand.join(" ")}`;
 }
 
 /**
@@ -79,65 +75,86 @@ function schtasksTaskName(taskId: string): string {
 
 export class WindowsPlatform implements PlatformService {
   installDaemon(config: HostConfig): void {
-    const cmd = getPalmierCommand();
-
-    // Try ONSTART first (requires elevation), fall back to ONLOGON
-    const baseArgs = [
-      "/create", "/tn", DAEMON_TASK_NAME,
-      "/tr", `${cmd} serve`,
-      "/rl", "HIGHEST",
-      "/f", // force overwrite if exists
-    ];
+    const script = process.argv[1] || "palmier";
+    const regValue = `"${process.execPath}" "${script}" serve`;
 
     try {
-      execSync(
-        `schtasks ${[...baseArgs, "/sc", "ONSTART"].join(" ")}`,
-        { encoding: "utf-8", shell: SHELL },
-      );
-      console.log(`Task Scheduler: "${DAEMON_TASK_NAME}" installed (runs at startup).`);
-    } catch {
-      // ONSTART requires admin — fall back to ONLOGON which does not
-      try {
-        execSync(
-          `schtasks ${[...baseArgs, "/sc", "ONLOGON"].join(" ")}`,
-          { encoding: "utf-8", shell: SHELL },
-        );
-        console.log(`Task Scheduler: "${DAEMON_TASK_NAME}" installed (runs at logon).`);
-        console.log("  Tip: run as Administrator to use ONSTART instead.");
-      } catch (err) {
-        console.error(`Warning: failed to create scheduled task: ${err}`);
-        console.error("You may need to start palmier serve manually.");
-      }
+      execFileSync("reg", [
+        "add", "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run",
+        "/v", DAEMON_TASK_NAME, "/t", "REG_SZ", "/d", regValue, "/f",
+      ], { encoding: "utf-8", stdio: "pipe" });
+      console.log(`Registry Run key "${DAEMON_TASK_NAME}" installed (runs at logon).`);
+    } catch (err) {
+      console.error(`Warning: failed to install registry run entry: ${err}`);
+      console.error("You may need to start palmier serve manually.");
     }
 
     // Start the daemon now
-    try {
-      execSync(`schtasks /run /tn ${DAEMON_TASK_NAME}`, { encoding: "utf-8", shell: SHELL });
-      console.log("Palmier daemon started.");
-    } catch {
-      console.log("Note: could not start daemon immediately. It will start at next login/boot.");
-    }
+    this.spawnDaemon(script);
 
     console.log("\nHost initialization complete!");
   }
 
+  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();
+      try {
+        execFileSync("taskkill", ["/pid", oldPid, "/t", "/f"], { windowsHide: true });
+      } 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"], {
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true,
+    });
+    if (child.pid) {
+      fs.writeFileSync(DAEMON_PID_FILE, String(child.pid), "utf-8");
+    }
+    child.unref();
+    console.log("Palmier daemon started.");
+  }
+
   installTaskTimer(config: HostConfig, task: ParsedTask): void {
     const taskId = task.frontmatter.id;
     const tn = schtasksTaskName(taskId);
-    const cmd = getPalmierCommand();
+    const tr = schtasksTr("run", taskId);
+
+    // Always create the scheduled task with a dummy trigger first.
+    // This ensures startTask (/run) works even when no triggers are configured.
+    try {
+      execFileSync("schtasks", [
+        "/create", "/tn", tn,
+        "/tr", tr,
+        "/sc", "ONCE", "/sd", "01/01/2000", "/st", "00:00",
+        "/f",
+      ], { encoding: "utf-8", windowsHide: true });
+    } catch (err: unknown) {
+      const e = err as { stderr?: string };
+      console.error(`Failed to create scheduled task ${tn}: ${e.stderr || err}`);
+    }
 
+    // Overlay with real schedule triggers if enabled
+    if (!task.frontmatter.triggers_enabled) return;
     const triggers = task.frontmatter.triggers || [];
     for (const trigger of triggers) {
       if (trigger.type === "cron") {
         const schedArgs = cronToSchtasksArgs(trigger.value);
-        const args = [
-          "/create", "/tn", tn,
-          "/tr", `${cmd} run ${taskId}`,
-          ...schedArgs,
-          "/f",
-        ];
         try {
-          execSync(`schtasks ${args.join(" ")}`, { encoding: "utf-8", shell: SHELL });
+          execFileSync("schtasks", [
+            "/create", "/tn", tn,
+            "/tr", tr,
+            ...schedArgs,
+            "/f",
+          ], { encoding: "utf-8", windowsHide: true });
         } catch (err: unknown) {
           const e = err as { stderr?: string };
           console.error(`Failed to create scheduled task ${tn}: ${e.stderr || err}`);
@@ -153,14 +170,13 @@ export class WindowsPlatform implements PlatformService {
         const [year, month, day] = datePart.split("-");
         const sd = `${month}/${day}/${year}`;
         const st = timePart.slice(0, 5);
-        const args = [
-          "/create", "/tn", tn,
-          "/tr", `${cmd} run ${taskId}`,
-          "/sc", "ONCE", "/sd", sd, "/st", st,
-          "/f",
-        ];
         try {
-          execSync(`schtasks ${args.join(" ")}`, { encoding: "utf-8", shell: SHELL });
+          execFileSync("schtasks", [
+            "/create", "/tn", tn,
+            "/tr", tr,
+            "/sc", "ONCE", "/sd", sd, "/st", st,
+            "/f",
+          ], { encoding: "utf-8", windowsHide: true });
         } catch (err: unknown) {
           const e = err as { stderr?: string };
           console.error(`Failed to create once task ${tn}: ${e.stderr || err}`);
@@ -172,47 +188,42 @@ export class WindowsPlatform implements PlatformService {
   removeTaskTimer(taskId: string): void {
     const tn = schtasksTaskName(taskId);
     try {
-      execSync(`schtasks /delete /tn ${tn} /f`, { encoding: "utf-8", shell: SHELL });
+      execFileSync("schtasks", ["/delete", "/tn", tn, "/f"], { encoding: "utf-8", windowsHide: true });
     } catch {
       // Task might not exist — that's fine
     }
   }
 
   async startTask(taskId: string): Promise<void> {
-    const config = loadConfig();
-    const taskDir = getTaskDir(config.projectRoot, taskId);
-    const script = process.argv[1] || "palmier";
-
-    // Spawn a detached child process and record its PID for later abort
-    const child = nodeSpawn(process.execPath, [script, "run", taskId], {
-      detached: true,
-      stdio: "ignore",
-      cwd: config.projectRoot,
-    });
-
-    if (child.pid) {
-      fs.mkdirSync(taskDir, { recursive: true });
-      fs.writeFileSync(path.join(taskDir, "pid"), String(child.pid), "utf-8");
+    const tn = schtasksTaskName(taskId);
+    try {
+      execFileSync("schtasks", ["/run", "/tn", tn], { encoding: "utf-8", windowsHide: true });
+    } catch (err: unknown) {
+      const e = err as { stderr?: string; message?: string };
+      throw new Error(`Failed to start task via schtasks: ${e.stderr || e.message}`);
     }
-    child.unref();
   }
 
   async stopTask(taskId: string): Promise<void> {
-    const config = loadConfig();
-    const taskDir = getTaskDir(config.projectRoot, taskId);
-    const pidPath = path.join(taskDir, "pid");
-
-    if (!fs.existsSync(pidPath)) {
-      throw new Error(`No PID file found for task ${taskId}`);
+    const tn = schtasksTaskName(taskId);
+    try {
+      execFileSync("schtasks", ["/end", "/tn", tn], { encoding: "utf-8", windowsHide: true });
+    } catch (err: unknown) {
+      const e = err as { stderr?: string; message?: string };
+      throw new Error(`Failed to stop task via schtasks: ${e.stderr || e.message}`);
     }
+  }
 
-    const pid = fs.readFileSync(pidPath, "utf-8").trim();
+  isTaskRunning(taskId: string): boolean {
+    const tn = schtasksTaskName(taskId);
     try {
-      // /t kills the entire process tree, /f forces termination
-      await execAsync(`taskkill /pid ${pid} /t /f`);
-    } finally {
-      // Clean up PID file regardless of whether taskkill succeeded
-      try { fs.unlinkSync(pidPath); } catch { /* ignore */ }
+      const out = execFileSync("schtasks", ["/query", "/tn", tn, "/fo", "CSV", "/nh"], {
+        encoding: "utf-8",
+        windowsHide: true,
+      });
+      return out.includes('"Running"');
+    } catch {
+      return false;
     }
   }