palmier 0.9.6 → 0.9.8

package/src/commands/serve.ts

@@ -1,211 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import { loadConfig } from "../config.js";
-import { connectNats } from "../nats-client.js";
-import { createRpcHandler } from "../rpc-handler.js";
-import { startNatsTransport } from "../transports/nats-transport.js";
-import { startHttpTransport } from "../transports/http-transport.js";
-import { getTaskDir, readTaskStatus, writeTaskStatus, parseTaskFile, appendRunMessage, listTasks, readFollowupStatus, deleteFollowupStatus } from "../task.js";
-import { publishHostEvent } from "../events.js";
-import { getPlatform } from "../platform/index.js";
-import { detectAgents } from "../agents/agent.js";
-import { saveConfig } from "../config.js";
-import type { HostConfig } from "../types.js";
-import { CONFIG_DIR } from "../config.js";
-import { StringCodec, type NatsConnection } from "nats";
-import { addNotification } from "../notification-store.js";
-import { addSmsMessage } from "../sms-store.js";
-import { enqueueEvent } from "../event-queues.js";
-
-const POLL_INTERVAL_MS = 30_000;
-const DAEMON_PID_FILE = path.join(CONFIG_DIR, "daemon.pid");
-
-/**
- * Reconcile tasks stuck in "started" whose process is no longer alive, and
- * clean up OS scheduler units for one-off tasks that have already terminated.
- * The system scheduler (Task Scheduler / systemd) is the authoritative source.
- */
-async function checkStaleTasks(
-  config: HostConfig,
-  nc: NatsConnection | undefined,
-): Promise<void> {
-  const tasksRoot = path.join(config.projectRoot, "tasks");
-  if (!fs.existsSync(tasksRoot)) return;
-
-  const platform = getPlatform();
-  const taskIds = fs.readdirSync(tasksRoot).filter((f) =>
-    fs.statSync(path.join(tasksRoot, f)).isDirectory()
-  );
-
-  for (const taskId of taskIds) {
-    const taskDir = getTaskDir(config.projectRoot, taskId);
-    const status = readTaskStatus(taskDir);
-    if (!status) continue;
-
-    let task;
-    try { task = parseTaskFile(taskDir); } catch { continue; }
-
-    if (status.running_state === "started" && !platform.isTaskRunning(taskId)) {
-      console.log(`[monitor] Task ${taskId} process exited unexpectedly, marking as failed.`);
-      const endTime = Date.now();
-      writeTaskStatus(taskDir, { running_state: "failed", time_stamp: endTime });
-
-      const runId = fs.readdirSync(taskDir)
-        .filter((f) => /^\d+$/.test(f) && fs.existsSync(path.join(taskDir, f, "TASKRUN.md")))
-        .sort()
-        .pop();
-
-      if (runId) {
-        appendRunMessage(taskDir, runId, {
-          role: "status",
-          time: endTime,
-          content: "",
-          type: "failed",
-        });
-      }
-
-      await publishHostEvent(nc, config.hostId, taskId, {
-        event_type: "running-state",
-        running_state: "failed",
-        name: task.frontmatter.name || taskId,
-      });
-    }
-
-    if (task.frontmatter.one_off && status.running_state !== "started") {
-      try { platform.removeTaskTimer(taskId); } catch { /* best-effort */ }
-    }
-
-    // Reconcile orphaned follow-ups: if a run has a persisted follow-up PID
-    // but that process is no longer alive, clear the file and mark the run
-    // as failed so the UI doesn't claim it's still running.
-    const runIds = fs.readdirSync(taskDir).filter((f) =>
-      /^\d+$/.test(f) && fs.existsSync(path.join(taskDir, f, "TASKRUN.md"))
-    );
-    for (const runId of runIds) {
-      const runDir = path.join(taskDir, runId);
-      const followup = readFollowupStatus(runDir);
-      if (!followup) continue;
-      try {
-        process.kill(followup.pid, 0);
-      } catch {
-        deleteFollowupStatus(runDir);
-        appendRunMessage(taskDir, runId, {
-          role: "status",
-          time: Date.now(),
-          content: "",
-          type: "failed",
-        });
-        await publishHostEvent(nc, config.hostId, taskId, { event_type: "result-updated", run_id: runId });
-      }
-    }
-  }
-}
-
-export async function serveCommand(): Promise<void> {
-  const config = loadConfig();
-
-  // PID file lets `palmier restart` find us regardless of how we were started
-  fs.writeFileSync(DAEMON_PID_FILE, String(process.pid), "utf-8");
-
-  console.log("Starting...");
-
-  const agents = await detectAgents();
-  config.agents = agents;
-  saveConfig(config);
-  console.log(`Detected agents: ${agents.map((a) => a.key).join(", ") || "none"}`);
-
-  let nc: NatsConnection | undefined;
-  try {
-    nc = await connectNats(config);
-    console.log("[nats] Connected");
-  } catch (err) {
-    console.warn(`[nats] Connection failed (server mode unavailable): ${err}`);
-  }
-
-  await checkStaleTasks(config, nc);
-
-  // Reinstall scheduler entries for all tasks (recovery after init/reinstall)
-  const platform = getPlatform();
-  const allTasks = listTasks(config.projectRoot);
-  for (const task of allTasks) {
-    try {
-      platform.installTaskTimer(config, task);
-    } catch (err) {
-      console.error(`Warning: failed to install timer for task ${task.frontmatter.id}: ${err}`);
-    }
-  }
-
-  setInterval(() => {
-    checkStaleTasks(config, nc).catch((err) => {
-      console.error("[monitor] Error checking stale tasks:", err);
-    });
-  }, POLL_INTERVAL_MS);
-
-  const handleRpc = createRpcHandler(config, nc);
-  const httpPort = config.httpPort ?? 7256;
-
-  if (nc) {
-    startNatsTransport(config, handleRpc, nc);
-
-    const sc = StringCodec();
-
-    // Match phone numbers regardless of formatting; letters preserved for shortcodes.
-    function normalizeSender(raw: string): string {
-      return raw.replace(/[\s\-()+]/g, "").toLowerCase();
-    }
-
-    function dispatchDeviceEvent(scheduleType: "on_new_notification" | "on_new_sms", payload: string, parsed?: unknown): void {
-      for (const task of listTasks(config.projectRoot)) {
-        if (task.frontmatter.schedule_type !== scheduleType) continue;
-        if (!task.frontmatter.schedule_enabled) continue;
-        if (scheduleType === "on_new_notification" && task.frontmatter.schedule_values && task.frontmatter.schedule_values.length > 0) {
-          const pkg = (parsed as { packageName?: string } | undefined)?.packageName;
-          if (!pkg || !task.frontmatter.schedule_values.includes(pkg)) continue;
-        }
-        if (scheduleType === "on_new_sms" && task.frontmatter.schedule_values && task.frontmatter.schedule_values.length > 0) {
-          const sender = (parsed as { sender?: string } | undefined)?.sender;
-          const normalizedSender = sender ? normalizeSender(sender) : "";
-          if (!normalizedSender || !task.frontmatter.schedule_values.some((s) => normalizeSender(s) === normalizedSender)) continue;
-        }
-        const { shouldStart } = enqueueEvent(task.frontmatter.id, payload);
-        if (shouldStart) {
-          platform.startTask(task.frontmatter.id).catch((err) => {
-            console.error(`[event-trigger] Failed to start ${task.frontmatter.id}:`, err);
-          });
-        }
-      }
-    }
-
-    const notifSub = nc.subscribe(`host.${config.hostId}.device.notifications`);
-    (async () => {
-      for await (const msg of notifSub) {
-        const raw = sc.decode(msg.data);
-        let parsed: unknown;
-        try {
-          parsed = JSON.parse(raw);
-          addNotification({ ...(parsed as object), receivedAt: Date.now() } as Parameters<typeof addNotification>[0]);
-        } catch (err) {
-          console.error("[nats] Failed to parse device notification:", err);
-        }
-        dispatchDeviceEvent("on_new_notification", raw, parsed);
-      }
-    })();
-
-    const smsSub = nc.subscribe(`host.${config.hostId}.device.sms`);
-    (async () => {
-      for await (const msg of smsSub) {
-        const raw = sc.decode(msg.data);
-        let parsed: unknown;
-        try {
-          parsed = JSON.parse(raw);
-          addSmsMessage({ ...(parsed as object), receivedAt: Date.now() } as Parameters<typeof addSmsMessage>[0]);
-        } catch (err) {
-          console.error("[nats] Failed to parse device SMS:", err);
-        }
-        dispatchDeviceEvent("on_new_sms", raw, parsed);
-      }
-    })();
-  }
-
-  await startHttpTransport(config, handleRpc, httpPort, nc);
-}

package/src/commands/uninstall.ts

@@ -1,9 +0,0 @@
-import { getPlatform } from "../platform/index.js";
-
-export async function uninstallCommand(): Promise<void> {
-  const platform = getPlatform();
-  platform.uninstallDaemon();
-
-  console.log("\nTo uninstall the package: npm uninstall -g palmier");
-  console.log("To also remove configuration and task data, see https://github.com/caihongxu/palmier#uninstalling");
-}

package/src/config.ts

@@ -1,36 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import { homedir } from "os";
-import type { HostConfig } from "./types.js";
-
-const CONFIG_DIR = path.join(homedir(), ".config", "palmier");
-const CONFIG_FILE = path.join(CONFIG_DIR, "host.json");
-
-export function loadConfig(): HostConfig {
-  if (!fs.existsSync(CONFIG_FILE)) {
-    throw new Error(
-      "Host not provisioned. Run `palmier init` first.\n" +
-        `Expected config at: ${CONFIG_FILE}`
-    );
-  }
-
-  const raw = fs.readFileSync(CONFIG_FILE, "utf-8");
-  const config = JSON.parse(raw) as HostConfig;
-
-  if (!config.hostId) {
-    throw new Error("Invalid host config: missing hostId");
-  }
-
-  if (!config.natsUrl || !config.natsJwt || !config.natsNkeySeed) {
-    throw new Error("Invalid host config: missing NATS JWT credentials. Re-run palmier init.");
-  }
-
-  return config;
-}
-
-export function saveConfig(config: HostConfig): void {
-  fs.mkdirSync(CONFIG_DIR, { recursive: true });
-  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), "utf-8");
-}
-
-export { CONFIG_DIR, CONFIG_FILE };

package/src/cross-spawn.d.ts

@@ -1,5 +0,0 @@
-declare module "cross-spawn" {
-  import type { ChildProcess, SpawnOptions } from "child_process";
-  function spawn(command: string, args?: string[], options?: SpawnOptions): ChildProcess;
-  export default spawn;
-}

package/src/event-queues.ts

@@ -1,41 +0,0 @@
-/**
- * Per-task in-memory event queues for on_new_notification / on_new_sms schedules.
- * The daemon owns the NATS subscription and populates these queues; the
- * `palmier run` process drains via /task-event/pop.
- *
- * Invariants:
- *   - popEvent clears activeRuns atomically when the queue empties, so a
- *     fresh startTask cannot race the tearing-down run.
- *   - enqueueEvent returns shouldStart=true only on the idle→active edge.
- */
-
-const MAX_QUEUE_SIZE = 100;
-
-const queues = new Map<string, string[]>();
-const activeRuns = new Set<string>();
-
-export function enqueueEvent(taskId: string, payload: string): { shouldStart: boolean } {
-  const queue = queues.get(taskId) ?? [];
-  if (queue.length >= MAX_QUEUE_SIZE) queue.shift();
-  queue.push(payload);
-  queues.set(taskId, queue);
-
-  if (activeRuns.has(taskId)) return { shouldStart: false };
-  activeRuns.add(taskId);
-  return { shouldStart: true };
-}
-
-export function popEvent(taskId: string): { event: string } | { empty: true } {
-  const queue = queues.get(taskId);
-  if (queue && queue.length > 0) {
-    return { event: queue.shift()! };
-  }
-  activeRuns.delete(taskId);
-  return { empty: true };
-}
-
-/** Remove any state for a task (called from task.delete). */
-export function clearTaskQueue(taskId: string): void {
-  queues.delete(taskId);
-  activeRuns.delete(taskId);
-}

package/src/events.ts

@@ -1,29 +0,0 @@
-import { StringCodec, type NatsConnection } from "nats";
-import { loadConfig } from "./config.js";
-
-const sc = StringCodec();
-
-export async function publishHostEvent(
-  nc: NatsConnection | undefined,
-  hostId: string,
-  taskId: string,
-  payload: Record<string, unknown>,
-): Promise<void> {
-  const subject = `host-event.${hostId}.${taskId}`;
-
-  if (nc) {
-    nc.publish(subject, sc.encode(JSON.stringify(payload)));
-    console.log(`[nats] ${subject} →`, payload);
-  }
-
-  const config = loadConfig();
-  const port = config.httpPort ?? 7256;
-  try {
-    await fetch(`http://localhost:${port}/event`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ task_id: taskId, ...payload }),
-    });
-    console.log(`[http] host-event: ${taskId} →`, payload);
-  } catch { /* serve HTTP may not be ready yet */ }
-}

package/src/index.ts

@@ -1,111 +0,0 @@
-#!/usr/bin/env node
-
-import "dotenv/config";
-import { readFileSync } from "fs";
-import { fileURLToPath } from "url";
-import { dirname, join } from "path";
-import { Command } from "commander";
-import { initCommand } from "./commands/init.js";
-import { infoCommand } from "./commands/info.js";
-import { runCommand } from "./commands/run.js";
-import { serveCommand } from "./commands/serve.js";
-
-import { pairCommand } from "./commands/pair.js";
-import { restartCommand } from "./commands/restart.js";
-import { clientsListCommand, clientsRevokeCommand, clientsRevokeAllCommand } from "./commands/clients.js";
-import { uninstallCommand } from "./commands/uninstall.js";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const pkg = JSON.parse(readFileSync(join(__dirname, "../package.json"), "utf-8"));
-
-const program = new Command();
-
-program
-  .name("palmier")
-  .description("Palmier host CLI")
-  .version(pkg.version);
-
-program
-  .command("init")
-  .description("Provision this host")
-  .action(async () => {
-    await initCommand();
-  });
-
-program
-  .command("info")
-  .description("Show host connection info")
-  .action(async () => {
-    await infoCommand();
-  });
-
-program
-  .command("run <task-id>")
-  .description("Execute a task by ID")
-  .action(async (taskId: string) => {
-    await runCommand(taskId);
-  });
-
-program
-  .command("serve")
-  .description("Start the persistent RPC handler")
-  .action(async () => {
-    await serveCommand();
-  });
-
-program
-  .command("restart")
-  .description("Restart the palmier serve daemon")
-  .action(async () => {
-    await restartCommand();
-  });
-
-
-program
-  .command("pair")
-  .description("Generate a pairing code for connecting a PWA client")
-  .action(async () => {
-    await pairCommand();
-  });
-
-
-const clientsCmd = program
-  .command("clients")
-  .description("Manage paired clients");
-
-clientsCmd
-  .command("list")
-  .description("List active clients")
-  .action(async () => {
-    await clientsListCommand();
-  });
-
-clientsCmd
-  .command("revoke <token>")
-  .description("Revoke a client by token")
-  .action(async (token: string) => {
-    await clientsRevokeCommand(token);
-  });
-
-clientsCmd
-  .command("revoke-all")
-  .description("Revoke all clients")
-  .action(async () => {
-    await clientsRevokeAllCommand();
-  });
-
-program
-  .command("uninstall")
-  .description("Stop the daemon and remove all scheduled tasks")
-  .action(async () => {
-    await uninstallCommand();
-  });
-
-if (process.argv.length <= 2) {
-  process.argv.push("serve");
-}
-
-program.parseAsync(process.argv).catch((err) => {
-  console.error(err);
-  process.exit(1);
-});

package/src/linked-device.ts

@@ -1,52 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import { CONFIG_DIR } from "./config.js";
-
-const LINKED_DEVICE_FILE = path.join(CONFIG_DIR, "linked-device.json");
-
-export interface LinkedDevice {
-  clientToken: string;
-  fcmToken: string;
-}
-
-function read(): LinkedDevice | null {
-  try {
-    if (!fs.existsSync(LINKED_DEVICE_FILE)) return null;
-    const raw = fs.readFileSync(LINKED_DEVICE_FILE, "utf-8");
-    const parsed = JSON.parse(raw) as Partial<LinkedDevice>;
-    if (!parsed?.clientToken || !parsed?.fcmToken) return null;
-    return { clientToken: parsed.clientToken, fcmToken: parsed.fcmToken };
-  } catch {
-    return null;
-  }
-}
-
-function write(device: LinkedDevice | null): void {
-  fs.mkdirSync(CONFIG_DIR, { recursive: true });
-  if (!device) {
-    if (fs.existsSync(LINKED_DEVICE_FILE)) fs.unlinkSync(LINKED_DEVICE_FILE);
-    return;
-  }
-  fs.writeFileSync(LINKED_DEVICE_FILE, JSON.stringify(device, null, 2), "utf-8");
-}
-
-export function getLinkedDevice(): LinkedDevice | null {
-  return read();
-}
-
-export function setLinkedDevice(clientToken: string, fcmToken: string): void {
-  write({ clientToken, fcmToken });
-}
-
-export function clearLinkedDevice(): void {
-  write(null);
-}
-
-export function clearLinkedDeviceIfMatches(clientToken: string): boolean {
-  const current = read();
-  if (current?.clientToken === clientToken) {
-    write(null);
-    return true;
-  }
-  return false;
-}

package/src/mcp-handler.ts

@@ -1,200 +0,0 @@
-import { randomUUID } from "crypto";
-import { agentTools, agentToolMap, agentResources, agentResourceMap, ToolError, type ToolContext } from "./mcp-tools.js";
-
-interface JsonRpcRequest {
-  jsonrpc: string;
-  id?: string | number | null;
-  method: string;
-  params?: Record<string, unknown>;
-}
-
-export interface McpResponse {
-  body: object;
-  sessionId?: string;
-  /** If true, the HTTP transport should keep the response open as an SSE stream for server-initiated notifications. */
-  stream?: boolean;
-}
-
-/** sessionId → subscribed resource URIs */
-const resourceSubscriptions = new Map<string, Set<string>>();
-
-export function getResourceSubscriptions(): Map<string, Set<string>> {
-  return resourceSubscriptions;
-}
-
-const SESSION_TTL_MS = 24 * 60 * 60 * 1000;
-const sessionAgents = new Map<string, { agentName: string; expiresAt: number }>();
-
-export function getAgentName(sessionId: string): string | undefined {
-  const entry = sessionAgents.get(sessionId);
-  if (!entry) return undefined;
-  if (Date.now() > entry.expiresAt) {
-    sessionAgents.delete(sessionId);
-    return undefined;
-  }
-  return entry.agentName;
-}
-
-function pruneExpiredSessions(): void {
-  const now = Date.now();
-  for (const [id, entry] of sessionAgents) {
-    if (now > entry.expiresAt) {
-      sessionAgents.delete(id);
-      resourceSubscriptions.delete(id);
-    }
-  }
-}
-
-function rpcError(id: string | number | null, code: number, message: string): object {
-  return { jsonrpc: "2.0", id, error: { code, message } };
-}
-
-function rpcResult(id: string | number | null, result: unknown): object {
-  return { jsonrpc: "2.0", id, result };
-}
-
-export async function handleMcpRequest(body: string, sessionId: string | undefined, ctx: ToolContext): Promise<McpResponse> {
-  let req: JsonRpcRequest;
-  try {
-    req = JSON.parse(body);
-  } catch {
-    return { body: rpcError(null, -32700, "Parse error") };
-  }
-
-  const id = req.id ?? null;
-
-  if (req.jsonrpc !== "2.0") {
-    return { body: rpcError(id, -32600, "Invalid Request: missing jsonrpc 2.0") };
-  }
-
-  const agent = sessionId ? getAgentName(sessionId) : undefined;
-  const sid = sessionId?.slice(0, 8) ?? "none";
-  const logPrefix = agent ? `[mcp] [${sid}] [${agent}]` : `[mcp] [${sid}]`;
-  console.log(`${logPrefix} ${req.method}${req.method === "tools/call" ? ` → ${req.params?.name}` : ""}`);
-
-  switch (req.method) {
-    case "initialize": {
-      const newSessionId = randomUUID();
-      const clientInfo = req.params?.clientInfo as { name?: string; version?: string } | undefined;
-      const agentName = clientInfo
-        ? `${clientInfo.name || "unknown"}${clientInfo.version ? ` ${clientInfo.version}` : ""}`
-        : undefined;
-
-      if (agentName) {
-        sessionAgents.set(newSessionId, { agentName, expiresAt: Date.now() + SESSION_TTL_MS });
-        pruneExpiredSessions();
-      }
-
-      console.log(`[mcp] [${newSessionId.slice(0, 8)}] Session initialized${agentName ? ` (${agentName})` : ""}`);
-      return {
-        body: rpcResult(id, {
-          protocolVersion: "2025-03-26",
-          capabilities: { tools: {}, resources: { subscribe: true } },
-          serverInfo: { name: "palmier", version: "1.0.0" },
-        }),
-        sessionId: newSessionId,
-      };
-    }
-
-    case "tools/list": {
-      return {
-        body: rpcResult(id, {
-          tools: agentTools.map((t) => ({
-            name: t.name,
-            description: t.description.join(" "),
-            inputSchema: t.inputSchema,
-          })),
-        }),
-      };
-    }
-
-    case "tools/call": {
-      const name = req.params?.name as string | undefined;
-      const args = (req.params?.arguments ?? {}) as Record<string, unknown>;
-
-      if (!name) return { body: rpcError(id, -32602, "Missing params.name") };
-
-      const tool = agentToolMap.get(name);
-      if (!tool) return { body: rpcError(id, -32602, `Unknown tool: ${name}`) };
-
-      try {
-        const result = await tool.handler(args, ctx);
-        console.log(`${logPrefix} tools/call ${name} done:`, JSON.stringify(result).slice(0, 200));
-        return {
-          body: rpcResult(id, {
-            content: [{ type: "text", text: JSON.stringify(result) }],
-          }),
-        };
-      } catch (err: any) {
-        const message = err instanceof ToolError ? err.message : String(err);
-        console.error(`${logPrefix} tools/call ${name} error:`, message);
-        return {
-          body: rpcResult(id, {
-            content: [{ type: "text", text: JSON.stringify({ error: message }) }],
-            isError: true,
-          }),
-        };
-      }
-    }
-
-    case "resources/list": {
-      return {
-        body: rpcResult(id, {
-          resources: agentResources.map((r) => ({
-            uri: r.uri,
-            name: r.name,
-            description: r.description[0],
-            mimeType: r.mimeType,
-          })),
-        }),
-      };
-    }
-
-    case "resources/read": {
-      const uri = req.params?.uri as string;
-      const resource = agentResourceMap.get(uri);
-      if (!resource) {
-        return { body: rpcError(id, -32602, `Unknown resource: ${uri}`) };
-      }
-      console.log(`${logPrefix} resources/read ${uri}`);
-      const content = resource.read();
-      console.log(`${logPrefix} resources/read ${uri} done: ${JSON.stringify(content).slice(0, 200)}`);
-      return {
-        body: rpcResult(id, {
-          contents: [{
-            uri: resource.uri,
-            mimeType: resource.mimeType,
-            text: JSON.stringify(content),
-          }],
-        }),
-      };
-    }
-
-    case "resources/subscribe": {
-      const uri = req.params?.uri as string;
-      if (!agentResourceMap.has(uri)) {
-        return { body: rpcError(id, -32602, `Unknown resource: ${uri}`) };
-      }
-      if (!sessionId) {
-        return { body: rpcError(id, -32600, "Session required for subscriptions") };
-      }
-      if (!resourceSubscriptions.has(sessionId)) {
-        resourceSubscriptions.set(sessionId, new Set());
-      }
-      resourceSubscriptions.get(sessionId)!.add(uri);
-      return { body: rpcResult(id, {}), stream: true };
-    }
-
-    case "resources/unsubscribe": {
-      const uri = req.params?.uri as string;
-      if (sessionId) {
-        resourceSubscriptions.get(sessionId)?.delete(uri);
-      }
-      return { body: rpcResult(id, {}) };
-    }
-
-    default:
-      console.warn(`${logPrefix} Unknown method: ${req.method}`);
-      return { body: rpcError(id, -32601, `Method not found: ${req.method}`) };
-  }
-}