palmier 0.2.4 → 0.2.6

package/dist/commands/task-cleanup.js

@@ -0,0 +1,84 @@
+import * as fs from "fs";
+import * as path from "path";
+import { loadConfig } from "../config.js";
+import { connectNats } from "../nats-client.js";
+import { getTaskDir, readTaskStatus, writeTaskStatus, appendHistory, parseTaskFile } from "../task.js";
+import { publishHostEvent } from "../events.js";
+/**
+ * Write a minimal RESULT file for a task that exited without writing one itself.
+ * Uses the status.json time_stamp as the start time.
+ */
+function writeCleanupResult(taskDir, taskName, runningState, startTime) {
+    const endTime = Date.now();
+    const resultFileName = `RESULT-${endTime}.md`;
+    // Find the task snapshot file that matches the start time
+    const taskSnapshotName = `TASK-${startTime}.md`;
+    const taskFile = fs.existsSync(path.join(taskDir, taskSnapshotName)) ? taskSnapshotName : "";
+    const content = `---\ntask_name: ${taskName}\nrunning_state: ${runningState}\nstart_time: ${startTime}\nend_time: ${endTime}\ntask_file: ${taskFile}\n---\nTask process exited unexpectedly.`;
+    fs.writeFileSync(path.join(taskDir, resultFileName), content, "utf-8");
+    return resultFileName;
+}
+/**
+ * Post-exit cleanup for a task process.
+ *
+ * Called by the platform hook (ExecStopPost on Linux, wrapper script on Windows)
+ * after the main `palmier run <taskId>` process exits.
+ *
+ * - If status.json shows "finish" or "fail", the process handled its own cleanup — no-op.
+ * - If status.json shows "abort", the RPC handler already wrote status and broadcast —
+ *   just write the RESULT file and append history.
+ * - If status.json shows "start", the process died unexpectedly — write "fail" status,
+ *   RESULT file, append history, and broadcast event.
+ */
+export async function taskCleanupCommand(taskId) {
+    const config = loadConfig();
+    const taskDir = getTaskDir(config.projectRoot, taskId);
+    const status = readTaskStatus(taskDir);
+    if (!status) {
+        console.log(`[task-cleanup] No status.json for task ${taskId}, nothing to do.`);
+        return;
+    }
+    // Process already handled its own cleanup
+    if (status.running_state === "finish" || status.running_state === "fail") {
+        console.log(`[task-cleanup] Task ${taskId} already in terminal state: ${status.running_state}`);
+        return;
+    }
+    // Read task name for RESULT file
+    let taskName = taskId;
+    try {
+        const task = parseTaskFile(taskDir);
+        taskName = task.frontmatter.name || taskId;
+    }
+    catch { /* use taskId as fallback name */ }
+    const startTime = status.time_stamp;
+    if (status.running_state === "abort") {
+        // RPC handler already wrote status and broadcast — just write RESULT + history
+        console.log(`[task-cleanup] Task ${taskId} was aborted via RPC, writing RESULT.`);
+        const resultFileName = writeCleanupResult(taskDir, taskName, "abort", startTime);
+        appendHistory(config.projectRoot, { task_id: taskId, result_file: resultFileName });
+        return;
+    }
+    // status.running_state === "start" — unexpected death
+    console.log(`[task-cleanup] Task ${taskId} died unexpectedly, marking as failed.`);
+    writeTaskStatus(taskDir, { running_state: "fail", time_stamp: Date.now() });
+    const resultFileName = writeCleanupResult(taskDir, taskName, "fail", startTime);
+    appendHistory(config.projectRoot, { task_id: taskId, result_file: resultFileName });
+    // Broadcast failure event via NATS and/or HTTP, consistent with other status pushes
+    const mode = config.mode ?? "nats";
+    const useNats = mode === "nats" || mode === "auto";
+    const useHttp = mode === "lan" || mode === "auto";
+    let nc;
+    try {
+        if (useNats) {
+            nc = await connectNats(config);
+        }
+        const payload = { event_type: "running-state", running_state: "fail", name: taskName };
+        await publishHostEvent(nc, config, taskId, payload, useHttp);
+    }
+    finally {
+        if (nc && !nc.isClosed()) {
+            await nc.drain();
+        }
+    }
+}
+//# sourceMappingURL=task-cleanup.js.map

package/dist/config.js

@@ -9,7 +9,7 @@ const CONFIG_FILE = path.join(CONFIG_DIR, "host.json");
  */
 export function loadConfig() {
     if (!fs.existsSync(CONFIG_FILE)) {
-        throw new Error("Host not provisioned. Run `palmier init --token <token>` or `palmier init --lan` first.\n" +
+        throw new Error("Host not provisioned. Run `palmier init` first.\n" +
             `Expected config at: ${CONFIG_FILE}`);
     }
     const raw = fs.readFileSync(CONFIG_FILE, "utf-8");

package/dist/events.d.ts

@@ -0,0 +1,10 @@
+import { type NatsConnection } from "nats";
+import type { HostConfig } from "./types.js";
+/**
+ * Broadcast an event to connected clients via NATS and/or HTTP SSE.
+ *
+ * - NATS: publishes to `host-event.{hostId}.{taskId}`
+ * - HTTP: POSTs to the daemon's `/internal/event` endpoint which fans out via SSE
+ */
+export declare function publishHostEvent(nc: NatsConnection | undefined, config: HostConfig, taskId: string, payload: Record<string, unknown>, useHttp: boolean): Promise<void>;
+//# sourceMappingURL=events.d.ts.map

package/dist/events.js

@@ -0,0 +1,29 @@
+import { StringCodec } from "nats";
+const sc = StringCodec();
+/**
+ * Broadcast an event to connected clients via NATS and/or HTTP SSE.
+ *
+ * - NATS: publishes to `host-event.{hostId}.{taskId}`
+ * - HTTP: POSTs to the daemon's `/internal/event` endpoint which fans out via SSE
+ */
+export async function publishHostEvent(nc, config, taskId, payload, useHttp) {
+    const subject = `host-event.${config.hostId}.${taskId}`;
+    if (nc) {
+        nc.publish(subject, sc.encode(JSON.stringify(payload)));
+        console.log(`[nats] ${subject} →`, payload);
+    }
+    if (useHttp && config.directPort) {
+        try {
+            await fetch(`http://localhost:${config.directPort}/internal/event`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ task_id: taskId, ...payload }),
+            });
+            console.log(`[http] host-event: ${taskId} →`, payload);
+        }
+        catch (err) {
+            console.error(`[http] Failed to push event:`, err);
+        }
+    }
+}
+//# sourceMappingURL=events.js.map

package/dist/index.js

@@ -11,6 +11,7 @@ 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 { restartCommand } from "./commands/restart.js";
 import { sessionsListCommand, sessionsRevokeCommand, sessionsRevokeAllCommand } from "./commands/sessions.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(join(__dirname, "../package.json"), "utf-8"));
@@ -22,12 +23,8 @@ program
 program
     .command("init")
     .description("Provision this host")
-    .option("--server <url>", "Register with Palmier server at the given URL")
-    .option("--lan", "Standalone LAN mode (no server needed)")
-    .option("--host <ip>", "Override detected LAN IP address")
-    .option("--port <port>", "Direct HTTP port (default: 7400)", parseInt)
-    .action(async (options) => {
-    await initCommand(options);
+    .action(async () => {
+    await initCommand();
 });
 program
     .command("info")
@@ -42,11 +39,17 @@ program
     await runCommand(taskId);
 });
 program
-    .command("serve", { isDefault: true })
+    .command("serve")
     .description("Start the persistent RPC handler")
     .action(async () => {
     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)")
@@ -86,6 +89,10 @@ sessionsCmd
     .action(async () => {
     await sessionsRevokeAllCommand();
 });
+// No subcommand → default to serve
+if (process.argv.length <= 2) {
+    process.argv.push("serve");
+}
 program.parseAsync(process.argv).catch((err) => {
     console.error(err);
     process.exit(1);

package/dist/platform/index.d.ts

@@ -0,0 +1,4 @@
+import type { PlatformService } from "./platform.js";
+export declare function getPlatform(): PlatformService;
+export type { PlatformService } from "./platform.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/platform/index.js

@@ -0,0 +1,12 @@
+import { LinuxPlatform } from "./linux.js";
+import { WindowsPlatform } from "./windows.js";
+let _instance;
+export function getPlatform() {
+    if (!_instance) {
+        _instance = process.platform === "win32"
+            ? new WindowsPlatform()
+            : new LinuxPlatform();
+    }
+    return _instance;
+}
+//# sourceMappingURL=index.js.map

package/dist/platform/linux.d.ts

@@ -0,0 +1,13 @@
+import type { PlatformService } from "./platform.js";
+import type { HostConfig, ParsedTask } from "../types.js";
+export declare class LinuxPlatform implements PlatformService {
+    installDaemon(config: HostConfig): void;
+    restartDaemon(): Promise<void>;
+    installTaskTimer(config: HostConfig, task: ParsedTask): void;
+    removeTaskTimer(taskId: string): void;
+    startTask(taskId: string): Promise<void>;
+    stopTask(taskId: string): Promise<void>;
+    isTaskRunning(taskId: string): boolean;
+    getGuiEnv(): Record<string, string>;
+}
+//# sourceMappingURL=linux.d.ts.map

package/dist/platform/linux.js

@@ -0,0 +1,207 @@
+import * as fs from "fs";
+import * as path from "path";
+import { homedir } from "os";
+import { execSync, exec } from "child_process";
+import { promisify } from "util";
+const execAsync = promisify(exec);
+const UNIT_DIR = path.join(homedir(), ".config", "systemd", "user");
+function getTimerName(taskId) {
+    return `palmier-task-${taskId}.timer`;
+}
+function getServiceName(taskId) {
+    return `palmier-task-${taskId}.service`;
+}
+/**
+ * Convert a cron expression to a systemd OnCalendar string.
+ *
+ * Only the 4 cron patterns the PWA UI can produce are supported:
+ *   hourly:  "0 * * * *"
+ *   daily:   "MM HH * * *"
+ *   weekly:  "MM HH * * D"
+ *   monthly: "MM HH D * *"
+ * Arbitrary cron expressions (ranges, lists, steps beyond hourly) are NOT
+ * handled because the UI never generates them.
+ */
+function cronToOnCalendar(cron) {
+    const parts = cron.trim().split(/\s+/);
+    if (parts.length !== 5) {
+        throw new Error(`Invalid cron expression (expected 5 fields): ${cron}`);
+    }
+    const [minute, hour, dayOfMonth, , dayOfWeek] = parts;
+    // Map cron day-of-week numbers to systemd abbreviated names
+    const dowMap = {
+        "0": "Sun", "1": "Mon", "2": "Tue", "3": "Wed",
+        "4": "Thu", "5": "Fri", "6": "Sat", "7": "Sun",
+    };
+    const monthPart = "*";
+    const dayPart = dayOfMonth === "*" ? "*" : dayOfMonth.padStart(2, "0");
+    const hourPart = hour === "*" ? "*" : hour.padStart(2, "0");
+    const minutePart = minute === "*" ? "*" : minute.padStart(2, "0");
+    if (dayOfWeek !== "*") {
+        const dow = dowMap[dayOfWeek] ?? dayOfWeek;
+        return `${dow} *-${monthPart}-${dayPart} ${hourPart}:${minutePart}:00`;
+    }
+    return `*-${monthPart}-${dayPart} ${hourPart}:${minutePart}:00`;
+}
+function daemonReload() {
+    try {
+        execSync("systemctl --user daemon-reload", { encoding: "utf-8" });
+    }
+    catch (err) {
+        const e = err;
+        console.error(`daemon-reload failed: ${e.stderr || err}`);
+    }
+}
+export class LinuxPlatform {
+    installDaemon(config) {
+        fs.mkdirSync(UNIT_DIR, { recursive: true });
+        const palmierBin = process.argv[1] || "palmier";
+        const serviceContent = `[Unit]
+Description=Palmier Host
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${palmierBin} serve
+WorkingDirectory=${config.projectRoot}
+Restart=on-failure
+RestartSec=5
+Environment=PATH=${process.env.PATH || "/usr/local/bin:/usr/bin:/bin"}
+
+[Install]
+WantedBy=default.target
+`;
+        const servicePath = path.join(UNIT_DIR, "palmier.service");
+        fs.writeFileSync(servicePath, serviceContent, "utf-8");
+        console.log("Systemd service installed at:", servicePath);
+        try {
+            execSync("systemctl --user daemon-reload", { stdio: "inherit" });
+            execSync("systemctl --user enable palmier.service", { stdio: "inherit" });
+            execSync("systemctl --user restart palmier.service", { stdio: "inherit" });
+            console.log("Palmier host service enabled and started.");
+        }
+        catch (err) {
+            console.error(`Warning: failed to enable systemd service: ${err}`);
+            console.error("You may need to start it manually: systemctl --user enable --now palmier.service");
+        }
+        // Enable lingering so service runs without active login session
+        try {
+            execSync(`loginctl enable-linger ${process.env.USER || ""}`, { stdio: "inherit" });
+            console.log("Login lingering enabled.");
+        }
+        catch (err) {
+            console.error(`Warning: failed to enable linger: ${err}`);
+        }
+        console.log("\nHost initialization complete!");
+    }
+    async restartDaemon() {
+        execSync("systemctl --user restart palmier.service", { stdio: "inherit" });
+        console.log("Palmier daemon restarted.");
+    }
+    installTaskTimer(config, task) {
+        fs.mkdirSync(UNIT_DIR, { recursive: true });
+        const taskId = task.frontmatter.id;
+        const serviceName = getServiceName(taskId);
+        const timerName = getTimerName(taskId);
+        const palmierBin = process.argv[1] || "palmier";
+        const serviceContent = `[Unit]
+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"}
+`;
+        fs.writeFileSync(path.join(UNIT_DIR, serviceName), serviceContent, "utf-8");
+        daemonReload();
+        // 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 = [];
+        for (const trigger of triggers) {
+            if (trigger.type === "cron") {
+                onCalendarLines.push(`OnCalendar=${cronToOnCalendar(trigger.value)}`);
+            }
+            else if (trigger.type === "once") {
+                onCalendarLines.push(`OnActiveSec=${trigger.value}`);
+            }
+        }
+        if (onCalendarLines.length > 0) {
+            const timerContent = `[Unit]
+Description=Timer for Palmier Task: ${taskId}
+
+[Timer]
+${onCalendarLines.join("\n")}
+Persistent=true
+
+[Install]
+WantedBy=timers.target
+`;
+            fs.writeFileSync(path.join(UNIT_DIR, timerName), timerContent, "utf-8");
+            daemonReload();
+            try {
+                execSync(`systemctl --user enable --now ${timerName}`, { encoding: "utf-8" });
+            }
+            catch (err) {
+                const e = err;
+                console.error(`Failed to enable timer ${timerName}: ${e.stderr || err}`);
+            }
+        }
+    }
+    removeTaskTimer(taskId) {
+        const timerName = getTimerName(taskId);
+        const serviceName = getServiceName(taskId);
+        const timerPath = path.join(UNIT_DIR, timerName);
+        const servicePath = path.join(UNIT_DIR, serviceName);
+        if (fs.existsSync(timerPath)) {
+            try {
+                execSync(`systemctl --user stop ${timerName}`, { encoding: "utf-8" });
+            }
+            catch { /* timer might not be running */ }
+            try {
+                execSync(`systemctl --user disable ${timerName}`, { encoding: "utf-8" });
+            }
+            catch { /* timer might not be enabled */ }
+            fs.unlinkSync(timerPath);
+        }
+        if (fs.existsSync(servicePath))
+            fs.unlinkSync(servicePath);
+        daemonReload();
+    }
+    async startTask(taskId) {
+        const serviceName = getServiceName(taskId);
+        await execAsync(`systemctl --user start --no-block ${serviceName}`);
+    }
+    async stopTask(taskId) {
+        const serviceName = getServiceName(taskId);
+        await execAsync(`systemctl --user stop ${serviceName}`);
+    }
+    isTaskRunning(taskId) {
+        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() {
+        const uid = process.getuid?.();
+        const runtimeDir = process.env.XDG_RUNTIME_DIR ||
+            (uid !== undefined ? `/run/user/${uid}` : "");
+        return {
+            DISPLAY: ":0",
+            ...(runtimeDir ? { XDG_RUNTIME_DIR: runtimeDir } : {}),
+        };
+    }
+}
+//# sourceMappingURL=linux.js.map

package/dist/platform/platform.d.ts

@@ -0,0 +1,24 @@
+import type { HostConfig, ParsedTask } from "../types.js";
+/**
+ * Abstracts OS-specific daemon, scheduling, and process management.
+ * Linux uses systemd; Windows uses Task Scheduler; macOS will use launchd.
+ */
+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;
+    /** Remove a task's scheduled trigger and service files. */
+    removeTaskTimer(taskId: string): void;
+    /** Start a task execution (non-blocking). */
+    startTask(taskId: string): Promise<void>;
+    /** 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>;
+}
+//# sourceMappingURL=platform.d.ts.map

package/dist/platform/platform.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=platform.js.map

package/dist/platform/windows.d.ts

@@ -0,0 +1,14 @@
+import type { PlatformService } from "./platform.js";
+import type { HostConfig, ParsedTask } from "../types.js";
+export declare class WindowsPlatform implements PlatformService {
+    installDaemon(config: HostConfig): void;
+    restartDaemon(): Promise<void>;
+    private spawnDaemon;
+    installTaskTimer(config: HostConfig, task: ParsedTask): void;
+    removeTaskTimer(taskId: string): void;
+    startTask(taskId: string): Promise<void>;
+    stopTask(taskId: string): Promise<void>;
+    isTaskRunning(taskId: string): boolean;
+    getGuiEnv(): Record<string, string>;
+}
+//# sourceMappingURL=windows.d.ts.map