palmier 0.2.0 → 0.2.2

package/src/agents/claude.ts

@@ -0,0 +1,39 @@
+import type { ParsedTask, RequiredPermission } from "../types.js";
+import { execSync } from "child_process";
+import type { AgentTool, CommandLine } from "./agent.js";
+import { TASK_OUTCOME_SUFFIX } from "./shared-prompt.js";
+
+export class ClaudeAgent implements AgentTool {
+  getPlanGenerationCommandLine(prompt: string): CommandLine {
+    return {
+      command: "claude",
+      args: ["-p", prompt],
+    };
+  }
+
+  getTaskRunCommandLine(task: ParsedTask, prompt?: string, extraPermissions?: RequiredPermission[]): CommandLine {
+    prompt = (prompt ?? (task.body || task.frontmatter.user_prompt)) + TASK_OUTCOME_SUFFIX;
+    const args = ["-c", "--permission-mode", "acceptEdits", "-p", prompt];
+
+    const allPerms = [...(task.frontmatter.permissions ?? []), ...(extraPermissions ?? [])];
+    for (const p of allPerms) {
+      args.push("--allowedTools", p.name);
+    }
+
+    return { command: "claude", args };
+  }
+
+  async init(): Promise<boolean> {
+    try {
+      execSync("claude --version");
+    } catch {
+      return false;
+    }
+    try {
+      execSync("claude mcp add --transport stdio palmier --scope user -- palmier mcpserver");
+    } catch (err) {
+      console.warn("Warning: failed to install MCP for Claude:", err instanceof Error ? err.message : err);
+    }
+    return true;
+  }
+}

package/src/agents/codex.ts

@@ -0,0 +1,46 @@
+import type { ParsedTask, RequiredPermission } from "../types.js";
+import { execSync } from "child_process";
+import type { AgentTool, CommandLine } from "./agent.js";
+import { TASK_OUTCOME_SUFFIX } from "./shared-prompt.js";
+
+export class CodexAgent implements AgentTool {
+  getPlanGenerationCommandLine(prompt: string): CommandLine {
+    // TODO: fill in
+    return {
+      command: "codex",
+      args: ["exec", "--skip-git-repo-check",prompt],
+    };
+  }
+
+  getTaskRunCommandLine(task: ParsedTask, prompt?: string, extraPermissions?: RequiredPermission[]): CommandLine {
+    prompt = (prompt ?? (task.body || task.frontmatter.user_prompt)) + TASK_OUTCOME_SUFFIX;
+    // TODO: Update sandbox to workspace-write once https://github.com/openai/codex/issues/12572
+    // is fixed.
+    const args = ["exec", "--full-auto", "--skip-git-repo-check", "--sandbox", "danger-full-access"];
+
+    const allPerms = [...(task.frontmatter.permissions ?? []), ...(extraPermissions ?? [])];
+    for (const p of allPerms) {
+      args.push("--config");
+      args.push(`apps.${p.name}.default_tools_approval_mode="approve"`);
+    }
+
+    args.push(prompt);
+    args.push("resume", "--last");
+
+    return { command: "codex", args };
+  }
+
+  async init(): Promise<boolean> {
+    try {
+      execSync("codex --version");
+    } catch {
+      return false;
+    }
+    try {
+      execSync("codex mcp add palmier palmier mcpserver");
+    } catch (err) {
+      console.warn("Warning: failed to install MCP for Codex:", err instanceof Error ? err.message : err);
+    }
+    return true;
+  }
+}

package/src/agents/gemini.ts

@@ -0,0 +1,43 @@
+import type { ParsedTask, RequiredPermission } from "../types.js";
+import { execSync } from "child_process";
+import type { AgentTool, CommandLine } from "./agent.js";
+import { TASK_OUTCOME_SUFFIX } from "./shared-prompt.js";
+
+export class GeminiAgent implements AgentTool {
+  getPlanGenerationCommandLine(prompt: string): CommandLine {
+    // TODO: fill in
+    return {
+      command: "gemini",
+      args: ["--approval-mode", "auto_edit","--prompt", prompt],
+    };
+  }
+
+  getTaskRunCommandLine(task: ParsedTask, prompt?: string, extraPermissions?: RequiredPermission[]): CommandLine {
+    prompt = prompt ?? (task.body || task.frontmatter.user_prompt);
+    const args = ["--resume", "--prompt", prompt + TASK_OUTCOME_SUFFIX];
+
+    const allPerms = [...(task.frontmatter.permissions ?? []), ...(extraPermissions ?? [])];
+    if (allPerms.length > 0) {
+      args.push("--allowed-tools");
+      for (const p of allPerms) {
+        args.push(p.name);
+      }
+    }
+
+    return { command: "gemini", args };
+  }
+
+  async init(): Promise<boolean> {
+    try {
+      execSync("gemini --version");
+    } catch {
+      return false;
+    }
+    try {
+      execSync("gemini mcp add --scope user palmier palmier mcpserver");
+    } catch (err) {
+      console.warn("Warning: failed to install MCP for Gemini:", err instanceof Error ? err.message : err);
+    }
+    return true;
+  }
+}

package/src/agents/openclaw.ts

@@ -0,0 +1,29 @@
+import type { ParsedTask, RequiredPermission } from "../types.js";
+import { execSync } from "child_process";
+import type { AgentTool, CommandLine } from "./agent.js";
+import { TASK_OUTCOME_SUFFIX } from "./shared-prompt.js";
+
+export class ClaudeAgent implements AgentTool {
+  getPlanGenerationCommandLine(prompt: string): CommandLine {
+    return {
+      command: "openclaw",
+      args: ["agent", "--message", prompt],
+    };
+  }
+
+  getTaskRunCommandLine(task: ParsedTask, prompt?: string, extraPermissions?: RequiredPermission[]): CommandLine {
+    prompt = (prompt ?? (task.body || task.frontmatter.user_prompt)) + TASK_OUTCOME_SUFFIX;
+    const args = ["agent", "--message", prompt];
+
+    return { command: "openclaw", args };
+  }
+
+  async init(): Promise<boolean> {
+    try {
+      execSync("openclaw --version");
+    } catch {
+      return false;
+    }
+    return true;
+  }
+}

package/src/agents/shared-prompt.ts

@@ -0,0 +1,26 @@
+/**
+ * Appended to the end of every task prompt.
+ * Instructs the agent to output a clear success/failure marker
+ * so that palmier can determine the task outcome.
+ */
+export const TASK_OUTCOME_SUFFIX = `
+
+---
+If you generate report or output files, print each file name on its own line prefixed with [PALMIER_REPORT]: e.g.
+[PALMIER_REPORT] report.md
+[PALMIER_REPORT] summary.md
+
+When you are done, output exactly one of these markers as the very last line:
+- Success: [PALMIER_TASK_SUCCESS]
+- Failure: [PALMIER_TASK_FAILURE]
+Do not wrap them in code blocks or add text on the same line.
+
+If the task fails because a tool was denied or you lack the required permissions, print each required permission on its own line prefixed with [PALMIER_PERMISSION]: e.g.
+[PALMIER_PERMISSION] Read | Read file contents from the repository
+[PALMIER_PERMISSION] Bash(npm test) | Run the test suite via npm
+[PALMIER_PERMISSION] Write | Write generated output files`;
+
+export const TASK_SUCCESS_MARKER = "[PALMIER_TASK_SUCCESS]";
+export const TASK_FAILURE_MARKER = "[PALMIER_TASK_FAILURE]";
+export const TASK_REPORT_PREFIX = "[PALMIER_REPORT]";
+export const TASK_PERMISSION_PREFIX = "[PALMIER_PERMISSION]";

package/src/commands/agents.ts

@@ -0,0 +1,20 @@
+import { loadConfig, saveConfig } from "../config.js";
+import { detectAgents } from "../agents/agent.js";
+
+export async function agentsCommand(): Promise<void> {
+  const config = loadConfig();
+
+  console.log("Detecting installed agents...");
+  const agents = await detectAgents();
+  config.agents = agents;
+  saveConfig(config);
+
+  if (agents.length === 0) {
+    console.log("No agent CLIs detected.");
+  } else {
+    console.log("Detected agents:");
+    for (const a of agents) {
+      console.log(`  ${a.key} — ${a.label}`);
+    }
+  }
+}

package/src/commands/info.ts

@@ -0,0 +1,44 @@
+import * as os from "os";
+import { loadConfig } from "../config.js";
+
+/**
+ * Detect the first non-internal IPv4 address.
+ */
+function detectLanIp(): string {
+  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";
+}
+
+/**
+ * Print host connection info for setting up clients.
+ */
+export async function infoCommand(): Promise<void> {
+  const config = loadConfig();
+  const mode = config.mode ?? "nats";
+
+  console.log(`Mode:    ${mode}`);
+  console.log(`Host ID: ${config.hostId}`);
+
+  if (mode === "lan" || mode === "auto") {
+    const lanIp = detectLanIp();
+    const port = config.directPort ?? 7400;
+    console.log("");
+    console.log("Direct connection info:");
+    console.log(`  Address: ${lanIp}:${port}`);
+    console.log(`  Token:   ${config.directToken}`);
+  }
+
+  if (mode === "nats" || mode === "auto") {
+    console.log("");
+    console.log("NATS connection info:");
+    console.log(`  URL:   ${config.natsUrl}`);
+    console.log(`  WS:    ${config.natsWsUrl}`);
+  }
+}

package/src/commands/init.ts

@@ -1,121 +1,229 @@
-import * as fs from "fs";
-import * as path from "path";
-import { execSync } from "child_process";
-import { homedir } from "os";
-import { saveConfig } from "../config.js";
-import type { AgentConfig } from "../types.js";
-
-export interface InitOptions {
-  token: string;
-}
-
-/**
- * Provision this agent by exchanging a base64 provisioning token for permanent credentials.
- */
-export async function initCommand(options: InitOptions): Promise<void> {
-  // 1. Decode base64 provisioning token
-  let decoded: { server: string; token: string };
-  try {
-    const jsonStr = Buffer.from(options.token, "base64").toString("utf-8");
-    decoded = JSON.parse(jsonStr) as { server: string; token: string };
-  } catch {
-    console.error("Failed to decode provisioning token. Ensure it is a valid base64-encoded JSON string.");
-    process.exit(1);
-  }
-
-  if (!decoded.server || !decoded.token) {
-    console.error("Invalid provisioning token: missing 'server' or 'token' field.");
-    process.exit(1);
-  }
-
-  console.log(`Claiming agent at ${decoded.server}...`);
-
-  // 2. POST to server to claim agent
-  let claimResponse: {
-    agentId: string;
-    userId: string;
-    natsUrl: string;
-    natsWsUrl: string;
-    natsToken: string;
-  };
-
-  try {
-    const res = await fetch(`${decoded.server}/api/agents/claim`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ provisioning_token: options.token }),
-    });
-
-    if (!res.ok) {
-      const body = await res.text();
-      console.error(`Failed to claim agent: ${res.status} ${res.statusText}\n${body}`);
-      process.exit(1);
-    }
-
-    claimResponse = (await res.json()) as typeof claimResponse;
-  } catch (err) {
-    console.error(`Failed to reach server: ${err}`);
-    process.exit(1);
-  }
-
-  // 3. Save config
-  const config: AgentConfig = {
-    agentId: claimResponse.agentId,
-    userId: claimResponse.userId,
-    natsUrl: claimResponse.natsUrl,
-    natsWsUrl: claimResponse.natsWsUrl,
-    natsToken: claimResponse.natsToken,
-    projectRoot: process.cwd(),
-  };
-
-  saveConfig(config);
-  console.log(`Agent provisioned. ID: ${config.agentId}`);
-  console.log("Config saved to ~/.config/palmier/agent.json");
-
-  // 4. Install systemd user service for palmier serve
-  const unitDir = path.join(homedir(), ".config", "systemd", "user");
-  fs.mkdirSync(unitDir, { recursive: true });
-
-  const palmierBin = process.argv[1] || "palmier";
-
-  const serviceContent = `[Unit]
-Description=Palmier Agent
-After=network-online.target
-Wants=network-online.target
-
-[Service]
-Type=simple
-ExecStart=${palmierBin} serve
-WorkingDirectory=${config.projectRoot}
-Restart=on-failure
-RestartSec=5
-Environment=PATH=${process.env.PATH || "/usr/local/bin:/usr/bin:/bin"}
-
-[Install]
-WantedBy=default.target
-`;
-
-  const servicePath = path.join(unitDir, "palmier-agent.service");
-  fs.writeFileSync(servicePath, serviceContent, "utf-8");
-  console.log("Systemd service installed at:", servicePath);
-
-  // 6. Enable and start the service
-  try {
-    execSync("systemctl --user daemon-reload", { stdio: "inherit" });
-    execSync("systemctl --user enable --now palmier-agent.service", { stdio: "inherit" });
-    console.log("Palmier agent 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-agent.service");
-  }
-
-  // 7. Enable lingering so service runs without 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("\nAgent initialization complete!");
-}
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import * as readline from "readline";
+import { randomUUID, randomBytes } from "crypto";
+import { execSync } from "child_process";
+import { homedir } from "os";
+import { saveConfig } from "../config.js";
+import { detectAgents } from "../agents/agent.js";
+import { pairCommand } from "./pair.js";
+import type { HostConfig } from "../types.js";
+
+export interface InitOptions {
+  server?: string;
+  lan?: boolean;
+  host?: string;
+  port?: number;
+}
+
+/**
+ * Provision this host. Two flows:
+ *   - palmier init --lan              → standalone LAN mode, no server needed
+ *   - palmier init --server <url>     → register with server, prompts for nats/auto mode
+ */
+export async function initCommand(options: InitOptions): Promise<void> {
+  if (options.lan) {
+    await initLan(options);
+  } else if (options.server) {
+    await initWithServer(options);
+  } else {
+    console.error("Either --lan or --server <url> is required.");
+    process.exit(1);
+  }
+}
+
+/**
+ * Flow A: Standalone LAN mode. No web server needed.
+ */
+async function initLan(options: InitOptions): Promise<void> {
+  const hostId = randomUUID();
+  const directToken = randomBytes(32).toString("hex");
+  const directPort = options.port ?? 7400;
+  const lanIp = options.host ?? detectLanIp();
+
+  const config: HostConfig = {
+    hostId,
+    mode: "lan",
+    directPort,
+    directToken,
+    projectRoot: process.cwd(),
+  };
+
+  console.log("Detecting installed agents...");
+  config.agents = await detectAgents();
+  saveConfig(config);
+
+  console.log(`Host provisioned (LAN mode). ID: ${hostId}`);
+  console.log("Config saved to ~/.config/palmier/host.json");
+
+  installSystemdService(config);
+
+  // Auto-enter pair mode so user can connect their PWA immediately
+  console.log("");
+  console.log("Starting pairing...");
+  await pairCommand();
+}
+
+/**
+ * Flow B: Register directly with server. No provisioning token needed.
+ */
+async function initWithServer(options: InitOptions): Promise<void> {
+  const serverUrl = options.server!;
+
+  console.log(`Registering host at ${serverUrl}...`);
+
+  let registerResponse: {
+    hostId: string;
+    natsUrl: string;
+    natsWsUrl: string;
+    natsToken: string;
+  };
+
+  try {
+    const res = await fetch(`${serverUrl}/api/hosts/register`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({}),
+    });
+
+    if (!res.ok) {
+      const body = await res.text();
+      console.error(`Failed to register host: ${res.status} ${res.statusText}\n${body}`);
+      process.exit(1);
+    }
+
+    registerResponse = (await res.json()) as typeof registerResponse;
+  } catch (err) {
+    console.error(`Failed to reach server: ${err}`);
+    process.exit(1);
+  }
+
+  // Prompt for connection mode
+  const mode = await promptMode();
+
+  // Build config
+  const config: HostConfig = {
+    hostId: registerResponse.hostId,
+    projectRoot: process.cwd(),
+    mode,
+    natsUrl: registerResponse.natsUrl,
+    natsWsUrl: registerResponse.natsWsUrl,
+    natsToken: registerResponse.natsToken,
+  };
+
+  if (mode === "auto") {
+    const directToken = randomBytes(32).toString("hex");
+    const directPort = options.port ?? 7400;
+    const lanIp = options.host ?? detectLanIp();
+
+    config.directPort = directPort;
+    config.directToken = directToken;
+
+    console.log("");
+    console.log("Direct connection info (for LAN clients):");
+    console.log(`  Address: ${lanIp}:${directPort}`);
+    console.log(`  Token:   ${directToken}`);
+  }
+
+  console.log("Detecting installed agents...");
+  config.agents = await detectAgents();
+  saveConfig(config);
+  console.log(`Host provisioned (${mode} mode). ID: ${config.hostId}`);
+  console.log("Config saved to ~/.config/palmier/host.json");
+
+  installSystemdService(config);
+
+  // Auto-enter pair mode so user can connect their PWA immediately
+  console.log("");
+  console.log("Starting pairing...");
+  await pairCommand();
+}
+
+/**
+ * Prompt user to select connection mode.
+ */
+async function promptMode(): Promise<"nats" | "auto"> {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const question = (q: string) => new Promise<string>((resolve) => rl.question(q, resolve));
+
+  console.log("");
+  console.log("Connection mode:");
+  console.log("  1) auto — Both LAN and NATS (recommended)");
+  console.log("  2) nats — NATS only");
+  console.log("");
+
+  const answer = await question("Select [1]: ");
+  rl.close();
+
+  if (answer.trim() === "2" || answer.trim().toLowerCase() === "nats") {
+    return "nats";
+  }
+  return "auto";
+}
+
+/**
+ * Detect the first non-internal IPv4 address.
+ */
+function detectLanIp(): string {
+  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";
+}
+
+/**
+ * Install systemd user service for palmier serve.
+ */
+function installSystemdService(config: HostConfig): void {
+  const unitDir = path.join(homedir(), ".config", "systemd", "user");
+  fs.mkdirSync(unitDir, { recursive: true });
+
+  const palmierBin = process.argv[1] || "palmier";
+
+  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=${process.env.PATH || "/usr/local/bin:/usr/bin:/bin"}
+
+[Install]
+WantedBy=default.target
+`;
+
+  const servicePath = path.join(unitDir, "palmier.service");
+  fs.writeFileSync(servicePath, serviceContent, "utf-8");
+  console.log("Systemd service installed at:", servicePath);
+
+  // Enable and start the service
+  try {
+    execSync("systemctl --user daemon-reload", { stdio: "inherit" });
+    execSync("systemctl --user enable --now 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");
+  }
+
+  // Enable lingering so service runs without 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!");
+}