palmier 0.1.8 → 0.2.0

package/dist/commands/serve.js

@@ -1,11 +1,20 @@
 import { randomUUID } from "crypto";
-import { execSync } from "child_process";
+import { execSync, exec } from "child_process";
+import { promisify } from "util";
+const execAsync = promisify(exec);
 import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
 import { StringCodec } from "nats";
 import { loadConfig } from "../config.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+function shellEscape(arg) {
+    return "'" + arg.replace(/'/g, "'\\''") + "'";
+}
+const TASK_GENERATION_PROMPT = fs.readFileSync(path.join(__dirname, "task-generation.md"), "utf-8");
 import { connectNats } from "../nats-client.js";
 import { listTasks, parseTaskFile, writeTaskFile, getTaskDir } from "../task.js";
-import { installTaskTimer, removeTaskTimer, getTaskStatus } from "../systemd.js";
+import { installTaskTimer, removeTaskTimer } from "../systemd.js";
 /**
  * Start the persistent NATS RPC handler.
  */
@@ -25,10 +34,10 @@ export async function serveCommand() {
     };
     process.on("SIGINT", shutdown);
     process.on("SIGTERM", shutdown);
-    // On startup, clean up orphaned pending-hooks keys for this agent
+    // On startup, clean up orphaned pending-confirmation keys for this agent
     try {
         const js = nc.jetstream();
-        const kv = await js.views.kv("pending-hooks");
+        const kv = await js.views.kv("pending-confirmation");
         const keys = await kv.keys();
         for await (const key of keys) {
             if (key.startsWith(`${config.agentId}.`)) {
@@ -38,7 +47,7 @@ export async function serveCommand() {
         }
     }
     catch (err) {
-        console.error(`Warning: could not clean up pending-hooks KV: ${err}`);
+        console.error(`Warning: could not clean up pending-confirmation KV: ${err}`);
     }
     console.log("Agent serving. Waiting for RPC messages...");
     for await (const msg of sub) {
@@ -72,19 +81,20 @@ export async function serveCommand() {
             console.error(`RPC error (${method}):`, err);
             response = { error: String(err) };
         }
+        console.log(`RPC done: ${method}`, JSON.stringify(response).slice(0, 200));
         if (msg.reply) {
             msg.respond(sc.encode(JSON.stringify(response)));
         }
     }
-    function flattenTask(task, status) {
-        return { ...task.frontmatter, body: task.body, ...(status != null ? { status } : {}) };
+    function flattenTask(task) {
+        return { ...task.frontmatter, body: task.body };
     }
     async function handleRpc(request) {
         switch (request.method) {
             case "task.list": {
                 const tasks = listTasks(config.projectRoot);
                 return {
-                    tasks: tasks.map((task) => flattenTask(task, getTaskStatus(task.frontmatter.id))),
+                    tasks: tasks.map((task) => flattenTask(task)),
                 };
             }
             case "task.create": {
@@ -94,17 +104,18 @@ export async function serveCommand() {
                 const task = {
                     frontmatter: {
                         id,
-                        name: params.name,
                         user_prompt: params.user_prompt,
+                        command_line: params.command_line ?? "claude -p --dangerously-skip-permissions",
                         triggers: params.triggers ?? [],
+                        triggers_enabled: params.triggers_enabled ?? true,
                         requires_confirmation: params.requires_confirmation ?? true,
-                        suppress_permissions: params.suppress_permissions ?? false,
-                        enabled: params.enabled ?? true,
                     },
                     body: params.body || "",
                 };
                 writeTaskFile(taskDir, task);
-                installTaskTimer(config, task);
+                if (task.frontmatter.triggers_enabled) {
+                    installTaskTimer(config, task);
+                }
                 return flattenTask(task);
             }
             case "task.update": {
@@ -112,25 +123,25 @@ export async function serveCommand() {
                 const taskDir = getTaskDir(config.projectRoot, params.id);
                 const existing = parseTaskFile(taskDir);
                 // Merge updates
-                if (params.name !== undefined)
-                    existing.frontmatter.name = params.name;
                 if (params.user_prompt !== undefined)
                     existing.frontmatter.user_prompt = params.user_prompt;
+                if (params.command_line !== undefined)
+                    existing.frontmatter.command_line = params.command_line;
                 if (params.triggers !== undefined)
                     existing.frontmatter.triggers = params.triggers;
+                if (params.triggers_enabled !== undefined)
+                    existing.frontmatter.triggers_enabled = params.triggers_enabled;
                 if (params.requires_confirmation !== undefined)
                     existing.frontmatter.requires_confirmation = params.requires_confirmation;
-                if (params.suppress_permissions !== undefined)
-                    existing.frontmatter.suppress_permissions = params.suppress_permissions;
-                if (params.enabled !== undefined)
-                    existing.frontmatter.enabled = params.enabled;
                 if (params.body !== undefined)
                     existing.body = params.body;
                 writeTaskFile(taskDir, existing);
-                // Reinstall timer with updated config
+                // Reinstall or remove timers based on triggers_enabled
                 removeTaskTimer(params.id);
-                installTaskTimer(config, existing);
-                return flattenTask(existing, getTaskStatus(params.id));
+                if (existing.frontmatter.triggers_enabled) {
+                    installTaskTimer(config, existing);
+                }
+                return flattenTask(existing);
             }
             case "task.delete": {
                 const params = request.params;
@@ -144,8 +155,10 @@ export async function serveCommand() {
             }
             case "task.generate": {
                 const params = request.params;
+                const commandLine = params.command_line || "claude -p --dangerously-skip-permissions";
+                const fullPrompt = TASK_GENERATION_PROMPT + params.prompt;
                 try {
-                    const output = execSync(`claude -p "${params.prompt.replace(/"/g, '\\"')}"`, {
+                    const output = execSync(`${commandLine} ${shellEscape(fullPrompt)}`, {
                         encoding: "utf-8",
                         cwd: config.projectRoot,
                         timeout: 120_000,
@@ -154,24 +167,34 @@ export async function serveCommand() {
                 }
                 catch (err) {
                     const error = err;
-                    return { error: "claude command failed", stdout: error.stdout, stderr: error.stderr };
+                    return { error: "generation command failed", stdout: error.stdout, stderr: error.stderr };
                 }
             }
             case "task.run": {
                 const params = request.params;
                 const serviceName = `palmier-task-${params.id}.service`;
                 try {
-                    execSync(`systemctl --user start ${serviceName}`, { stdio: "inherit" });
+                    await execAsync(`systemctl --user start --no-block ${serviceName}`);
                     return { ok: true, task_id: params.id };
                 }
                 catch (err) {
-                    return { error: `Failed to start task service: ${err}` };
+                    const e = err;
+                    console.error(`task.run failed for ${params.id}: ${e.stderr || e.message}`);
+                    return { error: `Failed to start task: ${e.stderr || e.message}` };
                 }
             }
-            case "task.status": {
+            case "task.abort": {
                 const params = request.params;
-                const status = getTaskStatus(params.id);
-                return { task_id: params.id, status };
+                const serviceName = `palmier-task-${params.id}.service`;
+                try {
+                    await execAsync(`systemctl --user stop ${serviceName}`);
+                    return { ok: true, task_id: params.id };
+                }
+                catch (err) {
+                    const e = err;
+                    console.error(`task.abort failed for ${params.id}: ${e.stderr || e.message}`);
+                    return { error: `Failed to abort task: ${e.stderr || e.message}` };
+                }
             }
             case "task.logs": {
                 const params = request.params;
@@ -185,6 +208,28 @@ export async function serveCommand() {
                     return { task_id: params.id, logs: error.stdout || "", error: error.stderr };
                 }
             }
+            case "task.result": {
+                const params = request.params;
+                const resultPath = path.join(config.projectRoot, "tasks", params.id, "RESULT.md");
+                try {
+                    const raw = fs.readFileSync(resultPath, "utf-8");
+                    // Parse optional frontmatter
+                    const fmMatch = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+                    if (fmMatch) {
+                        const meta = {};
+                        for (const line of fmMatch[1].split("\n")) {
+                            const [key, val] = line.split(": ");
+                            if (key && val)
+                                meta[key.trim()] = Number(val.trim());
+                        }
+                        return { task_id: params.id, content: fmMatch[2], start_time: meta.start_time, end_time: meta.end_time };
+                    }
+                    return { task_id: params.id, content: raw };
+                }
+                catch {
+                    return { task_id: params.id, error: "No result file found" };
+                }
+            }
             default:
                 return { error: `Unknown method: ${request.method}` };
         }

package/dist/commands/task-generation.md

@@ -0,0 +1,28 @@
+You are a planning agent for a personal computer AI agent. Given a task description, produce a detailed Markdown execution plan that the agent can later follow step by step. **Do not execute any part of the task yourself.**
+
+The plan must include the following sections:
+
+### 1. Goal
+What the task accomplishes and the expected end state.
+
+### 2. Prerequisites
+What must be true before starting:
+- Required software and versions
+- Files or data that must be present
+- Permissions or access needed
+- Environment state (e.g., running services, network access)
+
+### 3. Plan
+A numbered sequence of concrete, actionable steps to complete the task.
+Use sub-steps for complex actions. Include conditional branches where behavior may vary (e.g., "If file exists, do A; otherwise, do B"). Each step should be specific enough that the agent can execute it without ambiguity.
+
+### 4. Edge Cases & Risks
+Anything that could go wrong and how to handle it:
+- Common failure modes
+- Platform-specific differences
+- Race conditions or timing issues
+- Data loss risks and mitigation
+
+Format the entire document as Markdown with proper headings, code blocks for commands, and tables where appropriate.
+
+**Task description:**

package/dist/index.js

@@ -6,7 +6,6 @@ import { dirname, join } from "path";
 import { Command } from "commander";
 import { initCommand } from "./commands/init.js";
 import { runCommand } from "./commands/run.js";
-import { hookCommand } from "./commands/hook.js";
 import { serveCommand } from "./commands/serve.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(join(__dirname, "../package.json"), "utf-8"));
@@ -28,12 +27,6 @@ program
     .action(async (taskId) => {
     await runCommand(taskId);
 });
-program
-    .command("hook")
-    .description("Handle a Claude Code hook event (reads from stdin)")
-    .action(async () => {
-    await hookCommand();
-});
 program
     .command("serve", { isDefault: true })
     .description("Start the persistent NATS RPC handler")

package/dist/systemd.d.ts

@@ -1,5 +1,5 @@
 import type { AgentConfig } from "./types.js";
-import type { ParsedTask, TaskStatus } from "./types.js";
+import type { ParsedTask } from "./types.js";
 /**
  * Convert a cron expression (5-field) to a systemd OnCalendar string.
  * Handles basic cron patterns: minute hour day-of-month month day-of-week
@@ -13,10 +13,6 @@ export declare function installTaskTimer(config: AgentConfig, task: ParsedTask):
  * Remove a task's systemd timer and service files.
  */
 export declare function removeTaskTimer(taskId: string): void;
-/**
- * Query systemd for task status information.
- */
-export declare function getTaskStatus(taskId: string): TaskStatus;
 /**
  * Run systemctl --user daemon-reload.
  */

package/dist/systemd.js

@@ -57,46 +57,49 @@ export function installTaskTimer(config, task) {
     // Determine the palmier binary path
     const palmierBin = process.argv[1] || "palmier";
     // Generate service unit
-    const serviceContent = `[Unit]
-Description=Palmier Task: ${task.frontmatter.name || taskId}
-
-[Service]
-Type=oneshot
-ExecStart=${palmierBin} run ${taskId}
-WorkingDirectory=${config.projectRoot}
-Environment=PATH=${process.env.PATH || "/usr/local/bin:/usr/bin:/bin"}
+    const serviceContent = `[Unit]
+Description=Palmier Task: ${taskId}
+
+[Service]
+Type=oneshot
+ExecStart=${palmierBin} run ${taskId}
+WorkingDirectory=${config.projectRoot}
+Environment=PATH=${process.env.PATH || "/usr/local/bin:/usr/bin:/bin"}
 `;
-    // Generate timer unit with OnCalendar entries for each cron trigger
+    // Write service unit (always needed for on-demand runs)
+    fs.writeFileSync(path.join(UNIT_DIR, serviceName), serviceContent, "utf-8");
+    daemonReload();
+    // Only create and enable a timer if there are actual triggers
+    const triggers = task.frontmatter.triggers || [];
     const onCalendarLines = [];
-    for (const trigger of task.frontmatter.triggers || []) {
+    for (const trigger of triggers) {
         if (trigger.type === "cron") {
             onCalendarLines.push(`OnCalendar=${cronToOnCalendar(trigger.value)}`);
         }
         else if (trigger.type === "once") {
-            // "once" triggers use OnActiveSec or a specific timestamp
             onCalendarLines.push(`OnActiveSec=${trigger.value}`);
         }
     }
-    const timerContent = `[Unit]
-Description=Timer for Palmier Task: ${task.frontmatter.name || taskId}
-
-[Timer]
-${onCalendarLines.join("\n")}
-Persistent=true
-
-[Install]
-WantedBy=timers.target
+    if (onCalendarLines.length > 0) {
+        const timerContent = `[Unit]
+Description=Timer for Palmier Task: ${taskId}
+
+[Timer]
+${onCalendarLines.join("\n")}
+Persistent=true
+
+[Install]
+WantedBy=timers.target
 `;
-    // Write unit files
-    fs.writeFileSync(path.join(UNIT_DIR, serviceName), serviceContent, "utf-8");
-    fs.writeFileSync(path.join(UNIT_DIR, timerName), timerContent, "utf-8");
-    // Reload and enable
-    daemonReload();
-    if (task.frontmatter.enabled) {
-        execSync(`systemctl --user enable --now ${timerName}`, { stdio: "inherit" });
-    }
-    else {
-        execSync(`systemctl --user enable ${timerName}`, { stdio: "inherit" });
+        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}`);
+        }
     }
 }
 /**
@@ -105,101 +108,38 @@ WantedBy=timers.target
 export function removeTaskTimer(taskId) {
     const timerName = getTimerName(taskId);
     const serviceName = getServiceName(taskId);
-    // Stop and disable
-    try {
-        execSync(`systemctl --user stop ${timerName}`, { stdio: "inherit" });
-    }
-    catch {
-        // Timer might not be running
-    }
-    try {
-        execSync(`systemctl --user disable ${timerName}`, { stdio: "inherit" });
-    }
-    catch {
-        // Timer might not be enabled
-    }
-    // Remove unit files
     const timerPath = path.join(UNIT_DIR, timerName);
     const servicePath = path.join(UNIT_DIR, serviceName);
-    if (fs.existsSync(timerPath))
-        fs.unlinkSync(timerPath);
-    if (fs.existsSync(servicePath))
-        fs.unlinkSync(servicePath);
-    daemonReload();
-}
-/**
- * Query systemd for task status information.
- */
-export function getTaskStatus(taskId) {
-    const timerName = getTimerName(taskId);
-    const serviceName = getServiceName(taskId);
-    let state = "inactive";
-    let lastRun;
-    let lastResult;
-    let nextRun;
-    // Check if timer is active
-    try {
-        const activeState = execSync(`systemctl --user is-active ${timerName}`, {
-            encoding: "utf-8",
-        }).trim();
-        if (activeState === "active") {
-            state = "active";
+    // Only stop/disable the timer if the file exists
+    if (fs.existsSync(timerPath)) {
+        try {
+            execSync(`systemctl --user stop ${timerName}`, { encoding: "utf-8" });
         }
-    }
-    catch {
-        // Not active
-    }
-    // Check if service has failed
-    try {
-        const serviceState = execSync(`systemctl --user is-failed ${serviceName}`, {
-            encoding: "utf-8",
-        }).trim();
-        if (serviceState === "failed") {
-            state = "failed";
+        catch {
+            // Timer might not be running
         }
-    }
-    catch {
-        // Not failed
-    }
-    // Get last run time and result
-    try {
-        const props = execSync(`systemctl --user show ${serviceName} --property=ExecMainStartTimestamp,ExecMainStatus`, { encoding: "utf-8" });
-        for (const line of props.split("\n")) {
-            if (line.startsWith("ExecMainStartTimestamp=") && line.trim() !== "ExecMainStartTimestamp=") {
-                const val = line.split("=", 2)[1].trim();
-                if (val)
-                    lastRun = val;
-            }
-            if (line.startsWith("ExecMainStatus=")) {
-                const val = parseInt(line.split("=", 2)[1].trim(), 10);
-                if (!isNaN(val))
-                    lastResult = val;
-            }
+        try {
+            execSync(`systemctl --user disable ${timerName}`, { encoding: "utf-8" });
         }
-    }
-    catch {
-        // Couldn't get properties
-    }
-    // Get next run time from timer
-    try {
-        const timerProps = execSync(`systemctl --user show ${timerName} --property=NextElapseUSecRealtime`, { encoding: "utf-8" });
-        for (const line of timerProps.split("\n")) {
-            if (line.startsWith("NextElapseUSecRealtime=")) {
-                const val = line.split("=", 2)[1].trim();
-                if (val)
-                    nextRun = val;
-            }
+        catch {
+            // Timer might not be enabled
         }
+        fs.unlinkSync(timerPath);
     }
-    catch {
-        // Couldn't get next run
-    }
-    return { state, lastRun, lastResult, nextRun };
+    if (fs.existsSync(servicePath))
+        fs.unlinkSync(servicePath);
+    daemonReload();
 }
 /**
  * Run systemctl --user daemon-reload.
  */
 export function daemonReload() {
-    execSync("systemctl --user daemon-reload", { stdio: "inherit" });
+    try {
+        execSync("systemctl --user daemon-reload", { encoding: "utf-8" });
+    }
+    catch (err) {
+        const e = err;
+        console.error(`daemon-reload failed: ${e.stderr || err}`);
+    }
 }
 //# sourceMappingURL=systemd.js.map

package/dist/task.js

@@ -26,6 +26,8 @@ function parseTaskContent(content) {
     if (!frontmatter.id) {
         throw new Error("TASK.md frontmatter must include at least: id");
     }
+    frontmatter.command_line ??= "claude -p --dangerously-skip-permissions";
+    frontmatter.triggers_enabled ??= true;
     return { frontmatter, body };
 }
 /**

package/dist/types.d.ts

@@ -8,12 +8,11 @@ export interface AgentConfig {
 }
 export interface TaskFrontmatter {
     id: string;
-    name: string;
     user_prompt: string;
+    command_line: string;
     triggers: Trigger[];
+    triggers_enabled: boolean;
     requires_confirmation: boolean;
-    suppress_permissions: boolean;
-    enabled: boolean;
 }
 export interface Trigger {
     type: "cron" | "once";
@@ -23,31 +22,13 @@ export interface ParsedTask {
     frontmatter: TaskFrontmatter;
     body: string;
 }
-export interface TaskStatus {
-    state: "active" | "inactive" | "failed";
-    lastRun?: string;
-    lastResult?: number;
-    nextRun?: string;
-}
-export interface TaskWithStatus extends ParsedTask {
-    status: TaskStatus;
-}
-export interface HookPayload {
-    type: "confirm" | "permission" | "input";
+export interface ConfirmPayload {
+    type: "confirm";
     task_id: string;
-    hook_id: string;
     agent_id: string;
     user_id: string;
     details: Record<string, unknown>;
-    status: string;
-}
-export interface ClaudeHookEvent {
-    hook_name: string;
-    session_id: string;
-    tool_name?: string;
-    tool_input?: Record<string, unknown>;
-    message?: string;
-    [key: string]: unknown;
+    status: "pending" | "confirmed" | "aborted";
 }
 export interface RpcMessage {
     method: string;

package/package.json

@@ -1,35 +1,33 @@
-{
-  "name": "palmier",
-  "version": "0.1.8",
-  "description": "Palmier agent CLI - provisions, executes tasks, and serves NATS RPC",
-  "license": "ISC",
-  "author": "Hongxu Cai",
-  "type": "module",
-  "main": "dist/index.js",
-  "types": "./dist/index.d.ts",
-  "bin": {
-    "palmier": "dist/index.js"
-  },
-  "scripts": {
-    "dev": "tsx src/index.ts",
-    "build": "tsc",
-    "start": "node dist/index.js"
-  },
-  "dependencies": {
-    "commander": "^13.1.0",
-    "dotenv": "^16.4.7",
-    "nats": "^2.29.1",
-    "node-pty": "^1.0.0",
-    "uuid": "^11.1.0",
-    "yaml": "^2.7.0"
-  },
-  "devDependencies": {
-    "@types/node": "^22.13.0",
-    "@types/uuid": "^10.0.0",
-    "tsx": "^4.19.0",
-    "typescript": "^5.7.0"
-  },
-  "engines": {
-    "node": ">=20.0.0"
-  }
-}
+{
+  "name": "palmier",
+  "version": "0.2.0",
+  "description": "Palmier agent CLI - provisions, executes tasks, and serves NATS RPC",
+  "license": "ISC",
+  "author": "Hongxu Cai",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "palmier": "dist/index.js"
+  },
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "build": "tsc && node -e \"require('fs').cpSync('src/commands/task-generation.md','dist/commands/task-generation.md')\"",
+    "prepare": "npm run build",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "commander": "^13.1.0",
+    "dotenv": "^16.4.7",
+    "nats": "^2.29.1",
+    "yaml": "^2.7.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}