palmier 0.2.7 → 0.2.8

package/src/types.ts

@@ -1,62 +1,62 @@
-export interface HostConfig {
-  hostId: string;
-  projectRoot: string;
-
-  // NATS (always enabled)
-  nats?: boolean;
-  natsUrl?: string;
-  natsWsUrl?: string;
-  natsToken?: string;
-
-  // Detected agent CLIs
-  agents?: Array<{ key: string; label: string }>;
-}
-
-export interface TaskFrontmatter {
-  id: string;
-  name: string;
-  user_prompt: string;
-  agent: string;
-  triggers: Trigger[];
-  triggers_enabled: boolean;
-  requires_confirmation: boolean;
-  permissions?: RequiredPermission[];
-  command?: string;
-}
-
-export interface Trigger {
-  type: "cron" | "once";
-  value: string;
-}
-
-export interface ParsedTask {
-  frontmatter: TaskFrontmatter;
-  body: string;
-}
-
-export type TaskRunningState = "started" | "finished" | "aborted" | "failed";
-
-export interface TaskStatus {
-  running_state: TaskRunningState;
-  time_stamp: number;
-  pending_confirmation?: boolean;
-  pending_permission?: RequiredPermission[];
-  pending_input?: string[];
-  user_input?: string[];
-}
-
-export interface HistoryEntry {
-  task_id: string;
-  result_file: string;
-}
-
-export interface RequiredPermission {
-  name: string;
-  description: string;
-}
-
-export interface RpcMessage {
-  method: string;
-  params: Record<string, unknown>;
-  sessionToken?: string;
-}
+export interface HostConfig {
+  hostId: string;
+  projectRoot: string;
+
+  // NATS (always enabled)
+  nats?: boolean;
+  natsUrl?: string;
+  natsWsUrl?: string;
+  natsToken?: string;
+
+  // Detected agent CLIs
+  agents?: Array<{ key: string; label: string }>;
+}
+
+export interface TaskFrontmatter {
+  id: string;
+  name: string;
+  user_prompt: string;
+  agent: string;
+  triggers: Trigger[];
+  triggers_enabled: boolean;
+  requires_confirmation: boolean;
+  permissions?: RequiredPermission[];
+  command?: string;
+}
+
+export interface Trigger {
+  type: "cron" | "once";
+  value: string;
+}
+
+export interface ParsedTask {
+  frontmatter: TaskFrontmatter;
+  body: string;
+}
+
+export type TaskRunningState = "started" | "finished" | "aborted" | "failed";
+
+export interface TaskStatus {
+  running_state: TaskRunningState;
+  time_stamp: number;
+  pending_confirmation?: boolean;
+  pending_permission?: RequiredPermission[];
+  pending_input?: string[];
+  user_input?: string[];
+}
+
+export interface HistoryEntry {
+  task_id: string;
+  result_file: string;
+}
+
+export interface RequiredPermission {
+  name: string;
+  description: string;
+}
+
+export interface RpcMessage {
+  method: string;
+  params: Record<string, unknown>;
+  sessionToken?: string;
+}

package/dist/commands/hook.d.ts

@@ -1,7 +0,0 @@
-/**
- * Handle a Claude Code hook invocation.
- * Called by Claude Code as a subprocess. Reads hook event from stdin,
- * dispatches by hook_name, and outputs response to stdout.
- */
-export declare function hookCommand(): Promise<void>;
-//# sourceMappingURL=hook.d.ts.map

package/dist/commands/hook.js

@@ -1,208 +0,0 @@
-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,
- * dispatches by hook_name, and outputs response to stdout.
- */
-export async function hookCommand() {
-    const rawInput = await readStdin();
-    let event;
-    try {
-        event = JSON.parse(rawInput);
-    }
-    catch {
-        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) {
-        log("no PALMIER_TASK_ID, exiting");
-        return;
-    }
-    const config = loadConfig();
-    const nc = await connectNats(config);
-    const sc = StringCodec();
-    try {
-        const js = nc.jetstream();
-        const kv = await js.views.kv("pending-hooks");
-        switch (event.hook_event_name) {
-            case "PermissionRequest":
-                await handlePermissionRequest(config, nc, kv, sc, event, taskId);
-                break;
-            case "Notification":
-                await handleNotification(config, nc, kv, sc, event, taskId);
-                break;
-            case "Stop":
-                await handleStop(config, nc, sc, taskId);
-                break;
-            default:
-                // Unknown hook, exit silently
-                break;
-        }
-    }
-    finally {
-        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}`;
-    // Start watching BEFORE writing
-    const watch = await kv.watch({ key: kvKey });
-    // Write hook payload to KV
-    const payload = {
-        type: "permission",
-        task_id: taskId,
-        hook_id: hookId,
-        agent_id: config.agentId,
-        user_id: config.userId,
-        details: {
-            tool: event.tool_name,
-            input: event.tool_input,
-        },
-        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({
-        type: "permission",
-        task_id: taskId,
-        hook_id: hookId,
-        agent_id: config.agentId,
-        tool: event.tool_name,
-        input: event.tool_input,
-    })));
-    // 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
-            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") {
-                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") {
-                const out = JSON.stringify(permissionResponse("deny"));
-                log(`permission: denying, stdout=${out}`);
-                process.stdout.write(out);
-                await kv.delete(kvKey);
-                return;
-            }
-            // Still pending, keep watching
-        }
-        catch {
-            // Couldn't parse, keep watching
-        }
-    }
-}
-async function handleNotification(config, nc, kv, sc, event, taskId) {
-    const message = event.message || "";
-    // Check if notification requires user input
-    // Look for patterns suggesting input is needed
-    const inputPatterns = [
-        /\bwait(ing)?\s+(for|on)\s+(user\s+)?input\b/i,
-        /\bplease\s+(provide|enter|type|input)\b/i,
-        /\buser\s+input\s+(required|needed)\b/i,
-        /\bask(ing)?\s+(the\s+)?user\b/i,
-        /\brequires?\s+(user\s+)?input\b/i,
-        /\bprompt(ing)?\s+(the\s+)?user\b/i,
-    ];
-    const needsInput = inputPatterns.some((pattern) => pattern.test(message));
-    if (!needsInput) {
-        // No input needed, exit silently
-        return;
-    }
-    const hookId = uuidv4();
-    const kvKey = `${config.agentId}.${taskId}.${hookId}`;
-    // Start watching BEFORE writing
-    const watch = await kv.watch({ key: kvKey });
-    // Write hook payload to KV
-    const payload = {
-        type: "input",
-        task_id: taskId,
-        hook_id: hookId,
-        agent_id: config.agentId,
-        user_id: config.userId,
-        details: {
-            message: event.message,
-        },
-        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({
-        type: "input",
-        task_id: taskId,
-        hook_id: hookId,
-        agent_id: config.agentId,
-        message: event.message,
-    })));
-    // 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;
-            }
-            // Still pending, keep watching
-        }
-        catch {
-            // Couldn't parse, keep watching
-        }
-    }
-}
-async function handleStop(config, nc, sc, taskId) {
-    // Publish completion notification
-    nc.publish(`user.${config.userId}.push.notify.complete`, sc.encode(JSON.stringify({
-        type: "complete",
-        task_id: taskId,
-        agent_id: config.agentId,
-    })));
-}
-async function readStdin() {
-    const chunks = [];
-    for await (const chunk of process.stdin) {
-        chunks.push(chunk);
-    }
-    return Buffer.concat(chunks).toString("utf-8");
-}
-//# sourceMappingURL=hook.js.map

package/dist/commands/task-cleanup.d.ts

@@ -1,14 +0,0 @@
-/**
- * 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 declare function taskCleanupCommand(taskId: string): Promise<void>;
-//# sourceMappingURL=task-cleanup.d.ts.map

package/dist/commands/task-cleanup.js

@@ -1,84 +0,0 @@
-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/commands/task-generation.md

@@ -1,28 +0,0 @@
-You are a planning assistant 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/systemd.d.ts

@@ -1,20 +0,0 @@
-import type { HostConfig } 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
- */
-export declare function cronToOnCalendar(cron: string): string;
-/**
- * Install a systemd user timer + service for a task.
- */
-export declare function installTaskTimer(config: HostConfig, task: ParsedTask): void;
-/**
- * Remove a task's systemd timer and service files.
- */
-export declare function removeTaskTimer(taskId: string): void;
-/**
- * Run systemctl --user daemon-reload.
- */
-export declare function daemonReload(): void;
-//# sourceMappingURL=systemd.d.ts.map

package/dist/systemd.js

@@ -1,145 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import { homedir } from "os";
-import { execSync } from "child_process";
-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 (5-field) to a systemd OnCalendar string.
- * Handles basic cron patterns: minute hour day-of-month month day-of-week
- */
-export 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, month, dayOfWeek] = parts;
-    // Map cron day-of-week names/numbers to systemd abbreviated names
-    const dowMap = {
-        "0": "Sun",
-        "1": "Mon",
-        "2": "Tue",
-        "3": "Wed",
-        "4": "Thu",
-        "5": "Fri",
-        "6": "Sat",
-        "7": "Sun",
-    };
-    // Convert day-of-week
-    let dow = dayOfWeek === "*" ? "*" : dayOfWeek;
-    if (dowMap[dow]) {
-        dow = dowMap[dow];
-    }
-    // Build OnCalendar string
-    // Format: DayOfWeek Year-Month-Day Hour:Minute:Second
-    const monthPart = month === "*" ? "*" : month.padStart(2, "0");
-    const dayPart = dayOfMonth === "*" ? "*" : dayOfMonth.padStart(2, "0");
-    const hourPart = hour === "*" ? "*" : hour.padStart(2, "0");
-    const minutePart = minute === "*" ? "*" : minute.padStart(2, "0");
-    if (dow === "*") {
-        return `*-${monthPart}-${dayPart} ${hourPart}:${minutePart}:00`;
-    }
-    return `${dow} *-${monthPart}-${dayPart} ${hourPart}:${minutePart}:00`;
-}
-/**
- * Install a systemd user timer + service for a task.
- */
-export function installTaskTimer(config, task) {
-    fs.mkdirSync(UNIT_DIR, { recursive: true });
-    const taskId = task.frontmatter.id;
-    const serviceName = getServiceName(taskId);
-    const timerName = getTimerName(taskId);
-    // Determine the palmier binary path
-    const palmierBin = process.argv[1] || "palmier";
-    // Generate service unit
-    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"}
-`;
-    // 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 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}`);
-        }
-    }
-}
-/**
- * Remove a task's systemd timer and service files.
- */
-export function removeTaskTimer(taskId) {
-    const timerName = getTimerName(taskId);
-    const serviceName = getServiceName(taskId);
-    const timerPath = path.join(UNIT_DIR, timerName);
-    const servicePath = path.join(UNIT_DIR, serviceName);
-    // Only stop/disable the timer if the file exists
-    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();
-}
-/**
- * Run systemctl --user daemon-reload.
- */
-export function daemonReload() {
-    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