palmier 0.2.0 → 0.2.1

package/src/task.ts

@@ -1,7 +1,7 @@
 import * as fs from "fs";
 import * as path from "path";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
-import type { ParsedTask, TaskFrontmatter } from "./types.js";
+import type { ParsedTask, TaskFrontmatter, TaskStatus, HistoryEntry } from "./types.js";
 
 /**
  * Parse a TASK.md file from the given task directory.
@@ -35,7 +35,8 @@ function parseTaskContent(content: string): ParsedTask {
     throw new Error("TASK.md frontmatter must include at least: id");
   }
 
-  frontmatter.command_line ??= "claude -p --dangerously-skip-permissions";
+  frontmatter.name ??= frontmatter.user_prompt?.slice(0, 60) ?? "";
+  frontmatter.agent ??= "claude";
   frontmatter.triggers_enabled ??= true;
 
   return { frontmatter, body };
@@ -56,34 +57,66 @@ export 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 function listTasks(projectRoot: string): ParsedTask[] {
-  const tasksDir = path.join(projectRoot, "tasks");
+export function appendTaskList(projectRoot: string, taskId: string): void {
+  const listPath = path.join(projectRoot, "tasks.jsonl");
+  fs.appendFileSync(listPath, JSON.stringify({ task_id: taskId }) + "\n", "utf-8");
+}
 
-  if (!fs.existsSync(tasksDir)) {
-    return [];
+/**
+ * Remove a task ID from the project-level tasks.jsonl file.
+ * Returns true if the entry was found and removed.
+ */
+export function removeFromTaskList(projectRoot: string, taskId: string): boolean {
+  const listPath = path.join(projectRoot, "tasks.jsonl");
+  if (!fs.existsSync(listPath)) return false;
+
+  const lines = fs.readFileSync(listPath, "utf-8").split("\n").filter(Boolean);
+  let found = false;
+  const remaining: string[] = [];
+
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line) as { task_id: string };
+      if (entry.task_id === taskId) {
+        found = true;
+        continue;
+      }
+    } catch { /* keep malformed lines */ }
+    remaining.push(line);
   }
 
-  const entries = fs.readdirSync(tasksDir, { withFileTypes: true });
-  const tasks: ParsedTask[] = [];
+  if (!found) return false;
+  fs.writeFileSync(listPath, remaining.length > 0 ? remaining.join("\n") + "\n" : "", "utf-8");
+  return true;
+}
 
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
+/**
+ * List all tasks referenced in tasks.jsonl.
+ */
+export function listTasks(projectRoot: string): ParsedTask[] {
+  const listPath = path.join(projectRoot, "tasks.jsonl");
+  if (!fs.existsSync(listPath)) return [];
 
-    const taskDir = path.join(tasksDir, entry.name);
-    const taskFile = path.join(taskDir, "TASK.md");
+  const lines = fs.readFileSync(listPath, "utf-8").split("\n").filter(Boolean);
+  const tasks: ParsedTask[] = [];
 
-    if (!fs.existsSync(taskFile)) continue;
+  for (const line of lines) {
+    let taskId: string;
+    try {
+      taskId = (JSON.parse(line) as { task_id: string }).task_id;
+    } catch { continue; }
 
+    const taskDir = getTaskDir(projectRoot, taskId);
     try {
       tasks.push(parseTaskFile(taskDir));
     } catch (err) {
-      console.error(`Warning: failed to parse task in ${taskDir}: ${err}`);
+      console.error(`Warning: failed to parse task ${taskId}: ${err}`);
     }
   }
 
-  return tasks;
+  return tasks.reverse();
 }
 
 /**
@@ -92,3 +125,120 @@ export function listTasks(projectRoot: string): ParsedTask[] {
 export function getTaskDir(projectRoot: string, taskId: string): string {
   return path.join(projectRoot, "tasks", taskId);
 }
+
+/**
+ * Get the creation time (birthtime) of a TASK.md file in ms since epoch.
+ */
+export function getTaskCreatedAt(taskDir: string): number {
+  const filePath = path.join(taskDir, "TASK.md");
+  try {
+    return fs.statSync(filePath).birthtimeMs;
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Write task status to status.json in the task directory.
+ */
+export function writeTaskStatus(taskDir: string, status: TaskStatus): void {
+  const filePath = path.join(taskDir, "status.json");
+  fs.writeFileSync(filePath, JSON.stringify(status), "utf-8");
+}
+
+/**
+ * Read task status from status.json in the task directory.
+ * Returns undefined if the file doesn't exist.
+ */
+export function readTaskStatus(taskDir: string): TaskStatus | undefined {
+  const filePath = path.join(taskDir, "status.json");
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf-8")) as TaskStatus;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Append a history entry to the project-level history.jsonl file.
+ */
+export function appendHistory(projectRoot: string, entry: HistoryEntry): void {
+  const historyPath = path.join(projectRoot, "history.jsonl");
+  fs.appendFileSync(historyPath, JSON.stringify(entry) + "\n", "utf-8");
+}
+
+/**
+ * Delete a history entry and its associated result/task-snapshot files.
+ * Returns true if the entry was found and removed.
+ */
+export function deleteHistoryEntry(
+  projectRoot: string,
+  taskId: string,
+  resultFile: string,
+): boolean {
+  const historyPath = path.join(projectRoot, "history.jsonl");
+  if (!fs.existsSync(historyPath)) return false;
+
+  const lines = fs.readFileSync(historyPath, "utf-8").split("\n").filter(Boolean);
+  let found = false;
+  const remaining: string[] = [];
+
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line) as HistoryEntry;
+      if (entry.task_id === taskId && entry.result_file === resultFile) {
+        found = true;
+        continue; // skip this entry
+      }
+    } catch { /* keep malformed lines */ }
+    remaining.push(line);
+  }
+
+  if (!found) return false;
+
+  // Rewrite history.jsonl without the deleted entry
+  fs.writeFileSync(historyPath, remaining.length > 0 ? remaining.join("\n") + "\n" : "", "utf-8");
+
+  // Delete the result file
+  const resultPath = path.join(projectRoot, "tasks", taskId, resultFile);
+  if (fs.existsSync(resultPath)) {
+    fs.unlinkSync(resultPath);
+  }
+
+  // Delete the corresponding task snapshot (TASK-<timestamp>.md)
+  const tsMatch = resultFile.match(/^RESULT-(\d+)\.md$/);
+  if (tsMatch) {
+    const snapshotFile = `TASK-${tsMatch[1]}.md`;
+    const snapshotPath = path.join(projectRoot, "tasks", taskId, snapshotFile);
+    if (fs.existsSync(snapshotPath)) {
+      fs.unlinkSync(snapshotPath);
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Read history entries from history.jsonl with pagination.
+ * Returns entries sorted most-recent-first.
+ */
+export function readHistory(
+  projectRoot: string,
+  opts: { offset?: number; limit?: number; task_id?: string },
+): { entries: HistoryEntry[]; total: number } {
+  const historyPath = path.join(projectRoot, "history.jsonl");
+  if (!fs.existsSync(historyPath)) return { entries: [], total: 0 };
+
+  const lines = fs.readFileSync(historyPath, "utf-8").split("\n").filter(Boolean);
+  let all: HistoryEntry[] = [];
+  for (const line of lines) {
+    try { all.push(JSON.parse(line)); } catch { /* skip malformed */ }
+  }
+  all.reverse();
+  if (opts.task_id) {
+    all = all.filter((e) => e.task_id === opts.task_id);
+  }
+  const offset = opts.offset ?? 0;
+  const limit = opts.limit ?? 10;
+  return { entries: all.slice(offset, offset + limit), total: all.length };
+}

package/src/transports/http-transport.ts

@@ -0,0 +1,180 @@
+import * as http from "node:http";
+import { validateSession, hasSessions } from "../session-store.js";
+import type { HostConfig, RpcMessage } from "../types.js";
+
+type SseClient = http.ServerResponse;
+
+/**
+ * Start the HTTP transport: Express-like server with RPC, SSE, and health endpoints.
+ */
+export async function startHttpTransport(
+  config: HostConfig,
+  handleRpc: (req: RpcMessage) => Promise<unknown>,
+): Promise<void> {
+  const port = config.directPort ?? 7400;
+  const sseClients = new Set<SseClient>();
+
+  function broadcastSseEvent(data: unknown) {
+    const payload = `data: ${JSON.stringify(data)}\n\n`;
+    for (const client of sseClients) {
+      client.write(payload);
+    }
+  }
+
+  function setCorsHeaders(res: http.ServerResponse) {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Headers", "Authorization, Content-Type");
+    res.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS");
+  }
+
+  function checkAuth(req: http.IncomingMessage): boolean {
+    const auth = req.headers.authorization;
+    if (!auth || !auth.startsWith("Bearer ")) return false;
+    const token = auth.slice(7);
+    // Accept the original directToken or any valid session token
+    if (token === config.directToken) return true;
+    if (hasSessions() && validateSession(token)) return true;
+    return false;
+  }
+
+  function extractSessionToken(req: http.IncomingMessage): string | undefined {
+    const auth = req.headers.authorization;
+    if (!auth || !auth.startsWith("Bearer ")) return undefined;
+    return auth.slice(7);
+  }
+
+  function sendJson(res: http.ServerResponse, status: number, body: unknown) {
+    res.writeHead(status, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(body));
+  }
+
+  function readBody(req: http.IncomingMessage): Promise<string> {
+    return new Promise((resolve, reject) => {
+      const chunks: Buffer[] = [];
+      req.on("data", (chunk: Buffer) => chunks.push(chunk));
+      req.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+      req.on("error", reject);
+    });
+  }
+
+  function isLocalhost(req: http.IncomingMessage): boolean {
+    const addr = req.socket.remoteAddress;
+    return addr === "127.0.0.1" || addr === "::1" || addr === "::ffff:127.0.0.1";
+  }
+
+  const server = http.createServer(async (req, res) => {
+    setCorsHeaders(res);
+
+    // Handle CORS preflight
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+
+    const url = new URL(req.url ?? "/", `http://localhost:${port}`);
+    const pathname = url.pathname;
+
+    // Internal event endpoint — localhost only, no auth
+    if (req.method === "POST" && pathname === "/internal/event") {
+      if (!isLocalhost(req)) {
+        sendJson(res, 403, { error: "localhost only" });
+        return;
+      }
+      try {
+        const body = await readBody(req);
+        const event = JSON.parse(body);
+        broadcastSseEvent(event);
+        sendJson(res, 200, { ok: true });
+      } catch {
+        sendJson(res, 400, { error: "Invalid JSON" });
+      }
+      return;
+    }
+
+    // All other endpoints require auth
+    if (!checkAuth(req)) {
+      sendJson(res, 401, { error: "Unauthorized" });
+      return;
+    }
+
+    // SSE event stream
+    if (req.method === "GET" && pathname === "/events") {
+      res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+        "Access-Control-Allow-Origin": "*",
+      });
+      res.write(":ok\n\n");
+
+      // Send heartbeat every 5 seconds
+      const heartbeat = setInterval(() => {
+        res.write("data: {\"heartbeat\":true}\n\n");
+      }, 5000);
+
+      sseClients.add(res);
+      req.on("close", () => {
+        clearInterval(heartbeat);
+        sseClients.delete(res);
+      });
+      return;
+    }
+
+    // RPC endpoint: POST /rpc/<method>
+    if (req.method === "POST" && pathname.startsWith("/rpc/")) {
+      const method = pathname.slice("/rpc/".length);
+      if (!method) {
+        sendJson(res, 400, { error: "Missing RPC method" });
+        return;
+      }
+
+      let params: Record<string, unknown> = {};
+      try {
+        const body = await readBody(req);
+        if (body.trim().length > 0) {
+          params = JSON.parse(body);
+        }
+      } catch {
+        sendJson(res, 400, { error: "Invalid JSON" });
+        return;
+      }
+
+      const sessionToken = extractSessionToken(req);
+      console.log(`[http] RPC: ${method}`);
+
+      try {
+        const response = await handleRpc({ method, params, sessionToken });
+        console.log(`[http] RPC done: ${method}`, JSON.stringify(response).slice(0, 200));
+        sendJson(res, 200, response);
+      } catch (err) {
+        console.error(`[http] RPC error (${method}):`, err);
+        sendJson(res, 500, { error: String(err) });
+      }
+      return;
+    }
+
+    sendJson(res, 404, { error: "Not found" });
+  });
+
+  return new Promise<void>((resolve, reject) => {
+    server.listen(port, () => {
+      console.log(`[http] Listening on port ${port}`);
+      console.log(`[http] SSE clients can connect to /events`);
+
+      // Graceful shutdown
+      const shutdown = () => {
+        console.log("[http] Shutting down...");
+        for (const client of sseClients) {
+          client.end();
+        }
+        server.close(() => process.exit(0));
+      };
+
+      process.on("SIGINT", shutdown);
+      process.on("SIGTERM", shutdown);
+    });
+
+    server.on("error", reject);
+  });
+}

package/src/transports/nats-transport.ts

@@ -0,0 +1,82 @@
+import { StringCodec, type Msg, type Subscription } from "nats";
+import { connectNats } from "../nats-client.js";
+import type { HostConfig, RpcMessage } from "../types.js";
+
+/**
+ * Start the NATS transport: connect, subscribe to RPC subjects, dispatch to handler.
+ */
+export async function startNatsTransport(
+  config: HostConfig,
+  handleRpc: (req: RpcMessage) => Promise<unknown>,
+): Promise<void> {
+  const nc = await connectNats(config);
+  const sc = StringCodec();
+
+  const subject = `host.${config.hostId}.rpc.>`;
+  console.log(`[nats] Subscribing to: ${subject}`);
+  const sub = nc.subscribe(subject);
+
+  // Graceful shutdown
+  const shutdown = async () => {
+    console.log("[nats] Shutting down...");
+    sub.unsubscribe();
+    await nc.drain();
+    process.exit(0);
+  };
+
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+
+  async function processMessage(msg: Msg) {
+    // 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
+    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(`[nats] Failed to parse RPC params for ${method}`);
+          if (msg.reply) {
+            msg.respond(sc.encode(JSON.stringify({ error: "Invalid JSON" })));
+          }
+          return;
+        }
+      }
+    }
+
+    // Extract sessionToken from params (PWA includes it in the payload)
+    const sessionToken = typeof params.sessionToken === "string" ? params.sessionToken : undefined;
+    delete params.sessionToken;
+
+    console.log(`[nats] RPC: ${method}`);
+
+    let response: unknown;
+    try {
+      response = await handleRpc({ method, params, sessionToken });
+    } catch (err) {
+      console.error(`[nats] RPC error (${method}):`, err);
+      response = { error: String(err) };
+    }
+
+    console.log(`[nats] RPC done: ${method}`, JSON.stringify(response).slice(0, 200));
+    if (msg.reply) {
+      msg.respond(sc.encode(JSON.stringify(response)));
+    }
+  }
+
+  async function consumeSubscription(subscription: Subscription) {
+    for await (const msg of subscription) {
+      // Handle RPC without blocking the message loop so heartbeats keep flowing
+      processMessage(msg);
+    }
+  }
+
+  console.log("[nats] Waiting for RPC messages...");
+  await consumeSubscription(sub);
+}

package/src/types.ts

@@ -1,19 +1,30 @@
-export interface AgentConfig {
-  agentId: string;
-  userId: string;
-  natsUrl: string;
-  natsWsUrl: string;
-  natsToken: string;
+export interface HostConfig {
+  hostId: string;
   projectRoot: string;
+  mode: "nats" | "lan" | "auto";
+
+  // NATS fields (required when mode === "nats" or "auto")
+  natsUrl?: string;
+  natsWsUrl?: string;
+  natsToken?: string;
+
+  // Direct/LAN fields (required when mode === "lan" or "auto")
+  directPort?: number;
+  directToken?: string;
+
+  // Detected agent CLIs
+  agents?: Array<{ key: string; label: string }>;
 }
 
 export interface TaskFrontmatter {
   id: string;
+  name: string;
   user_prompt: string;
-  command_line: string;
+  agent: string;
   triggers: Trigger[];
   triggers_enabled: boolean;
   requires_confirmation: boolean;
+  permissions?: RequiredPermission[];
 }
 
 export interface Trigger {
@@ -26,16 +37,28 @@ export interface ParsedTask {
   body: string;
 }
 
-export interface ConfirmPayload {
-  type: "confirm";
+export type TaskRunningState = "start" | "finish" | "abort" | "fail";
+
+export interface TaskStatus {
+  running_state: TaskRunningState;
+  time_stamp: number;
+  pending_confirmation?: boolean;
+  pending_permission?: RequiredPermission[];
+  user_input?: string;
+}
+
+export interface HistoryEntry {
   task_id: string;
-  agent_id: string;
-  user_id: string;
-  details: Record<string, unknown>;
-  status: "pending" | "confirmed" | "aborted";
+  result_file: string;
+}
+
+export interface RequiredPermission {
+  name: string;
+  description: string;
 }
 
 export interface RpcMessage {
   method: string;
   params: Record<string, unknown>;
+  sessionToken?: string;
 }

package/src/commands/task-generation.md

@@ -1,28 +0,0 @@
-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:**