palmier 0.2.0 → 0.2.2

package/dist/rpc-handler.js

@@ -0,0 +1,367 @@
+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";
+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() {
+    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) {
+    const fmMatch = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+    if (!fmMatch)
+        return { content: raw };
+    const meta = {};
+    const requiredPermissions = [];
+    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) => 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, userPrompt, agentName) {
+    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]);
+            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) {
+    function flattenTask(task) {
+        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) {
+        // 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;
+                // 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) {
+                        const error = err;
+                        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;
+                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) {
+                            const error = err;
+                            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;
+                removeTaskTimer(params.id);
+                removeFromTaskList(config.projectRoot, params.id);
+                return { ok: true, task_id: params.id };
+            }
+            case "task.run": {
+                const params = request.params;
+                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) {
+                    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.abort": {
+                const params = request.params;
+                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;
+                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) {
+                    const error = err;
+                    return { task_id: params.id, logs: error.stdout || "", error: error.stderr };
+                }
+            }
+            case "task.status": {
+                const params = request.params;
+                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;
+                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;
+                if (!Array.isArray(params.report_files) || params.report_files.length === 0) {
+                    return { error: "report_files must be a non-empty array" };
+                }
+                const reports = [];
+                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;
+                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;
+                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;
+                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;
+}
+//# sourceMappingURL=rpc-handler.js.map

package/dist/session-store.d.ts

@@ -0,0 +1,12 @@
+export interface SessionEntry {
+    token: string;
+    createdAt: string;
+    label?: string;
+}
+export declare function loadSessions(): SessionEntry[];
+export declare function addSession(label?: string): SessionEntry;
+export declare function revokeSession(token: string): boolean;
+export declare function revokeAllSessions(): number;
+export declare function validateSession(token: string): boolean;
+export declare function hasSessions(): boolean;
+//# sourceMappingURL=session-store.d.ts.map

package/dist/session-store.js

@@ -0,0 +1,57 @@
+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");
+function readFile() {
+    try {
+        if (!fs.existsSync(SESSIONS_FILE))
+            return [];
+        const raw = fs.readFileSync(SESSIONS_FILE, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+}
+function writeFile(sessions) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs.writeFileSync(SESSIONS_FILE, JSON.stringify(sessions, null, 2), "utf-8");
+}
+export function loadSessions() {
+    return readFile();
+}
+export function addSession(label) {
+    const sessions = readFile();
+    const entry = {
+        token: randomBytes(32).toString("hex"),
+        createdAt: new Date().toISOString(),
+        ...(label ? { label } : {}),
+    };
+    sessions.push(entry);
+    writeFile(sessions);
+    return entry;
+}
+export function revokeSession(token) {
+    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() {
+    const sessions = readFile();
+    const count = sessions.length;
+    writeFile([]);
+    return count;
+}
+export function validateSession(token) {
+    const sessions = readFile();
+    return sessions.some((s) => s.token === token);
+}
+export function hasSessions() {
+    return readFile().length > 0;
+}
+//# sourceMappingURL=session-store.js.map

package/dist/spawn-command.d.ts

@@ -0,0 +1,26 @@
+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 declare function spawnCommand(command: string, args: string[], opts: SpawnCommandOptions): Promise<SpawnCommandResult>;
+//# sourceMappingURL=spawn-command.d.ts.map

package/dist/spawn-command.js

@@ -0,0 +1,48 @@
+import { spawn } from "child_process";
+export function spawnCommand(command, args, opts) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            cwd: opts.cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+            env: opts.env ? { ...process.env, ...opts.env } : undefined,
+        });
+        const chunks = [];
+        child.stdout.on("data", (d) => {
+            chunks.push(d);
+            if (opts.echoStdout)
+                process.stdout.write(d);
+        });
+        child.stderr.on("data", (d) => 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;
+        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);
+        });
+    });
+}
+//# sourceMappingURL=spawn-command.js.map

package/dist/systemd.d.ts

@@ -1,4 +1,4 @@
-import type { AgentConfig } from "./types.js";
+import type { HostConfig } from "./types.js";
 import type { ParsedTask } from "./types.js";
 /**
  * Convert a cron expression (5-field) to a systemd OnCalendar string.
@@ -8,7 +8,7 @@ export declare function cronToOnCalendar(cron: string): string;
 /**
  * Install a systemd user timer + service for a task.
  */
-export declare function installTaskTimer(config: AgentConfig, task: ParsedTask): void;
+export declare function installTaskTimer(config: HostConfig, task: ParsedTask): void;
 /**
  * Remove a task's systemd timer and service files.
  */

package/dist/task.d.ts

@@ -1,4 +1,4 @@
-import type { ParsedTask } from "./types.js";
+import type { ParsedTask, TaskStatus, HistoryEntry } from "./types.js";
 /**
  * Parse a TASK.md file from the given task directory.
  */
@@ -9,11 +9,54 @@ export declare function parseTaskFile(taskDir: string): ParsedTask;
  */
 export declare function writeTaskFile(taskDir: string, task: ParsedTask): void;
 /**
- * List all tasks from projectRoot/tasks/{id}/TASK.md.
+ * Append a task ID to the project-level tasks.jsonl file.
+ */
+export declare function appendTaskList(projectRoot: string, taskId: string): void;
+/**
+ * Remove a task ID from the project-level tasks.jsonl file.
+ * Returns true if the entry was found and removed.
+ */
+export declare function removeFromTaskList(projectRoot: string, taskId: string): boolean;
+/**
+ * List all tasks referenced in tasks.jsonl.
  */
 export declare function listTasks(projectRoot: string): ParsedTask[];
 /**
  * Get the directory path for a task by its ID.
  */
 export declare function getTaskDir(projectRoot: string, taskId: string): string;
+/**
+ * Get the creation time (birthtime) of a TASK.md file in ms since epoch.
+ */
+export declare function getTaskCreatedAt(taskDir: string): number;
+/**
+ * Write task status to status.json in the task directory.
+ */
+export declare function writeTaskStatus(taskDir: string, status: TaskStatus): void;
+/**
+ * Read task status from status.json in the task directory.
+ * Returns undefined if the file doesn't exist.
+ */
+export declare function readTaskStatus(taskDir: string): TaskStatus | undefined;
+/**
+ * Append a history entry to the project-level history.jsonl file.
+ */
+export declare function appendHistory(projectRoot: string, entry: HistoryEntry): void;
+/**
+ * Delete a history entry and its associated result/task-snapshot files.
+ * Returns true if the entry was found and removed.
+ */
+export declare function deleteHistoryEntry(projectRoot: string, taskId: string, resultFile: string): boolean;
+/**
+ * Read history entries from history.jsonl with pagination.
+ * Returns entries sorted most-recent-first.
+ */
+export declare function readHistory(projectRoot: string, opts: {
+    offset?: number;
+    limit?: number;
+    task_id?: string;
+}): {
+    entries: HistoryEntry[];
+    total: number;
+};
 //# sourceMappingURL=task.d.ts.map