palmier 0.2.0 → 0.2.2

package/src/rpc-handler.ts

@@ -0,0 +1,421 @@
+import { randomUUID } from "crypto";
+import * as os from "os";
+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 { parse as parseYaml } from "yaml";
+import { listTasks, parseTaskFile, writeTaskFile, getTaskDir, getTaskCreatedAt, readTaskStatus, writeTaskStatus, readHistory, deleteHistoryEntry, appendTaskList, removeFromTaskList } from "./task.js";
+import { installTaskTimer, removeTaskTimer } from "./systemd.js";
+import { spawnCommand } from "./spawn-command.js";
+import { getAgent } from "./agents/agent.js";
+import { hasSessions, validateSession } from "./session-store.js";
+import type { HostConfig, ParsedTask, RpcMessage } from "./types.js";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const PLAN_GENERATION_PROMPT = fs.readFileSync(
+  path.join(__dirname, "commands", "plan-generation.md"),
+  "utf-8",
+);
+
+function detectLanIp(): string {
+  const interfaces = os.networkInterfaces();
+  for (const name of Object.keys(interfaces)) {
+    for (const iface of interfaces[name] ?? []) {
+      if (iface.family === "IPv4" && !iface.internal) {
+        return iface.address;
+      }
+    }
+  }
+  return "127.0.0.1";
+}
+
+/**
+ * Parse RESULT frontmatter into a metadata object.
+ */
+function parseResultFrontmatter(raw: string): Record<string, unknown> {
+  const fmMatch = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!fmMatch) return { content: raw };
+
+  const meta: Record<string, string> = {};
+  const requiredPermissions: Array<{ name: string; description: string }> = [];
+  for (const line of fmMatch[1].split("\n")) {
+    const sep = line.indexOf(": ");
+    if (sep === -1) continue;
+    const key = line.slice(0, sep).trim();
+    const value = line.slice(sep + 2).trim();
+    if (key === "required_permission") {
+      const pipeSep = value.indexOf("|");
+      if (pipeSep !== -1) {
+        requiredPermissions.push({ name: value.slice(0, pipeSep).trim(), description: value.slice(pipeSep + 1).trim() });
+      } else {
+        requiredPermissions.push({ name: value, description: "" });
+      }
+    } else {
+      meta[key] = value;
+    }
+  }
+  const reportFiles = meta.report_files
+    ? meta.report_files.split(",").map((f: string) => f.trim()).filter(Boolean)
+    : [];
+
+  return {
+    content: fmMatch[2],
+    task_name: meta.task_name,
+    running_state: meta.running_state,
+    start_time: meta.start_time ? Number(meta.start_time) : undefined,
+    end_time: meta.end_time ? Number(meta.end_time) : undefined,
+    task_file: meta.task_file,
+    report_files: reportFiles.length > 0 ? reportFiles : undefined,
+    required_permissions: requiredPermissions.length > 0 ? requiredPermissions : undefined,
+  };
+}
+
+/**
+ * Run plan generation for a task prompt using the given agent.
+ * Returns the generated plan body and task name.
+ */
+async function generatePlan(
+  projectRoot: string,
+  userPrompt: string,
+  agentName: string,
+): Promise<{ name: string; body: string }> {
+  const fullPrompt = PLAN_GENERATION_PROMPT + userPrompt;
+  const planAgent = getAgent(agentName);
+  const { command, args } = planAgent.getPlanGenerationCommandLine(fullPrompt);
+  console.log(`[generatePlan] Running: ${command} ${args.join(" ")}`);
+
+  const { output } = await spawnCommand(command, args, {
+    cwd: projectRoot,
+    timeout: 120_000,
+  });
+
+  let name = "";
+  const trimmed = output.trim();
+  let body = trimmed;
+  const fmMatch = trimmed.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (fmMatch) {
+    try {
+      const fm = parseYaml(fmMatch[1]) as { task_name?: string };
+      name = fm.task_name ?? "";
+    } catch {
+      // If frontmatter parsing fails, treat entire output as body
+    }
+    body = fmMatch[2].trimStart();
+  }
+  return { name, body };
+}
+
+/**
+ * Create a transport-agnostic RPC handler bound to the given config.
+ */
+export function createRpcHandler(config: HostConfig) {
+  function flattenTask(task: ParsedTask) {
+    const taskDir = getTaskDir(config.projectRoot, task.frontmatter.id);
+    return {
+      ...task.frontmatter,
+      body: task.body,
+      created_at: getTaskCreatedAt(taskDir),
+      status: readTaskStatus(taskDir),
+    };
+  }
+
+  async function handleRpc(request: RpcMessage): Promise<unknown> {
+    // Session token validation: if any sessions exist, require a valid token
+    if (hasSessions()) {
+      if (!request.sessionToken || !validateSession(request.sessionToken)) {
+        return { error: "Unauthorized" };
+      }
+    }
+
+    switch (request.method) {
+      case "task.list": {
+        const tasks = listTasks(config.projectRoot);
+        return {
+          tasks: tasks.map((task) => flattenTask(task)),
+          agents: config.agents ?? [],
+        };
+      }
+
+      case "task.create": {
+        const params = request.params as {
+          user_prompt: string;
+          agent: string;
+          triggers?: Array<{ type: "cron" | "once"; value: string }>;
+          triggers_enabled?: boolean;
+          requires_confirmation?: boolean;
+        };
+
+        // Short descriptions skip plan generation and use the description as-is
+        let name = "";
+        let body = "";
+        if (params.user_prompt.length < 50) {
+          name = params.user_prompt;
+        } else {
+          try {
+            const plan = await generatePlan(config.projectRoot, params.user_prompt, params.agent);
+            name = plan.name;
+            body = plan.body;
+          } catch (err: unknown) {
+            const error = err as { stdout?: string; stderr?: string };
+            return { error: "plan generation failed", stdout: error.stdout, stderr: error.stderr };
+          }
+        }
+
+        const id = randomUUID();
+        const taskDir = getTaskDir(config.projectRoot, id);
+        const task = {
+          frontmatter: {
+            id,
+            name,
+            user_prompt: params.user_prompt,
+            agent: params.agent,
+            triggers: params.triggers ?? [],
+            triggers_enabled: params.triggers_enabled ?? true,
+            requires_confirmation: params.requires_confirmation ?? true,
+          },
+          body,
+        };
+
+        writeTaskFile(taskDir, task);
+        appendTaskList(config.projectRoot, id);
+        if (task.frontmatter.triggers_enabled) {
+          installTaskTimer(config, task);
+        }
+
+        return flattenTask(task);
+      }
+
+      case "task.update": {
+        const params = request.params as {
+          id: string;
+          user_prompt?: string;
+          agent?: string;
+          triggers?: Array<{ type: "cron" | "once"; value: string }>;
+          triggers_enabled?: boolean;
+          requires_confirmation?: boolean;
+        };
+
+        const taskDir = getTaskDir(config.projectRoot, params.id);
+        const existing = parseTaskFile(taskDir);
+
+        // Detect whether plan needs regeneration
+        const promptChanged = params.user_prompt !== undefined && params.user_prompt !== existing.frontmatter.user_prompt;
+        const agentChanged = params.agent !== undefined && params.agent !== existing.frontmatter.agent;
+        const needsRegeneration = promptChanged || agentChanged || !existing.body;
+
+        // Merge updates
+        if (params.user_prompt !== undefined) existing.frontmatter.user_prompt = params.user_prompt;
+        if (params.agent !== undefined) existing.frontmatter.agent = params.agent;
+        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;
+
+        // Regenerate plan if needed
+        if (needsRegeneration) {
+          if (existing.frontmatter.user_prompt.length < 50) {
+            existing.frontmatter.name = existing.frontmatter.user_prompt;
+            existing.body = "";
+          } else {
+            try {
+              const plan = await generatePlan(config.projectRoot, existing.frontmatter.user_prompt, existing.frontmatter.agent);
+              existing.frontmatter.name = plan.name;
+              existing.body = plan.body;
+            } catch (err: unknown) {
+              const error = err as { stdout?: string; stderr?: string };
+              return { error: "plan generation failed", stdout: error.stdout, stderr: error.stderr };
+            }
+          }
+        }
+
+        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 };
+
+        removeTaskTimer(params.id);
+        removeFromTaskList(config.projectRoot, params.id);
+
+        return { ok: true, task_id: params.id };
+      }
+
+      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.status": {
+        const params = request.params as { id: string };
+        const taskDir = getTaskDir(config.projectRoot, params.id);
+        const status = readTaskStatus(taskDir);
+        if (!status) {
+          return { task_id: params.id, error: "No status found" };
+        }
+        return { task_id: params.id, ...status };
+      }
+
+      case "task.result": {
+        const params = request.params as { id: string; result_file: string };
+        if (!params.result_file) {
+          return { error: "result_file is required" };
+        }
+        const resultPath = path.join(config.projectRoot, "tasks", params.id, params.result_file);
+
+        try {
+          const raw = fs.readFileSync(resultPath, "utf-8");
+          const meta = parseResultFrontmatter(raw);
+          return { task_id: params.id, ...meta };
+        } catch {
+          return { task_id: params.id, error: "No result file found" };
+        }
+      }
+
+      case "task.reports": {
+        const params = request.params as { id: string; report_files: string[] };
+        if (!Array.isArray(params.report_files) || params.report_files.length === 0) {
+          return { error: "report_files must be a non-empty array" };
+        }
+        const reports: Array<{ file: string; content?: string; error?: string }> = [];
+        for (const file of params.report_files) {
+          if (!file.endsWith(".md")) {
+            reports.push({ file, error: "must end with .md" });
+            continue;
+          }
+          const basename = path.basename(file);
+          if (basename !== file) {
+            reports.push({ file, error: "must be a plain filename" });
+            continue;
+          }
+          const reportPath = path.join(config.projectRoot, "tasks", params.id, basename);
+          try {
+            const content = fs.readFileSync(reportPath, "utf-8");
+            reports.push({ file, content });
+          } catch {
+            reports.push({ file, error: "Report file not found" });
+          }
+        }
+        return { task_id: params.id, reports };
+      }
+
+      case "task.user_input": {
+        const params = request.params as { id: string; value: string };
+        const taskDir = getTaskDir(config.projectRoot, params.id);
+
+        const currentStatus = readTaskStatus(taskDir);
+        if (!currentStatus?.pending_confirmation && !currentStatus?.pending_permission?.length) {
+          return { ok: false, error: "not pending" };
+        }
+
+        writeTaskStatus(taskDir, { ...currentStatus, user_input: params.value });
+
+        console.log(`[task.user_input] ${params.id} → ${params.value}`);
+        return { ok: true };
+      }
+
+      case "activity.list": {
+        const params = request.params as { offset?: number; limit?: number; task_id?: string };
+        const { entries, total } = readHistory(config.projectRoot, {
+          offset: params.offset ?? 0,
+          limit: params.limit ?? 10,
+          task_id: params.task_id,
+        });
+
+        const enriched = entries.map((entry) => {
+          const resultPath = path.join(config.projectRoot, "tasks", entry.task_id, entry.result_file);
+          try {
+            const raw = fs.readFileSync(resultPath, "utf-8");
+            const meta = parseResultFrontmatter(raw);
+            // Exclude full content from list response
+            const { content: _, ...rest } = meta;
+            return { ...entry, ...rest };
+          } catch {
+            return { ...entry, error: "Result file not found" };
+          }
+        });
+
+        return { entries: enriched, total };
+      }
+
+      case "activity.delete": {
+        const params = request.params as { task_id: string; result_file: string };
+        if (!params.task_id || !params.result_file) {
+          return { error: "task_id and result_file are required" };
+        }
+        const deleted = deleteHistoryEntry(config.projectRoot, params.task_id, params.result_file);
+        if (!deleted) {
+          return { error: "History entry not found" };
+        }
+        return { ok: true, task_id: params.task_id, result_file: params.result_file };
+      }
+
+      case "host.directInfo": {
+        if (config.mode === "lan" || config.mode === "auto") {
+          const ip = detectLanIp();
+          return {
+            directUrl: `http://${ip}:${config.directPort ?? 7400}`,
+            directToken: config.directToken,
+          };
+        }
+        return { directUrl: null, directToken: null };
+      }
+
+      default:
+        return { error: `Unknown method: ${request.method}` };
+    }
+  }
+
+  return handleRpc;
+}

package/src/session-store.ts

@@ -0,0 +1,68 @@
+import * as fs from "fs";
+import * as path from "path";
+import { randomBytes } from "crypto";
+import { CONFIG_DIR } from "./config.js";
+
+const SESSIONS_FILE = path.join(CONFIG_DIR, "sessions.json");
+
+export interface SessionEntry {
+  token: string;
+  createdAt: string;
+  label?: string;
+}
+
+function readFile(): SessionEntry[] {
+  try {
+    if (!fs.existsSync(SESSIONS_FILE)) return [];
+    const raw = fs.readFileSync(SESSIONS_FILE, "utf-8");
+    return JSON.parse(raw) as SessionEntry[];
+  } catch {
+    return [];
+  }
+}
+
+function writeFile(sessions: SessionEntry[]): void {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(SESSIONS_FILE, JSON.stringify(sessions, null, 2), "utf-8");
+}
+
+export function loadSessions(): SessionEntry[] {
+  return readFile();
+}
+
+export function addSession(label?: string): SessionEntry {
+  const sessions = readFile();
+  const entry: SessionEntry = {
+    token: randomBytes(32).toString("hex"),
+    createdAt: new Date().toISOString(),
+    ...(label ? { label } : {}),
+  };
+  sessions.push(entry);
+  writeFile(sessions);
+  return entry;
+}
+
+export function revokeSession(token: string): boolean {
+  const sessions = readFile();
+  const idx = sessions.findIndex((s) => s.token === token);
+  if (idx === -1) return false;
+  sessions.splice(idx, 1);
+  writeFile(sessions);
+  return true;
+}
+
+export function revokeAllSessions(): number {
+  const sessions = readFile();
+  const count = sessions.length;
+  writeFile([]);
+  return count;
+}
+
+export function validateSession(token: string): boolean {
+  const sessions = readFile();
+  return sessions.some((s) => s.token === token);
+}
+
+export function hasSessions(): boolean {
+  return readFile().length > 0;
+}

package/src/spawn-command.ts

@@ -0,0 +1,78 @@
+import { spawn } from "child_process";
+
+export interface SpawnCommandOptions {
+  cwd: string;
+  env?: Record<string, string>;
+  timeout?: number;
+  /** Echo stdout to process.stdout (useful for journald logging). */
+  echoStdout?: boolean;
+  /** Forward SIGINT/SIGTERM to the child and resolve on stop. */
+  forwardSignals?: boolean;
+  /** Resolve with output even on non-zero exit (instead of rejecting). */
+  resolveOnFailure?: boolean;
+}
+
+/**
+ * Spawn a command with additional arguments.
+ *
+ * Runs without a shell — the command and args are passed directly to the
+ * child process (no escaping needed).
+ *
+ * stdin is set to "ignore" (equivalent to < /dev/null) because tools like
+ * `claude -p` hang indefinitely on an open stdin pipe.
+ */
+export interface SpawnCommandResult {
+  output: string;
+  exitCode: number | null;
+}
+
+export function spawnCommand(
+  command: string,
+  args: string[],
+  opts: SpawnCommandOptions,
+): Promise<SpawnCommandResult> {
+  return new Promise<SpawnCommandResult>((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd: opts.cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: opts.env ? { ...process.env, ...opts.env } : undefined,
+    });
+
+    const chunks: Buffer[] = [];
+    child.stdout.on("data", (d: Buffer) => {
+      chunks.push(d);
+      if (opts.echoStdout) process.stdout.write(d);
+    });
+    child.stderr.on("data", (d: Buffer) => process.stderr.write(d));
+
+    let stopping = false;
+    if (opts.forwardSignals) {
+      const killChild = () => {
+        stopping = true;
+        child.kill("SIGTERM");
+      };
+      process.on("SIGINT", killChild);
+      process.on("SIGTERM", killChild);
+    }
+
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    if (opts.timeout) {
+      timer = setTimeout(() => {
+        child.kill();
+        reject(new Error("command timed out"));
+      }, opts.timeout);
+    }
+
+    child.on("close", (code) => {
+      if (timer) clearTimeout(timer);
+      const output = Buffer.concat(chunks).toString("utf-8");
+      if (code === 0 || stopping || opts.resolveOnFailure) resolve({ output, exitCode: code });
+      else reject(new Error(`process exited with code ${code}`));
+    });
+
+    child.on("error", (err) => {
+      if (timer) clearTimeout(timer);
+      reject(err);
+    });
+  });
+}

package/src/systemd.ts

@@ -2,7 +2,7 @@ import * as fs from "fs";
 import * as path from "path";
 import { homedir } from "os";
 import { execSync } from "child_process";
-import type { AgentConfig } from "./types.js";
+import type { HostConfig } from "./types.js";
 import type { ParsedTask } from "./types.js";
 
 const UNIT_DIR = path.join(homedir(), ".config", "systemd", "user");
@@ -62,7 +62,7 @@ export function cronToOnCalendar(cron: string): string {
 /**
  * Install a systemd user timer + service for a task.
  */
-export function installTaskTimer(config: AgentConfig, task: ParsedTask): void {
+export function installTaskTimer(config: HostConfig, task: ParsedTask): void {
   fs.mkdirSync(UNIT_DIR, { recursive: true });
 
   const taskId = task.frontmatter.id;