palmier 0.1.8 → 0.2.0

package/src/commands/serve.ts

@@ -1,240 +1,287 @@
-import { randomUUID } from "crypto";
-import { execSync } from "child_process";
-import * as fs from "fs";
-import { StringCodec } from "nats";
-import { loadConfig } from "../config.js";
-import { connectNats } from "../nats-client.js";
-import { listTasks, parseTaskFile, writeTaskFile, getTaskDir } from "../task.js";
-import { installTaskTimer, removeTaskTimer, getTaskStatus } from "../systemd.js";
-import type { ParsedTask, RpcMessage } from "../types.js";
-
-/**
- * Start the persistent NATS RPC handler.
- */
-export async function serveCommand(): Promise<void> {
-  const config = loadConfig();
-  const nc = await connectNats(config);
-  const sc = StringCodec();
-
-  const subject = `user.${config.userId}.agent.${config.agentId}.rpc.>`;
-  console.log(`Subscribing to: ${subject}`);
-
-  const sub = nc.subscribe(subject);
-
-  // Graceful shutdown
-  const shutdown = async () => {
-    console.log("Shutting down...");
-    sub.unsubscribe();
-    await nc.drain();
-    process.exit(0);
-  };
-
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
-
-  // On startup, clean up orphaned pending-hooks keys for this agent
-  try {
-    const js = nc.jetstream();
-    const kv = await js.views.kv("pending-hooks");
-    const keys = await kv.keys();
-    for await (const key of keys) {
-      if (key.startsWith(`${config.agentId}.`)) {
-        console.log(`Cleaning up orphaned hook key: ${key}`);
-        await kv.delete(key);
-      }
-    }
-  } catch (err) {
-    console.error(`Warning: could not clean up pending-hooks KV: ${err}`);
-  }
-
-  console.log("Agent serving. Waiting for RPC messages...");
-
-  for await (const msg of sub) {
-    // Derive RPC method from subject: ...rpc.<method parts>
-    const subjectTokens = msg.subject.split(".");
-    const rpcIdx = subjectTokens.indexOf("rpc");
-    const method = rpcIdx >= 0 ? subjectTokens.slice(rpcIdx + 1).join(".") : "";
-
-    // Parse params from message body (the PWA sends params directly, no wrapper)
-    let params: Record<string, unknown> = {};
-    if (msg.data && msg.data.length > 0) {
-      const raw = sc.decode(msg.data).trim();
-      if (raw.length > 0) {
-        try {
-          params = JSON.parse(raw);
-        } catch {
-          console.error(`Failed to parse RPC params for ${method}`);
-          if (msg.reply) {
-            msg.respond(sc.encode(JSON.stringify({ error: "Invalid JSON" })));
-          }
-          continue;
-        }
-      }
-    }
-
-    console.log(`RPC: ${method}`);
-
-    let response: unknown;
-    try {
-      response = await handleRpc({ method, params });
-    } catch (err) {
-      console.error(`RPC error (${method}):`, err);
-      response = { error: String(err) };
-    }
-
-    if (msg.reply) {
-      msg.respond(sc.encode(JSON.stringify(response)));
-    }
-  }
-
-  function flattenTask(task: ParsedTask, status?: unknown) {
-    return { ...task.frontmatter, body: task.body, ...(status != null ? { status } : {}) };
-  }
-
-  async function handleRpc(request: RpcMessage): Promise<unknown> {
-    switch (request.method) {
-      case "task.list": {
-        const tasks = listTasks(config.projectRoot);
-        return {
-          tasks: tasks.map((task) =>
-            flattenTask(task, getTaskStatus(task.frontmatter.id))
-          ),
-        };
-      }
-
-      case "task.create": {
-        const params = request.params as {
-          name: string;
-          user_prompt: string;
-          triggers?: Array<{ type: "cron" | "once"; value: string }>;
-          requires_confirmation?: boolean;
-          suppress_permissions?: boolean;
-          enabled?: boolean;
-          body?: string;
-        };
-
-        const id = randomUUID();
-        const taskDir = getTaskDir(config.projectRoot, id);
-        const task = {
-          frontmatter: {
-            id,
-            name: params.name,
-            user_prompt: params.user_prompt,
-            triggers: params.triggers ?? [],
-            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);
-
-        return flattenTask(task);
-      }
-
-      case "task.update": {
-        const params = request.params as {
-          id: string;
-          name?: string;
-          user_prompt?: string;
-          triggers?: Array<{ type: "cron" | "once"; value: string }>;
-          requires_confirmation?: boolean;
-          suppress_permissions?: boolean;
-          enabled?: boolean;
-          body?: string;
-        };
-
-        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.triggers !== undefined) existing.frontmatter.triggers = params.triggers;
-        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
-        removeTaskTimer(params.id);
-        installTaskTimer(config, existing);
-
-        return flattenTask(existing, getTaskStatus(params.id));
-      }
-
-      case "task.delete": {
-        const params = request.params as { id: string };
-        const taskDir = getTaskDir(config.projectRoot, params.id);
-
-        removeTaskTimer(params.id);
-
-        // Remove task directory
-        if (fs.existsSync(taskDir)) {
-          fs.rmSync(taskDir, { recursive: true, force: true });
-        }
-
-        return { ok: true, task_id: params.id };
-      }
-
-      case "task.generate": {
-        const params = request.params as { prompt: string };
-
-        try {
-          const output = execSync(`claude -p "${params.prompt.replace(/"/g, '\\"')}"`, {
-            encoding: "utf-8",
-            cwd: config.projectRoot,
-            timeout: 120_000,
-          });
-          return { ok: true, body: output };
-        } catch (err: unknown) {
-          const error = err as { stdout?: string; stderr?: string };
-          return { error: "claude command failed", stdout: error.stdout, stderr: error.stderr };
-        }
-      }
-
-      case "task.run": {
-        const params = request.params as { id: string };
-        const serviceName = `palmier-task-${params.id}.service`;
-
-        try {
-          execSync(`systemctl --user start ${serviceName}`, { stdio: "inherit" });
-          return { ok: true, task_id: params.id };
-        } catch (err) {
-          return { error: `Failed to start task service: ${err}` };
-        }
-      }
-
-      case "task.status": {
-        const params = request.params as { id: string };
-        const status = getTaskStatus(params.id);
-        return { task_id: params.id, status };
-      }
-
-      case "task.logs": {
-        const params = request.params as { id: string };
-        const serviceName = `palmier-task-${params.id}.service`;
-
-        try {
-          const logs = execSync(
-            `journalctl --user -u ${serviceName} -n 100 --no-pager`,
-            { encoding: "utf-8" }
-          );
-          return { task_id: params.id, logs };
-        } catch (err: unknown) {
-          const error = err as { stdout?: string; stderr?: string };
-          return { task_id: params.id, logs: error.stdout || "", error: error.stderr };
-        }
-      }
-
-      default:
-        return { error: `Unknown method: ${request.method}` };
-    }
-  }
-}
+import { randomUUID } from "crypto";
+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: string): string {
+  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 } from "../systemd.js";
+import type { ParsedTask, RpcMessage } from "../types.js";
+
+/**
+ * Start the persistent NATS RPC handler.
+ */
+export async function serveCommand(): Promise<void> {
+  const config = loadConfig();
+  const nc = await connectNats(config);
+  const sc = StringCodec();
+
+  const subject = `user.${config.userId}.agent.${config.agentId}.rpc.>`;
+  console.log(`Subscribing to: ${subject}`);
+
+  const sub = nc.subscribe(subject);
+
+  // Graceful shutdown
+  const shutdown = async () => {
+    console.log("Shutting down...");
+    sub.unsubscribe();
+    await nc.drain();
+    process.exit(0);
+  };
+
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+
+  // On startup, clean up orphaned pending-confirmation keys for this agent
+  try {
+    const js = nc.jetstream();
+    const kv = await js.views.kv("pending-confirmation");
+    const keys = await kv.keys();
+    for await (const key of keys) {
+      if (key.startsWith(`${config.agentId}.`)) {
+        console.log(`Cleaning up orphaned hook key: ${key}`);
+        await kv.delete(key);
+      }
+    }
+  } catch (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) {
+    // Derive RPC method from subject: ...rpc.<method parts>
+    const subjectTokens = msg.subject.split(".");
+    const rpcIdx = subjectTokens.indexOf("rpc");
+    const method = rpcIdx >= 0 ? subjectTokens.slice(rpcIdx + 1).join(".") : "";
+
+    // Parse params from message body (the PWA sends params directly, no wrapper)
+    let params: Record<string, unknown> = {};
+    if (msg.data && msg.data.length > 0) {
+      const raw = sc.decode(msg.data).trim();
+      if (raw.length > 0) {
+        try {
+          params = JSON.parse(raw);
+        } catch {
+          console.error(`Failed to parse RPC params for ${method}`);
+          if (msg.reply) {
+            msg.respond(sc.encode(JSON.stringify({ error: "Invalid JSON" })));
+          }
+          continue;
+        }
+      }
+    }
+
+    console.log(`RPC: ${method}`);
+
+    let response: unknown;
+    try {
+      response = await handleRpc({ method, params });
+    } catch (err) {
+      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: ParsedTask) {
+    return { ...task.frontmatter, body: task.body };
+  }
+
+  async function handleRpc(request: RpcMessage): Promise<unknown> {
+    switch (request.method) {
+      case "task.list": {
+        const tasks = listTasks(config.projectRoot);
+        return {
+          tasks: tasks.map((task) => flattenTask(task)),
+        };
+      }
+
+      case "task.create": {
+        const params = request.params as {
+          user_prompt: string;
+          command_line?: string;
+          triggers?: Array<{ type: "cron" | "once"; value: string }>;
+          triggers_enabled?: boolean;
+          requires_confirmation?: boolean;
+          body?: string;
+        };
+
+        const id = randomUUID();
+        const taskDir = getTaskDir(config.projectRoot, id);
+        const task = {
+          frontmatter: {
+            id,
+            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,
+          },
+          body: params.body || "",
+        };
+
+        writeTaskFile(taskDir, task);
+        if (task.frontmatter.triggers_enabled) {
+          installTaskTimer(config, task);
+        }
+
+        return flattenTask(task);
+      }
+
+      case "task.update": {
+        const params = request.params as {
+          id: string;
+          user_prompt?: string;
+          command_line?: string;
+          triggers?: Array<{ type: "cron" | "once"; value: string }>;
+          triggers_enabled?: boolean;
+          requires_confirmation?: boolean;
+          body?: string;
+        };
+
+        const taskDir = getTaskDir(config.projectRoot, params.id);
+        const existing = parseTaskFile(taskDir);
+
+        // Merge updates
+        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.body !== undefined) existing.body = params.body;
+
+        writeTaskFile(taskDir, existing);
+
+        // Reinstall or remove timers based on triggers_enabled
+        removeTaskTimer(params.id);
+        if (existing.frontmatter.triggers_enabled) {
+          installTaskTimer(config, existing);
+        }
+
+        return flattenTask(existing);
+      }
+
+      case "task.delete": {
+        const params = request.params as { id: string };
+        const taskDir = getTaskDir(config.projectRoot, params.id);
+
+        removeTaskTimer(params.id);
+
+        // Remove task directory
+        if (fs.existsSync(taskDir)) {
+          fs.rmSync(taskDir, { recursive: true, force: true });
+        }
+
+        return { ok: true, task_id: params.id };
+      }
+
+      case "task.generate": {
+        const params = request.params as { prompt: string; command_line?: string };
+        const commandLine = params.command_line || "claude -p --dangerously-skip-permissions";
+        const fullPrompt = TASK_GENERATION_PROMPT + params.prompt;
+
+        try {
+          const output = execSync(`${commandLine} ${shellEscape(fullPrompt)}`, {
+            encoding: "utf-8",
+            cwd: config.projectRoot,
+            timeout: 120_000,
+          });
+          return { ok: true, body: output };
+        } catch (err: unknown) {
+          const error = err as { stdout?: string; stderr?: string };
+          return { error: "generation command failed", stdout: error.stdout, stderr: error.stderr };
+        }
+      }
+
+      case "task.run": {
+        const params = request.params as { id: string };
+        const serviceName = `palmier-task-${params.id}.service`;
+
+        try {
+          await execAsync(`systemctl --user start --no-block ${serviceName}`);
+          return { ok: true, task_id: params.id };
+        } catch (err: unknown) {
+          const e = err as { stderr?: string; message?: string };
+          console.error(`task.run failed for ${params.id}: ${e.stderr || e.message}`);
+          return { error: `Failed to start task: ${e.stderr || e.message}` };
+        }
+      }
+
+      case "task.abort": {
+        const params = request.params as { id: string };
+        const serviceName = `palmier-task-${params.id}.service`;
+
+        try {
+          await execAsync(`systemctl --user stop ${serviceName}`);
+          return { ok: true, task_id: params.id };
+        } catch (err: unknown) {
+          const e = err as { stderr?: string; message?: string };
+          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 as { id: string };
+        const serviceName = `palmier-task-${params.id}.service`;
+
+        try {
+          const logs = execSync(
+            `journalctl --user -u ${serviceName} -n 100 --no-pager`,
+            { encoding: "utf-8" }
+          );
+          return { task_id: params.id, logs };
+        } catch (err: unknown) {
+          const error = err as { stdout?: string; stderr?: string };
+          return { task_id: params.id, logs: error.stdout || "", error: error.stderr };
+        }
+      }
+
+      case "task.result": {
+        const params = request.params as { id: string };
+        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: Record<string, number> = {};
+            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/src/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/src/index.ts

@@ -7,7 +7,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));
@@ -35,13 +34,6 @@ program
     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/src/nats-client.ts

@@ -1,15 +1,15 @@
-import { connect, type NatsConnection } from "nats";
-import type { AgentConfig } from "./types.js";
-
-/**
- * Connect to NATS using the agent config's TCP URL and token auth.
- */
-export async function connectNats(config: AgentConfig): Promise<NatsConnection> {
-  const nc = await connect({
-    servers: config.natsUrl,
-    token: config.natsToken,
-  });
-
-  console.log(`Connected to NATS at ${config.natsUrl}`);
-  return nc;
-}
+import { connect, type NatsConnection } from "nats";
+import type { AgentConfig } from "./types.js";
+
+/**
+ * Connect to NATS using the agent config's TCP URL and token auth.
+ */
+export async function connectNats(config: AgentConfig): Promise<NatsConnection> {
+  const nc = await connect({
+    servers: config.natsUrl,
+    token: config.natsToken,
+  });
+
+  console.log(`Connected to NATS at ${config.natsUrl}`);
+  return nc;
+}