palmier 0.1.9 → 0.2.0

package/CLAUDE.md

@@ -0,0 +1,5 @@
+# CLAUDE.md
+
+## Getting Started
+
+Always read `spec.md` and `README.md` first before starting any task. These files contain the project specification and setup instructions that should inform all work.

package/README.md

@@ -21,7 +21,6 @@ npm install -g palmier
 | `palmier init --token <token>` | Provision the agent with a token from the dashboard |
 | `palmier serve` | Run the persistent NATS RPC handler (default command) |
 | `palmier run <task-id>` | Execute a specific task |
-| `palmier hook` | Handle Claude Code hook events (invoked by Claude Code, not manually) |
 
 ## Setup
 
@@ -33,7 +32,6 @@ npm install -g palmier
 The `init` command:
 - Saves agent configuration to `~/.config/palmier/agent.json`
 - Installs a systemd user service for the agent
-- Configures Claude Code hooks for remote interaction
 
 ### Verifying the Service
 
@@ -66,9 +64,12 @@ cat ~/.config/palmier/agent.json
 - The persistent process (`palmier serve`) is a NATS RPC handler. It derives the RPC method from the NATS subject (e.g., `...rpc.task.create` → `task.create`) and treats the message body as request parameters.
 - **Task IDs** are generated by the agent as UUIDs.
 - All RPC responses (`task.list`, `task.create`, `task.update`) return **flat task objects** — frontmatter fields at the top level, not nested under a `frontmatter` key.
+- Tasks have no separate name field — the `user_prompt` is the primary identifier and display label.
+- Plan generation is optional — if no plan body is present, the agent uses only `user_prompt` as the prompt.
+- **Triggers can be enabled/disabled** via the `triggers_enabled` frontmatter field (default `true`). When disabled, systemd timers are removed; when re-enabled, they are reinstalled. Tasks can still be run manually regardless.
 - Incoming tasks are stored as `TASK.md` files in a local `tasks/` directory.
-- Task execution spawns **Claude Code in a PTY**, giving the AI full CLI access within the project.
-- **Hooks** intercept Claude Code permission, confirmation, and input prompts, resolving them remotely via NATS KV so tasks can run unattended.
+- Task execution spawns **Claude Code as a background process** with `-p --dangerously-skip-permissions`, running non-interactively. Task lifecycle events (`start`, `finish`, `abort`, `fail`) are tracked via a NATS JetStream KV bucket (`task-event`), keyed by `<agent_id>.<task_id>`.
+- **Task confirmation** — tasks with `requires_confirmation: true` write a pending entry to the `pending-confirmation` KV bucket before execution. The Web Server and PWA watch this bucket to show confirmation prompts. The task waits until the user confirms or aborts via the PWA or push notification.
 
 ## Project Structure
 
@@ -84,9 +85,54 @@ src/
     init.ts           # Provisioning logic
     serve.ts          # Persistent NATS RPC handler
     run.ts            # Single task execution
-    hook.ts           # Claude Code hook handler
 ```
 
+## Removing an Agent
+
+To fully remove an agent from a machine:
+
+1. **Delete the agent from the PWA dashboard** (this removes it from the server database).
+
+2. **Stop and remove the systemd service:**
+
+   ```bash
+   systemctl --user stop palmier-agent.service
+   systemctl --user disable palmier-agent.service
+   rm ~/.config/systemd/user/palmier-agent.service
+   ```
+
+3. **Remove any task timers and services:**
+
+   ```bash
+   systemctl --user stop palmier-task-*.timer palmier-task-*.service 2>/dev/null
+   systemctl --user disable palmier-task-*.timer 2>/dev/null
+   rm -f ~/.config/systemd/user/palmier-task-*.timer ~/.config/systemd/user/palmier-task-*.service
+   ```
+
+4. **Reload systemd:**
+
+   ```bash
+   systemctl --user daemon-reload
+   ```
+
+5. **Remove the agent configuration:**
+
+   ```bash
+   rm -rf ~/.config/palmier
+   ```
+
+6. **Remove the tasks directory** from your project root:
+
+   ```bash
+   rm -rf tasks/
+   ```
+
+7. *(Optional)* **Disable login lingering** if no other user services need it:
+
+   ```bash
+   loginctl disable-linger
+   ```
+
 ## Related
 
 See the [palmier](../palmier) repo for the server, API, and PWA.

package/dist/commands/hook.js

@@ -1,7 +1,12 @@
 import { v4 as uuidv4 } from "uuid";
 import { StringCodec } from "nats";
+import { appendFileSync } from "fs";
 import { loadConfig } from "../config.js";
 import { connectNats } from "../nats-client.js";
+function log(msg) {
+    const line = `[${new Date().toISOString()}] ${msg}\n`;
+    appendFileSync("/tmp/palmier-hook.log", line);
+}
 /**
  * Handle a Claude Code hook invocation.
  * Called by Claude Code as a subprocess. Reads hook event from stdin,
@@ -17,9 +22,10 @@ export async function hookCommand() {
         console.error("Failed to parse hook event from stdin");
         process.exit(1);
     }
+    log(`received: ${JSON.stringify(event).slice(0, 500)}`);
     const taskId = process.env.PALMIER_TASK_ID;
     if (!taskId) {
-        // Not running in a palmier task context, exit silently
+        log("no PALMIER_TASK_ID, exiting");
         return;
     }
     const config = loadConfig();
@@ -28,7 +34,7 @@ export async function hookCommand() {
     try {
         const js = nc.jetstream();
         const kv = await js.views.kv("pending-hooks");
-        switch (event.hook_name) {
+        switch (event.hook_event_name) {
             case "PermissionRequest":
                 await handlePermissionRequest(config, nc, kv, sc, event, taskId);
                 break;
@@ -47,6 +53,14 @@ export async function hookCommand() {
         await nc.drain();
     }
 }
+function permissionResponse(behavior) {
+    return {
+        hookSpecificOutput: {
+            hookEventName: "PermissionRequest",
+            decision: { behavior },
+        },
+    };
+}
 async function handlePermissionRequest(config, nc, kv, sc, event, taskId) {
     const hookId = uuidv4();
     const kvKey = `${config.agentId}.${taskId}.${hookId}`;
@@ -65,6 +79,7 @@ async function handlePermissionRequest(config, nc, kv, sc, event, taskId) {
         },
         status: "pending",
     };
+    log(`permission: putting KV key=${kvKey} payload=${JSON.stringify(payload)}`);
     await kv.put(kvKey, sc.encode(JSON.stringify(payload)));
     // Publish push notification
     nc.publish(`user.${config.userId}.push.request.permission`, sc.encode(JSON.stringify({
@@ -77,20 +92,27 @@ async function handlePermissionRequest(config, nc, kv, sc, event, taskId) {
     })));
     // Wait for status change
     for await (const entry of watch) {
+        log(`permission: watch event op=${entry.operation} key=${entry.key}`);
         if (entry.operation === "DEL" || entry.operation === "PURGE") {
             // Key deleted, deny by default
-            process.stdout.write(JSON.stringify({ behavior: "deny" }));
+            log(`permission: key deleted/purged, denying`);
+            process.stdout.write(JSON.stringify(permissionResponse("deny")));
             return;
         }
         try {
             const updated = JSON.parse(sc.decode(entry.value));
+            log(`permission: KV update status=${updated.status} payload=${JSON.stringify(updated)}`);
             if (updated.status === "confirmed" || updated.status === "allowed") {
-                process.stdout.write(JSON.stringify({ behavior: "allow" }));
+                const out = JSON.stringify(permissionResponse("allow"));
+                log(`permission: allowing, stdout=${out}`);
+                process.stdout.write(out);
                 await kv.delete(kvKey);
                 return;
             }
             else if (updated.status === "denied" || updated.status === "aborted") {
-                process.stdout.write(JSON.stringify({ behavior: "deny" }));
+                const out = JSON.stringify(permissionResponse("deny"));
+                log(`permission: denying, stdout=${out}`);
+                process.stdout.write(out);
                 await kv.delete(kvKey);
                 return;
             }
@@ -134,6 +156,7 @@ async function handleNotification(config, nc, kv, sc, event, taskId) {
         },
         status: "pending",
     };
+    log(`input: putting KV key=${kvKey} payload=${JSON.stringify(payload)}`);
     await kv.put(kvKey, sc.encode(JSON.stringify(payload)));
     // Publish push notification
     nc.publish(`user.${config.userId}.push.notify.input_needed`, sc.encode(JSON.stringify({
@@ -145,13 +168,17 @@ async function handleNotification(config, nc, kv, sc, event, taskId) {
     })));
     // Wait for status change - the status field will contain the user's input text
     for await (const entry of watch) {
+        log(`input: watch event op=${entry.operation} key=${entry.key}`);
         if (entry.operation === "DEL" || entry.operation === "PURGE") {
+            log(`input: key deleted/purged`);
             return;
         }
         try {
             const updated = JSON.parse(sc.decode(entry.value));
+            log(`input: KV update status=${updated.status} payload=${JSON.stringify(updated)}`);
             if (updated.status !== "pending") {
                 // The status field contains the user's input text
+                log(`input: resolved with user input`);
                 process.stdout.write(updated.status);
                 await kv.delete(kvKey);
                 return;

package/dist/commands/init.js

@@ -53,38 +53,25 @@ export async function initCommand(options) {
     saveConfig(config);
     console.log(`Agent provisioned. ID: ${config.agentId}`);
     console.log("Config saved to ~/.config/palmier/agent.json");
-    // 4. Write Claude Code hooks config
-    const claudeSettingsDir = path.join(process.cwd(), ".claude");
-    fs.mkdirSync(claudeSettingsDir, { recursive: true });
-    const hookEntry = { hooks: [{ type: "command", command: "palmier hook" }] };
-    const hooksConfig = {
-        hooks: {
-            PermissionRequest: [hookEntry],
-            Notification: [hookEntry],
-            Stop: [hookEntry],
-        },
-    };
-    fs.writeFileSync(path.join(claudeSettingsDir, "settings.json"), JSON.stringify(hooksConfig, null, 2), "utf-8");
-    console.log("Claude Code hooks config written to .claude/settings.json");
-    // 5. Install systemd user service for palmier serve
+    // 4. Install systemd user service for palmier serve
     const unitDir = path.join(homedir(), ".config", "systemd", "user");
     fs.mkdirSync(unitDir, { recursive: true });
     const palmierBin = process.argv[1] || "palmier";
-    const serviceContent = `[Unit]
-Description=Palmier Agent
-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 serviceContent = `[Unit]
+Description=Palmier Agent
+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(unitDir, "palmier-agent.service");
     fs.writeFileSync(servicePath, serviceContent, "utf-8");

package/dist/commands/run.d.ts

@@ -1,3 +1,4 @@
+export type TaskEventType = "start" | "finish" | "abort" | "fail";
 /**
  * Execute a task by ID.
  */

package/dist/commands/run.js

@@ -1,4 +1,6 @@
-import { v4 as uuidv4 } from "uuid";
+import * as fs from "fs";
+import * as path from "path";
+import { spawn } from "child_process";
 import { loadConfig } from "../config.js";
 import { connectNats } from "../nats-client.js";
 import { parseTaskFile, getTaskDir } from "../task.js";
@@ -10,21 +12,16 @@ export async function runCommand(taskId) {
     const config = loadConfig();
     const taskDir = getTaskDir(config.projectRoot, taskId);
     const task = parseTaskFile(taskDir);
-    console.log(`Running task: ${task.frontmatter.name || taskId}`);
+    console.log(`Running task: ${taskId}`);
     let nc;
-    let kv;
-    // Track KV keys we create so we can clean them up
-    const kvKeysToClean = [];
+    let confirmKv;
+    const confirmKey = `${config.agentId}.${taskId}`;
     const cleanup = async () => {
-        if (kv) {
-            for (const key of kvKeysToClean) {
-                try {
-                    await kv.delete(key);
-                }
-                catch {
-                    // Ignore cleanup errors
-                }
+        if (confirmKv) {
+            try {
+                await confirmKv.delete(confirmKey);
             }
+            catch { /* may not exist */ }
         }
         if (nc && !nc.isClosed()) {
             await nc.drain();
@@ -33,84 +30,90 @@ export async function runCommand(taskId) {
     // Handle signals
     const onSignal = async () => {
         console.log("Received signal, cleaning up...");
+        if (eventKv) {
+            await writeTaskEvent(eventKv, `${config.agentId}.${taskId}`, "abort").catch(() => { });
+        }
         await cleanup();
         process.exit(1);
     };
     process.on("SIGINT", onSignal);
     process.on("SIGTERM", onSignal);
+    let eventKv;
     try {
+        nc = await connectNats(config);
+        const js = nc.jetstream();
+        // Set up task-event KV and mark as started immediately
+        eventKv = await js.views.kv("task-event", { history: 1 });
+        const eventKey = `${config.agentId}.${taskId}`;
+        await writeTaskEvent(eventKv, eventKey, "start");
         // If requires_confirmation, ask user via NATS KV
         if (task.frontmatter.requires_confirmation) {
-            nc = await connectNats(config);
-            const js = nc.jetstream();
-            kv = await js.views.kv("pending-hooks");
-            const confirmed = await requestConfirmation(config, task, kv, nc, kvKeysToClean);
+            confirmKv = await js.views.kv("pending-confirmation");
+            const confirmed = await requestConfirmation(config, task, confirmKv);
             if (!confirmed) {
                 console.log("Task aborted by user.");
+                await writeTaskEvent(eventKv, eventKey, "abort");
                 await cleanup();
                 return;
             }
             console.log("Task confirmed by user.");
         }
-        // Spawn Claude CLI via node-pty
-        await spawnClaude(config, task, taskId);
+        // Spawn task process
+        const startTime = Date.now();
+        const output = await spawnTask(config, task);
+        const endTime = Date.now();
+        // Save result with frontmatter to task directory
+        const resultPath = path.join(taskDir, "RESULT.md");
+        const resultContent = `---\nstart_time: ${startTime}\nend_time: ${endTime}\n---\n${output}`;
+        fs.writeFileSync(resultPath, resultContent, "utf-8");
+        // Set event to finish on completion
+        await writeTaskEvent(eventKv, eventKey, "finish");
         console.log(`Task ${taskId} completed.`);
     }
     catch (err) {
         console.error(`Task ${taskId} failed:`, err);
+        if (eventKv) {
+            await writeTaskEvent(eventKv, `${config.agentId}.${taskId}`, "fail").catch(() => { });
+        }
         process.exitCode = 1;
     }
     finally {
         await cleanup();
     }
 }
-async function requestConfirmation(config, task, kv, nc, kvKeysToClean) {
-    const sc = StringCodec();
-    const hookId = uuidv4();
-    const kvKey = `${config.agentId}.${task.frontmatter.id}.${hookId}`;
-    kvKeysToClean.push(kvKey);
-    // Start watching BEFORE writing, to avoid race condition
-    const watch = await kv.watch({ key: kvKey });
-    // Write hook payload to KV
+const sc = StringCodec();
+async function writeTaskEvent(kv, key, eventType) {
+    const event = { event_type: eventType, time_stamp: Date.now() };
+    console.log(`[task-event] ${key} → ${eventType}`);
+    await kv.put(key, sc.encode(JSON.stringify(event)));
+}
+async function requestConfirmation(config, task, kv) {
+    const kvKey = `${config.agentId}.${task.frontmatter.id}`;
+    // Write confirmation payload to KV — the server watches this bucket and sends push notifications
     const payload = {
         type: "confirm",
         task_id: task.frontmatter.id,
-        hook_id: hookId,
         agent_id: config.agentId,
         user_id: config.userId,
         details: {
-            task_name: task.frontmatter.name,
             prompt: task.frontmatter.user_prompt,
         },
         status: "pending",
     };
     await kv.put(kvKey, sc.encode(JSON.stringify(payload)));
-    // Publish push notification
-    nc.publish(`user.${config.userId}.push.request.confirm`, sc.encode(JSON.stringify({
-        type: "confirm",
-        task_id: task.frontmatter.id,
-        hook_id: hookId,
-        agent_id: config.agentId,
-        task_name: task.frontmatter.name,
-    })));
-    // Wait for status change
+    // Watch AFTER writing — the initial history replay delivers the "pending" entry (skipped),
+    // then the iterator stays open for live updates (confirmed/aborted).
+    const watch = await kv.watch({ key: kvKey });
     for await (const entry of watch) {
         if (entry.operation === "DEL" || entry.operation === "PURGE") {
-            // Key was deleted, treat as aborted
             return false;
         }
         try {
             const updated = JSON.parse(sc.decode(entry.value));
-            if (updated.status === "confirmed") {
-                await kv.delete(kvKey);
-                kvKeysToClean.pop();
+            if (updated.status === "confirmed")
                 return true;
-            }
-            else if (updated.status === "aborted") {
-                await kv.delete(kvKey);
-                kvKeysToClean.pop();
+            if (updated.status === "aborted")
                 return false;
-            }
             // Still pending, keep watching
         }
         catch {
@@ -119,45 +122,50 @@ async function requestConfirmation(config, task, kv, nc, kvKeysToClean) {
     }
     return false;
 }
-async function spawnClaude(config, task, taskId) {
-    // Dynamic import of node-pty (native module)
-    const { spawn } = await import("node-pty");
+function shellEscape(arg) {
+    return "'" + arg.replace(/'/g, "'\\''") + "'";
+}
+async function spawnTask(config, task) {
     return new Promise((resolve, reject) => {
-        const args = ["-p", task.frontmatter.user_prompt];
-        if (task.frontmatter.suppress_permissions) {
-            args.push("--dangerously-skip-permissions");
-        }
-        // If the task has a body (system prompt / additional instructions), pass via --system-prompt
-        if (task.body) {
-            args.push("--system-prompt", task.body);
-        }
-        const ptyProcess = spawn("claude", args, {
-            name: "xterm-256color",
-            cols: 120,
-            rows: 40,
+        const prompt = task.body
+            ? `${task.body}\n\n${task.frontmatter.user_prompt}`
+            : task.frontmatter.user_prompt;
+        const command = `${task.frontmatter.command_line} ${shellEscape(prompt)}`;
+        const child = spawn(command, {
             cwd: config.projectRoot,
+            shell: true,
+            stdio: ["ignore", "pipe", "pipe"],
             env: {
                 ...process.env,
-                PALMIER_TASK_ID: taskId,
+                PALMIER_TASK_ID: task.frontmatter.id,
             },
         });
-        ptyProcess.onData((data) => {
+        const stdoutChunks = [];
+        child.stdout?.on("data", (data) => {
+            stdoutChunks.push(data);
             process.stdout.write(data);
         });
-        ptyProcess.onExit(({ exitCode }) => {
-            if (exitCode === 0) {
-                resolve();
-            }
-            else {
-                reject(new Error(`Claude exited with code ${exitCode}`));
-            }
+        child.stderr?.on("data", (data) => {
+            process.stderr.write(data);
         });
-        // Forward signals to pty child
+        let stopping = false;
         const killChild = () => {
-            ptyProcess.kill();
+            stopping = true;
+            child.kill("SIGTERM");
         };
         process.on("SIGINT", killChild);
         process.on("SIGTERM", killChild);
+        child.on("close", (exitCode) => {
+            if (exitCode === 0 || stopping) {
+                resolve(Buffer.concat(stdoutChunks).toString("utf-8"));
+            }
+            else {
+                reject(new Error(`Task process exited with code ${exitCode}`));
+            }
+        });
+        child.on("error", (err) => {
+            reject(err);
+        });
     });
 }
 //# sourceMappingURL=run.js.map