palmier 0.9.6 → 0.9.7

package/src/nats-client.ts

@@ -1,19 +0,0 @@
-import { connect, jwtAuthenticator, type NatsConnection } from "nats";
-import type { HostConfig } from "./types.js";
-
-export async function connectNats(config: HostConfig): Promise<NatsConnection> {
-  if (!config.natsJwt || !config.natsNkeySeed) {
-    throw new Error("NATS JWT credentials not configured. Re-run palmier init.");
-  }
-
-  const nc = await connect({
-    servers: config.natsUrl,
-    authenticator: jwtAuthenticator(
-      config.natsJwt,
-      new TextEncoder().encode(config.natsNkeySeed),
-    ),
-  });
-
-  // Do not log — it would pollute stdout for the MCP server.
-  return nc;
-}

package/src/network.ts

@@ -1,96 +0,0 @@
-import * as os from "node:os";
-import * as dgram from "node:dgram";
-
-/**
- * Resolve the name of the network interface used for the IPv4 default route.
- * Falls back to the first non-internal IPv4 interface when the gateway lookup
- * fails — `default-gateway` shells out to `wmic` on Windows, which was removed
- * in Windows 11 24H2.
- */
-function findInterfaceByIp(ip: string): string | null {
-  for (const [name, addrs] of Object.entries(os.networkInterfaces())) {
-    for (const addr of addrs ?? []) {
-      if (addr.family === "IPv4" && addr.address === ip) return name;
-    }
-  }
-  return null;
-}
-
-/** Ask the kernel which local IPv4 would route to an external address. No packet is sent. */
-function probeOutboundIp(): Promise<string | null> {
-  return new Promise((resolve) => {
-    const sock = dgram.createSocket("udp4");
-    const cleanup = (ip: string | null) => { try { sock.close(); } catch { /* ignore */ } resolve(ip); };
-    sock.on("error", () => cleanup(null));
-    try {
-      sock.connect(80, "8.8.8.8", () => {
-        const addr = sock.address();
-        cleanup(addr.address && addr.address !== "0.0.0.0" ? addr.address : null);
-      });
-    } catch {
-      cleanup(null);
-    }
-  });
-}
-
-type IpClass = 0 | 1 | 2 | 3;
-
-/** Lower score = more preferred. 0=192.168, 1=10.x, 2=172.16-31, 3=everything else. */
-function ipClass(ip: string): IpClass {
-  const parts = ip.split(".").map(Number);
-  if (parts.length !== 4 || parts.some((p) => Number.isNaN(p))) return 3;
-  const [a, b] = parts;
-  if (a === 192 && b === 168) return 0;
-  if (a === 10) return 1;
-  if (a === 172 && b >= 16 && b <= 31) return 2;
-  return 3;
-}
-
-/** Names that commonly belong to virtual/VPN adapters we'd rather skip. */
-const VIRTUAL_NAME_PATTERNS = [
-  "vethernet", "virtualbox", "vmware", "hyper-v", "docker", "bridge",
-  "tailscale", "wireguard", "meta", "vpn", "tun", "tap", "loopback",
-  "wsl", "utun",
-];
-
-function isVirtualName(name: string): boolean {
-  const lower = name.toLowerCase();
-  return VIRTUAL_NAME_PATTERNS.some((p) => lower.includes(p));
-}
-
-export async function detectDefaultInterface(): Promise<string | null> {
-  const probedIp = await probeOutboundIp();
-  if (probedIp) {
-    const name = findInterfaceByIp(probedIp);
-    if (name && !isVirtualName(name)) return name;
-  }
-
-  type Candidate = { name: string; klass: IpClass; virtual: boolean };
-  const candidates: Candidate[] = [];
-  for (const [name, addrs] of Object.entries(os.networkInterfaces())) {
-    for (const addr of addrs ?? []) {
-      if (addr.family !== "IPv4" || addr.internal) continue;
-      candidates.push({ name, klass: ipClass(addr.address), virtual: isVirtualName(name) });
-    }
-  }
-  candidates.sort((a, b) => {
-    if (a.virtual !== b.virtual) return a.virtual ? 1 : -1;
-    return a.klass - b.klass;
-  });
-  return candidates[0]?.name ?? null;
-}
-
-export function getInterfaceIpv4(interfaceName: string): string | null {
-  const addrs = os.networkInterfaces()[interfaceName];
-  if (!addrs) return null;
-  for (const addr of addrs) {
-    if (addr.family === "IPv4" && !addr.internal) return addr.address;
-  }
-  return null;
-}
-
-export function buildLanUrl(port: number, interfaceName: string | undefined): string | null {
-  if (!interfaceName) return null;
-  const ip = getInterfaceIpv4(interfaceName);
-  return ip ? `http://${ip}:${port}` : null;
-}

package/src/notification-store.ts

@@ -1,30 +0,0 @@
-export interface DeviceNotification {
-  id: string;
-  packageName: string;
-  appName: string;
-  title: string;
-  text: string;
-  timestamp: number;
-  receivedAt: number;
-}
-
-const MAX_NOTIFICATIONS = 50;
-const notifications: DeviceNotification[] = [];
-const listeners = new Set<() => void>();
-
-export function addNotification(n: DeviceNotification): void {
-  notifications.push(n);
-  if (notifications.length > MAX_NOTIFICATIONS) {
-    notifications.shift();
-  }
-  for (const cb of listeners) cb();
-}
-
-export function getNotifications(): DeviceNotification[] {
-  return [...notifications];
-}
-
-export function onNotificationsChanged(cb: () => void): () => void {
-  listeners.add(cb);
-  return () => { listeners.delete(cb); };
-}

package/src/pending-requests.ts

@@ -1,73 +0,0 @@
-import type { RequiredPermission } from "./types.js";
-
-export interface PendingRequestMeta {
-  /** Doubles as task_id for permission-type entries (the key the task uses). */
-  session_id?: string;
-  /** Human-readable label for whoever opened the prompt — agent name for
-   *  confirm/input, task name for permission. */
-  session_name?: string;
-  description?: string;
-  input_questions?: string[];
-}
-
-export interface PendingRequest {
-  type: "confirmation" | "permission" | "input";
-  resolve: (value: string[]) => void;
-  /** Permission list (for 'permission') or input descriptions (for 'input'). */
-  params?: RequiredPermission[] | string[];
-  /** Display context for PWAs that connect while this request is already open. */
-  meta?: PendingRequestMeta;
-}
-
-const pending = new Map<string, PendingRequest>();
-
-/**
- * Key is sessionId for confirmation/input, taskId for permission. Only one
- * pending request per key at a time. `meta` is surfaced via host.info so a
- * freshly-connected PWA can render the modal without replaying events.
- */
-export function registerPending(
-  key: string,
-  type: PendingRequest["type"],
-  params?: PendingRequest["params"],
-  meta?: PendingRequestMeta,
-): Promise<string[]> {
-  if (pending.has(key)) {
-    return Promise.reject(new Error(`Key ${key} already has a pending request`));
-  }
-
-  return new Promise<string[]>((resolve) => {
-    pending.set(key, { type, resolve, params, meta });
-  });
-}
-
-export function resolvePending(key: string, value: string[]): boolean {
-  const entry = pending.get(key);
-  if (!entry) return false;
-  pending.delete(key);
-  entry.resolve(value);
-  return true;
-}
-
-export function getPending(key: string): PendingRequest | undefined {
-  return pending.get(key);
-}
-
-export function removePending(key: string): void {
-  pending.delete(key);
-}
-
-/** Pending requests stripped of the unserializable `resolve` callback. */
-export function listPending(): Array<{
-  key: string;
-  type: PendingRequest["type"];
-  params?: PendingRequest["params"];
-  meta?: PendingRequestMeta;
-}> {
-  return [...pending.entries()].map(([key, entry]) => ({
-    key,
-    type: entry.type,
-    params: entry.params,
-    meta: entry.meta,
-  }));
-}

package/src/platform/index.ts

@@ -1,20 +0,0 @@
-import type { PlatformService } from "./platform.js";
-import { LinuxPlatform } from "./linux.js";
-import { WindowsPlatform } from "./windows.js";
-import { MacOsPlatform } from "./macos.js";
-
-/** Windows needs an explicit shell for execSync to resolve .cmd shims. */
-export const SHELL: string | undefined = process.platform === "win32" ? "cmd.exe" : undefined;
-
-let _instance: PlatformService | undefined;
-
-export function getPlatform(): PlatformService {
-  if (!_instance) {
-    if (process.platform === "win32") _instance = new WindowsPlatform();
-    else if (process.platform === "darwin") _instance = new MacOsPlatform();
-    else _instance = new LinuxPlatform();
-  }
-  return _instance;
-}
-
-export type { PlatformService } from "./platform.js";

package/src/platform/linux.ts

@@ -1,296 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import { homedir } from "os";
-import { execSync, exec } from "child_process";
-import { promisify } from "util";
-import type { PlatformService } from "./platform.js";
-import type { HostConfig, ParsedTask } from "../types.js";
-import { loadConfig } from "../config.js";
-import { getTaskDir, readTaskStatus } from "../task.js";
-
-const execAsync = promisify(exec);
-
-const UNIT_DIR = path.join(homedir(), ".config", "systemd", "user");
-const PATH_FILE = path.join(homedir(), ".config", "palmier", "user-path");
-
-function getTimerName(taskId: string): string {
-  return `palmier-task-${taskId}.timer`;
-}
-
-function getServiceName(taskId: string): string {
-  return `palmier-task-${taskId}.service`;
-}
-
-/**
- * Only the 4 cron patterns the PWA UI produces are supported:
- *   hourly "0 * * * *", daily "MM HH * * *", weekly "MM HH * * D", monthly "MM HH D * *".
- * Arbitrary expressions (ranges, lists, sub-hour steps) are not handled.
- */
-export function cronToOnCalendar(cron: string): string {
-  const parts = cron.trim().split(/\s+/);
-  if (parts.length !== 5) {
-    throw new Error(`Invalid cron expression (expected 5 fields): ${cron}`);
-  }
-
-  const [minute, hour, dayOfMonth, , dayOfWeek] = parts;
-
-  const dowMap: Record<string, string> = {
-    "0": "Sun", "1": "Mon", "2": "Tue", "3": "Wed",
-    "4": "Thu", "5": "Fri", "6": "Sat", "7": "Sun",
-  };
-
-  const monthPart = "*";
-  const dayPart = dayOfMonth === "*" ? "*" : dayOfMonth.padStart(2, "0");
-  const hourPart = hour === "*" ? "*" : hour.padStart(2, "0");
-  const minutePart = minute === "*" ? "*" : minute.padStart(2, "0");
-
-  if (dayOfWeek !== "*") {
-    const dow = dowMap[dayOfWeek] ?? dayOfWeek;
-    return `${dow} *-${monthPart}-${dayPart} ${hourPart}:${minutePart}:00`;
-  }
-
-  return `*-${monthPart}-${dayPart} ${hourPart}:${minutePart}:00`;
-}
-
-function daemonReload(): void {
-  try {
-    execSync("systemctl --user daemon-reload", { encoding: "utf-8" });
-  } catch (err: unknown) {
-    const e = err as { stderr?: string };
-    console.error(`daemon-reload failed: ${e.stderr || err}`);
-  }
-}
-
-export class LinuxPlatform implements PlatformService {
-  installDaemon(config: HostConfig): void {
-    fs.mkdirSync(UNIT_DIR, { recursive: true });
-
-    const palmierBin = process.argv[1] || "palmier";
-    // Save the user's shell PATH so restartDaemon can reuse it later — under
-    // systemd the daemon itself runs with a limited PATH.
-    const userPath = process.env.PATH || "/usr/local/bin:/usr/bin:/bin";
-    fs.mkdirSync(path.dirname(PATH_FILE), { recursive: true });
-    fs.writeFileSync(PATH_FILE, userPath, "utf-8");
-
-    const serviceContent = `[Unit]
-Description=Palmier Host
-After=network-online.target
-Wants=network-online.target
-
-[Service]
-Type=simple
-ExecStart=${palmierBin} serve
-WorkingDirectory=${config.projectRoot}
-Restart=on-failure
-RestartSec=5
-Environment=PATH=${userPath}
-
-[Install]
-WantedBy=default.target
-`;
-
-    const servicePath = path.join(UNIT_DIR, "palmier.service");
-    fs.writeFileSync(servicePath, serviceContent, "utf-8");
-    console.log("Systemd service installed at:", servicePath);
-
-    try {
-      execSync("systemctl --user daemon-reload", { stdio: "inherit" });
-      execSync("systemctl --user enable palmier.service", { stdio: "inherit" });
-      execSync("systemctl --user restart palmier.service", { stdio: "inherit" });
-      console.log("Palmier host service enabled and started.");
-    } catch (err) {
-      console.error(`Warning: failed to enable systemd service: ${err}`);
-      console.error("You may need to start it manually: systemctl --user enable --now palmier.service");
-    }
-
-    // Lingering lets the service run without an active login session.
-    try {
-      execSync(`loginctl enable-linger ${process.env.USER || ""}`, { stdio: "inherit" });
-      console.log("Login lingering enabled.");
-    } catch (err) {
-      console.error(`Warning: failed to enable linger: ${err}`);
-    }
-
-    console.log("\nHost initialization complete!");
-  }
-
-  uninstallDaemon(): void {
-    try {
-      execSync("systemctl --user stop palmier.service 2>/dev/null", { stdio: "pipe" });
-      execSync("systemctl --user disable palmier.service 2>/dev/null", { stdio: "pipe" });
-    } catch { /* service may not exist */ }
-
-    const servicePath = path.join(UNIT_DIR, "palmier.service");
-    try { fs.unlinkSync(servicePath); } catch { /* ignore */ }
-
-    try {
-      const files = fs.readdirSync(UNIT_DIR).filter((f) => f.startsWith("palmier-task-"));
-      for (const f of files) {
-        const unit = f.replace(/\.(timer|service)$/, "");
-        try { execSync(`systemctl --user stop ${f} 2>/dev/null`, { stdio: "pipe" }); } catch { /* ignore */ }
-        try { execSync(`systemctl --user disable ${f} 2>/dev/null`, { stdio: "pipe" }); } catch { /* ignore */ }
-        try { fs.unlinkSync(path.join(UNIT_DIR, f)); } catch { /* ignore */ }
-      }
-    } catch { /* ignore */ }
-
-    try { execSync("systemctl --user daemon-reload", { stdio: "pipe" }); } catch { /* ignore */ }
-
-    console.log("Palmier daemon and tasks uninstalled.");
-  }
-
-  async restartDaemon(): Promise<void> {
-    // From a TTY, snapshot the current PATH; from the daemon (auto-update),
-    // reuse whatever was last saved.
-    if (process.stdin.isTTY) {
-      fs.mkdirSync(path.dirname(PATH_FILE), { recursive: true });
-      fs.writeFileSync(PATH_FILE, process.env.PATH || "", "utf-8");
-    }
-
-    const servicePath = path.join(UNIT_DIR, "palmier.service");
-    if (fs.existsSync(servicePath) && fs.existsSync(PATH_FILE)) {
-      const userPath = fs.readFileSync(PATH_FILE, "utf-8").trim();
-      if (userPath) {
-        const content = fs.readFileSync(servicePath, "utf-8");
-        const updated = content.replace(
-          /^Environment=PATH=.*/m,
-          `Environment=PATH=${userPath}`,
-        );
-        if (updated !== content) {
-          fs.writeFileSync(servicePath, updated, "utf-8");
-          execSync("systemctl --user daemon-reload", { encoding: "utf-8" });
-        }
-      }
-    }
-    execSync("systemctl --user restart palmier.service", { stdio: "inherit" });
-    console.log("Palmier daemon restarted.");
-  }
-
-  installTaskTimer(config: HostConfig, task: ParsedTask): void {
-    fs.mkdirSync(UNIT_DIR, { recursive: true });
-
-    const taskId = task.frontmatter.id;
-    const serviceName = getServiceName(taskId);
-    const timerName = getTimerName(taskId);
-    const palmierBin = process.argv[1] || "palmier";
-
-    const serviceContent = `[Unit]
-Description=Palmier Task: ${taskId}
-
-[Service]
-Type=oneshot
-TimeoutStartSec=infinity
-ExecStart=${palmierBin} run ${taskId}
-WorkingDirectory=${config.projectRoot}
-Environment=PATH=${process.env.PATH || "/usr/local/bin:/usr/bin:/bin"}
-`;
-
-    fs.writeFileSync(path.join(UNIT_DIR, serviceName), serviceContent, "utf-8");
-
-    // Tear down any previously installed timer unit so on-demand tasks don't
-    // keep firing on the old schedule. Service unit stays so startTask works.
-    const timerPath = path.join(UNIT_DIR, timerName);
-    if (fs.existsSync(timerPath)) {
-      try { execSync(`systemctl --user stop ${timerName}`, { encoding: "utf-8" }); } catch { /* not running */ }
-      try { execSync(`systemctl --user disable ${timerName}`, { encoding: "utf-8" }); } catch { /* not enabled */ }
-      fs.unlinkSync(timerPath);
-    }
-    daemonReload();
-
-    if (!task.frontmatter.schedule_enabled) return;
-    const scheduleType = task.frontmatter.schedule_type;
-    const scheduleValues = task.frontmatter.schedule_values;
-    if (!scheduleType || !scheduleValues?.length) return;
-    const onCalendarLines: string[] = [];
-    for (const value of scheduleValues) {
-      if (scheduleType === "crons") {
-        onCalendarLines.push(`OnCalendar=${cronToOnCalendar(value)}`);
-      } else if (scheduleType === "specific_times") {
-        onCalendarLines.push(`OnActiveSec=${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: unknown) {
-        const e = err as { stderr?: string };
-        console.error(`Failed to enable timer ${timerName}: ${e.stderr || err}`);
-      }
-    }
-  }
-
-  removeTaskTimer(taskId: string): void {
-    const timerName = getTimerName(taskId);
-    const serviceName = getServiceName(taskId);
-    const timerPath = path.join(UNIT_DIR, timerName);
-    const servicePath = path.join(UNIT_DIR, serviceName);
-
-    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();
-  }
-
-  async startTask(taskId: string): Promise<void> {
-    const serviceName = getServiceName(taskId);
-    await execAsync(`systemctl --user start --no-block ${serviceName}`);
-  }
-
-  async stopTask(taskId: string): Promise<void> {
-    const serviceName = getServiceName(taskId);
-    await execAsync(`systemctl --user stop ${serviceName}`);
-  }
-
-  isTaskRunning(taskId: string): boolean {
-    const serviceName = getServiceName(taskId);
-    try {
-      const out = execSync(
-        `systemctl --user show -p ActiveState --value ${serviceName}`,
-        { encoding: "utf-8" },
-      );
-      const state = out.trim();
-      if (state === "active" || state === "activating") return true;
-    } catch { /* service may not exist */ }
-
-    // Follow-up runs are spawned directly, so check PID too.
-    try {
-      const taskDir = getTaskDir(loadConfig().projectRoot, taskId);
-      const status = readTaskStatus(taskDir);
-      if (status?.pid) {
-        process.kill(status.pid, 0); // signal 0 = check if process exists
-        return true;
-      }
-    } catch { /* process not running or config unavailable */ }
-
-    return false;
-  }
-
-  getGuiEnv(): Record<string, string> {
-    const uid = process.getuid?.();
-    const runtimeDir =
-      process.env.XDG_RUNTIME_DIR ||
-      (uid !== undefined ? `/run/user/${uid}` : "");
-
-    return {
-      DISPLAY: ":0",
-      ...(runtimeDir ? { XDG_RUNTIME_DIR: runtimeDir } : {}),
-    };
-  }
-}