palmier 1.1.23 → 1.1.24

package/DISCLAIMER.md

@@ -10,7 +10,7 @@ Palmier spawns third-party AI agent CLIs (such as Claude Code, Codex CLI, GitHub
 - **Execute arbitrary shell commands** with your user permissions
 - **Make network requests** and interact with external services
 
-AI agents may produce unexpected, incorrect, or harmful outputs. **You are solely responsible for reviewing and approving all actions taken by AI agents on your system.** The authors of Palmier have no control over the behavior of third-party AI agents and accept no liability for their actions.
+AI agents may produce unexpected, incorrect, or harmful outputs. **You are solely responsible for all actions taken by AI agents on your system, including actions taken without per-action approval.** The authors of Palmier have no control over the behavior of third-party AI agents and accept no liability for their actions.
 
 ## Agent CLI Installation
 
@@ -20,10 +20,12 @@ Agent CLIs that Palmier installed (those carrying a Palmier-managed version stam
 
 ## Unattended and Scheduled Execution
 
+Palmier runs agents with tool approvals bypassed whenever the agent CLI supports it. Agents can act without asking first.
+
 Tasks can be configured to run on schedules (cron) or in response to events without active supervision. You should:
 
 - Use the **confirmation** feature for sensitive tasks
-- Restrict **permissions** granted to agents to the minimum necessary
+- Limit what the **host's user account** can access, for example by using a dedicated account, container or VM
 - Regularly review **task history and results**
 - Maintain **backups** of any important data in directories where agents operate
 

package/dist/agents/agent-instructions.md

@@ -22,11 +22,6 @@ On the line right before that marker, in the same final message, print the model
 
 Do this at the end of every response, including responses to follow-up messages.
 
-## Permissions
-
-Whenever a tool you are trying to use is denied or you lack the required permissions, print each required permission on its own line to stdout using this exact format:
-[PALMIER_PERMISSION] <tool_name> | <description>
-
 ## Browsers
 
 Whenever the task needs a browser, launch it with the Playwright CLI (`playwright-cli open`). Do not use any other browser tool, automation library, or launch method.

package/dist/agents/agent.d.ts

@@ -25,9 +25,6 @@ export interface AgentTool {
      *  can sign in before configuration continues. Leave undefined for agents that auth on
      *  first run with no separate command. */
     authArgs?: string[];
-    /** Whether this agent supports permission overrides (e.g. --allowedTools).
-     *  When falsy, the permissions section is omitted from agent instructions. */
-    supportsPermissions?: boolean;
     /** When true, the run loop persists the agent's stderr output only if the invocation fails. */
     suppressStdErr?: boolean;
     /** Matches the model name (capture group 1) in the banner the CLI prints on stderr.
@@ -51,7 +48,6 @@ export declare function getNpmInstalledVersion(npmPackage: string): string | nul
 export interface DetectedAgent {
     key: string;
     label: string;
-    supportsPermissions?: boolean;
     npmPackage?: string;
     /** Runtime marker for "managed by Palmier" — present iff Palmier installed/manages this agent. */
     version?: string;

package/dist/agents/agent.js

@@ -120,7 +120,6 @@ export async function detectAgents(previous, newlyInstalled) {
         detected.push({
             key,
             label: agent.label,
-            supportsPermissions: agent.supportsPermissions,
             ...(agent.npmPackage ? { npmPackage: agent.npmPackage } : {}),
             ...(version ? { version } : {}),
         });

package/dist/agents/claude.js

@@ -5,7 +5,6 @@ export const claudeAgent = {
     promptArgs: ["-p"],
     probeArg: "--version",
     authArgs: ["auth", "login"],
-    supportsPermissions: true,
     npmPackage: "@anthropic-ai/claude-code",
     freeUsage: "Free with Claude Pro",
     getTaskRunCommandLine(task, followupPrompt) {

package/dist/agents/shared-prompt.d.ts

@@ -2,5 +2,4 @@ import type { ParsedTask } from "../types.js";
 export declare function getAgentInstructions(task: ParsedTask): string;
 export declare const TASK_SUCCESS_MARKER = "[PALMIER_TASK_SUCCESS]";
 export declare const TASK_FAILURE_MARKER = "[PALMIER_TASK_FAILURE]";
-export declare const TASK_PERMISSION_PREFIX = "[PALMIER_PERMISSION]";
 export declare const AGENT_MODEL_PREFIX = "[PALMIER_AGENT_MODEL]";

package/dist/agents/shared-prompt.js

@@ -10,10 +10,8 @@ export function getAgentInstructions(task) {
     const taskDescription = task.frontmatter.user_prompt;
     return AGENT_INSTRUCTIONS_TEMPLATE
         .replace(/\{\{ENDPOINT_DOCS\}\}/g, generateEndpointDocs(port, task.frontmatter.id))
-        .replace(/\{\{TASK_DESCRIPTION\}\}/g, taskDescription)
-        .replace(/## Permissions\r?\n[\s\S]*?(?=## |\r?\n---)/m, "");
+        .replace(/\{\{TASK_DESCRIPTION\}\}/g, taskDescription);
 }
 export const TASK_SUCCESS_MARKER = "[PALMIER_TASK_SUCCESS]";
 export const TASK_FAILURE_MARKER = "[PALMIER_TASK_FAILURE]";
-export const TASK_PERMISSION_PREFIX = "[PALMIER_PERMISSION]";
 export const AGENT_MODEL_PREFIX = "[PALMIER_AGENT_MODEL]";

package/dist/agents/wizard.js

@@ -60,7 +60,6 @@ export async function pickAndInstallAgent(current, options = {}) {
     const record = {
         key: choice.key,
         label: choice.label,
-        ...(tool.supportsPermissions ? { supportsPermissions: true } : {}),
         npmPackage: choice.npmPackage,
         ...(version ? { version } : {}),
     };

package/dist/commands/run.d.ts

@@ -1,10 +1,9 @@
 import type { AgentTool } from "../agents/agent.js";
-import type { TaskRunningState, RequiredPermission } from "../types.js";
+import type { TaskRunningState } from "../types.js";
 export declare function stripPalmierMarkers(output: string): string;
 export declare function runCommand(taskId: string): Promise<void>;
 /** Only links to files that exist count, so example links echoed from the prompt are ignored. */
 export declare function listLinkedTaskFiles(taskDir: string, runId: string, output: string): string[];
-export declare function parsePermissions(output: string): RequiredPermission[];
 export declare function parseAgentModel(output: string): string | undefined;
 /** Returns a function that accumulates stderr chunks and yields the model once the CLI banner reveals it. */
 export declare function createCliModelCapture(agent: AgentTool): (stderrChunk: string) => string | undefined;

package/dist/commands/run.js

@@ -2,157 +2,116 @@ import * as fs from "fs";
 import * as path from "path";
 import { spawnCommand } from "../spawn-command.js";
 import { loadConfig } from "../config.js";
-import { parseTaskFile, taskDisplayName, getTaskDir, writeTaskFile, writeTaskStatus, readTaskStatus, appendHistory, createRunDir, claimPendingRun, appendRunMessage, getRunDir, beginStreamingMessage, formatAgentModelComment } from "../task.js";
+import { parseTaskFile, taskDisplayName, getTaskDir, writeTaskStatus, readTaskStatus, appendHistory, createRunDir, claimPendingRun, appendRunMessage, getRunDir, beginStreamingMessage, formatAgentModelComment } from "../task.js";
 import { getAgent } from "../agents/agent.js";
 import { getPlatform } from "../platform/index.js";
-import { TASK_SUCCESS_MARKER, TASK_FAILURE_MARKER, TASK_PERMISSION_PREFIX, AGENT_MODEL_PREFIX } from "../agents/shared-prompt.js";
+import { TASK_SUCCESS_MARKER, TASK_FAILURE_MARKER, AGENT_MODEL_PREFIX } from "../agents/shared-prompt.js";
 import { extractFileLinks, resolveTaskFile } from "../task-files.js";
 import { publishHostEvent } from "../events.js";
 /**
- * Invoke the agent CLI in a continuation loop to handle permission requests.
  * `invokeTask` is the ParsedTask whose prompt is passed to the agent (for
  * triggered tasks this is the per-trigger augmented task).
  */
-async function invokeAgentWithRetries(ctx, invokeTask) {
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-        let writer;
-        let activeStream;
-        const lineBufs = { stdout: "", stderr: "" };
-        let suppressedStderr = "";
-        let notifyPending = false;
-        let notifyTimer;
-        let agentModel;
-        let agentModelWritten = false;
-        const captureCliModel = createCliModelCapture(ctx.agent);
-        function throttledNotify() {
-            if (notifyPending)
-                return;
-            notifyPending = true;
-            notifyTimer = setTimeout(() => {
-                notifyPending = false;
-                publishHostEvent(ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
-            }, 500);
-        }
-        function ensureWriter(stream) {
-            if (writer && activeStream === stream)
-                return writer;
-            if (writer)
-                writer.end();
-            writer = beginStreamingMessage(ctx.taskDir, ctx.runId, Date.now(), stream);
-            activeStream = stream;
+async function invokeAgent(ctx, invokeTask) {
+    let writer;
+    let activeStream;
+    const lineBufs = { stdout: "", stderr: "" };
+    let suppressedStderr = "";
+    let notifyPending = false;
+    let notifyTimer;
+    let agentModel;
+    let agentModelWritten = false;
+    const captureCliModel = createCliModelCapture(ctx.agent);
+    function throttledNotify() {
+        if (notifyPending)
+            return;
+        notifyPending = true;
+        notifyTimer = setTimeout(() => {
+            notifyPending = false;
+            publishHostEvent(ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
+        }, 500);
+    }
+    function ensureWriter(stream) {
+        if (writer && activeStream === stream)
             return writer;
+        if (writer)
+            writer.end();
+        writer = beginStreamingMessage(ctx.taskDir, ctx.runId, Date.now(), stream);
+        activeStream = stream;
+        return writer;
+    }
+    function flushAgentModel() {
+        if (!agentModel || agentModelWritten || !writer)
+            return;
+        writer.write(formatAgentModelComment(agentModel));
+        agentModelWritten = true;
+        throttledNotify();
+    }
+    function onStderr(chunk) {
+        if (ctx.agent.suppressStdErr)
+            suppressedStderr += chunk;
+        else
+            emit("stderr", chunk);
+        const cliModel = captureCliModel(chunk);
+        if (cliModel && !agentModelWritten)
+            agentModel = cliModel;
+        flushAgentModel();
+    }
+    function emit(stream, chunk) {
+        lineBufs[stream] += chunk;
+        const lines = lineBufs[stream].split("\n");
+        lineBufs[stream] = lines.pop() ?? "";
+        if (stream === "stdout" && !agentModel) {
+            agentModel = parseAgentModel(lines.join("\n"));
         }
-        function flushAgentModel() {
-            if (!agentModel || agentModelWritten || !writer)
-                return;
-            writer.write(formatAgentModelComment(agentModel));
-            agentModelWritten = true;
+        const filtered = lines.filter((l) => !l.startsWith("[PALMIER"));
+        if (filtered.length > 0) {
+            ensureWriter(stream).write(filtered.join("\n") + "\n");
             throttledNotify();
         }
-        function onStderr(chunk) {
-            if (ctx.agent.suppressStdErr)
-                suppressedStderr += chunk;
-            else
-                emit("stderr", chunk);
-            const cliModel = captureCliModel(chunk);
-            if (cliModel && !agentModelWritten)
-                agentModel = cliModel;
-            flushAgentModel();
-        }
-        function emit(stream, chunk) {
-            lineBufs[stream] += chunk;
-            const lines = lineBufs[stream].split("\n");
-            lineBufs[stream] = lines.pop() ?? "";
-            if (stream === "stdout" && !agentModel) {
-                agentModel = parseAgentModel(lines.join("\n"));
-            }
-            const filtered = lines.filter((l) => !l.startsWith("[PALMIER"));
-            if (filtered.length > 0) {
-                ensureWriter(stream).write(filtered.join("\n") + "\n");
-                throttledNotify();
-            }
-            flushAgentModel();
-        }
-        function flushTrailingLine(stream) {
-            const trailing = lineBufs[stream];
-            if (trailing && !trailing.startsWith("[PALMIER")) {
-                ensureWriter(stream).write(trailing);
-            }
-        }
-        const { args, stdin, env: agentEnv, files } = ctx.agent.getTaskRunCommandLine(invokeTask);
-        const command = ctx.agent.command;
-        const runDir = getRunDir(ctx.taskDir, ctx.runId);
-        if (files) {
-            for (const f of files)
-                fs.writeFileSync(path.join(runDir, f.path), f.content, "utf-8");
+        flushAgentModel();
+    }
+    function flushTrailingLine(stream) {
+        const trailing = lineBufs[stream];
+        if (trailing && !trailing.startsWith("[PALMIER")) {
+            ensureWriter(stream).write(trailing);
         }
-        const result = await spawnCommand(command, args, {
-            cwd: runDir,
-            env: { ...ctx.guiEnv, ...agentEnv, PALMIER_RUN_DIR: runDir, PALMIER_HTTP_PORT: String(ctx.config.httpPort ?? 7256) },
-            echoStdout: true,
-            resolveOnFailure: true,
-            stdin,
-            onStdout: (chunk) => emit("stdout", chunk),
-            onStderr,
+    }
+    const { args, stdin, env: agentEnv, files } = ctx.agent.getTaskRunCommandLine(invokeTask);
+    const command = ctx.agent.command;
+    const runDir = getRunDir(ctx.taskDir, ctx.runId);
+    if (files) {
+        for (const f of files)
+            fs.writeFileSync(path.join(runDir, f.path), f.content, "utf-8");
+    }
+    const result = await spawnCommand(command, args, {
+        cwd: runDir,
+        env: { ...ctx.guiEnv, ...agentEnv, PALMIER_RUN_DIR: runDir, PALMIER_HTTP_PORT: String(ctx.config.httpPort ?? 7256) },
+        echoStdout: true,
+        resolveOnFailure: true,
+        stdin,
+        onStdout: (chunk) => emit("stdout", chunk),
+        onStderr,
+    });
+    const outcome = result.exitCode !== 0 ? "failed" : parseTaskOutcome(result.output);
+    const linkedFiles = listLinkedTaskFiles(ctx.taskDir, ctx.runId, result.output);
+    flushTrailingLine("stdout");
+    if (outcome === "failed")
+        emit("stderr", suppressedStderr);
+    flushTrailingLine("stderr");
+    if (notifyTimer)
+        clearTimeout(notifyTimer);
+    writer?.end();
+    await publishHostEvent(ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
+    if (linkedFiles.length > 0) {
+        await publishHostEvent(ctx.taskId, {
+            event_type: "report-generated",
+            run_id: ctx.runId,
+            name: taskDisplayName(ctx.task.frontmatter),
+            report_files: linkedFiles,
         });
-        const outcome = result.exitCode !== 0 ? "failed" : parseTaskOutcome(result.output);
-        const linkedFiles = listLinkedTaskFiles(ctx.taskDir, ctx.runId, result.output);
-        const requiredPermissions = parsePermissions(result.output);
-        flushTrailingLine("stdout");
-        if (outcome === "failed")
-            emit("stderr", suppressedStderr);
-        flushTrailingLine("stderr");
-        if (requiredPermissions.length > 0) {
-            const permLines = requiredPermissions.map((p) => `- **${p.name}** ${p.description}`).join("\n");
-            ensureWriter("stdout").write(`\n\n**Permissions requested:**\n${permLines}\n`);
-        }
-        if (notifyTimer)
-            clearTimeout(notifyTimer);
-        writer?.end();
-        await publishHostEvent(ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
-        if (linkedFiles.length > 0) {
-            await publishHostEvent(ctx.taskId, {
-                event_type: "report-generated",
-                run_id: ctx.runId,
-                name: taskDisplayName(ctx.task.frontmatter),
-                report_files: linkedFiles,
-            });
-        }
-        if (requiredPermissions.length > 0) {
-            const response = await requestPermission(ctx.config, ctx.task, ctx.taskDir, requiredPermissions);
-            if (response === "aborted") {
-                await appendAndNotify(ctx, {
-                    role: "user",
-                    time: Date.now(),
-                    content: "Deny & Abort Task",
-                    type: "permission",
-                });
-                return { outcome: "failed" };
-            }
-            const newPerms = requiredPermissions.filter((rp) => !ctx.task.frontmatter.permissions?.some((ep) => ep.name === rp.name)
-                && !ctx.transientPermissions.some((ep) => ep.name === rp.name));
-            await appendAndNotify(ctx, {
-                role: "user",
-                time: Date.now(),
-                content: response === "granted_all" ? "Allow Always" : "Allow Once",
-                type: "permission",
-            });
-            if (response === "granted_all") {
-                ctx.task.frontmatter.permissions = [...(ctx.task.frontmatter.permissions ?? []), ...newPerms];
-                invokeTask.frontmatter.permissions = ctx.task.frontmatter.permissions;
-                writeTaskFile(ctx.taskDir, ctx.task);
-            }
-            else {
-                ctx.transientPermissions = [...ctx.transientPermissions, ...newPerms];
-            }
-            // Retry with the new permissions if the agent failed.
-            if (outcome === "failed") {
-                continue;
-            }
-        }
-        return { outcome };
     }
+    return { outcome };
 }
 export function stripPalmierMarkers(output) {
     return output.split("\n").filter((l) => !l.startsWith("[PALMIER")).join("\n").trim();
@@ -217,7 +176,6 @@ export async function runCommand(taskId) {
         const agent = getAgent(task.frontmatter.agent);
         const ctx = {
             agent, task, taskDir, runId, guiEnv, config, taskId,
-            transientPermissions: [],
         };
         // Command-output and on_new_* tasks share the same trigger machinery: the
         // daemon owns the trigger source (the shell command's stdout / a NATS
@@ -238,7 +196,7 @@ export async function runCommand(taskId) {
                 time: Date.now(),
                 content: task.frontmatter.user_prompt,
             });
-            const result = await invokeAgentWithRetries(ctx, task);
+            const result = await invokeAgent(ctx, task);
             const outcome = resolveOutcome(taskDir, result.outcome);
             appendRunMessage(taskDir, runId, { role: "status", time: Date.now(), content: "", type: outcome });
             await publishTaskEvent(taskDir, taskId, outcome, taskName, runId);
@@ -299,7 +257,7 @@ async function runEventTriggeredMode(ctx) {
             const perEventTask = {
                 frontmatter: { ...ctx.task.frontmatter, user_prompt: perEventPrompt },
             };
-            const result = await invokeAgentWithRetries(ctx, perEventTask);
+            const result = await invokeAgent(ctx, perEventTask);
             lastOutcome = result.outcome;
         }
     }
@@ -324,28 +282,6 @@ async function publishTaskEvent(taskDir, taskId, eventType, taskName, runId) {
         payload.run_id = runId;
     await publishHostEvent(taskId, payload);
 }
-async function requestPermission(config, task, taskDir, requiredPermissions) {
-    const port = config.httpPort ?? 7256;
-    const res = await fetch(`http://localhost:${port}/request-permission`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-            taskId: task.frontmatter.id,
-            taskName: taskDisplayName(task.frontmatter),
-            permissions: requiredPermissions,
-        }),
-    });
-    const body = await res.json();
-    const response = body.response;
-    if (!response || !["granted", "granted_all", "aborted"].includes(response)) {
-        throw new Error(`Permission request failed: ${body.error ?? `unexpected response: ${JSON.stringify(body)}`}`);
-    }
-    writeTaskStatus(taskDir, {
-        running_state: response === "aborted" ? "aborted" : "started",
-        time_stamp: Date.now(),
-    });
-    return response;
-}
 async function requestConfirmation(config, task, taskDir) {
     const port = config.httpPort ?? 7256;
     const res = await fetch(`http://localhost:${port}/request-confirmation?taskId=${encodeURIComponent(task.frontmatter.id)}`, {
@@ -376,25 +312,6 @@ export function listLinkedTaskFiles(taskDir, runId, output) {
         }
     });
 }
-export function parsePermissions(output) {
-    const regex = new RegExp(`^\\${TASK_PERMISSION_PREFIX}\\s+(.+)$`, "gm");
-    const perms = [];
-    let match;
-    while ((match = regex.exec(output)) !== null) {
-        const raw = match[1].trim();
-        // Skip placeholder examples echoed from the prompt (e.g. "<tool_name> | <description>").
-        if (raw.startsWith("<"))
-            continue;
-        const sep = raw.indexOf("|");
-        if (sep !== -1) {
-            perms.push({ name: raw.slice(0, sep).trim(), description: raw.slice(sep + 1).trim() });
-        }
-        else {
-            perms.push({ name: raw, description: "" });
-        }
-    }
-    return perms;
-}
 export function parseAgentModel(output) {
     const regex = new RegExp(`^\\${AGENT_MODEL_PREFIX}[ \\t]+(.+)$`, "gm");
     let match;

package/dist/pending-requests.d.ts

@@ -1,8 +1,6 @@
-import type { RequiredPermission } from "./types.js";
 export interface PendingRequestMeta {
     /** The task the request belongs to. */
     session_id?: string;
-    /** Task name, set for permission requests. */
     session_name?: string;
     description?: string;
     input_questions?: string[];
@@ -10,10 +8,10 @@ export interface PendingRequestMeta {
     secret?: boolean;
 }
 export interface PendingRequest {
-    type: "confirmation" | "permission" | "input" | "choice";
+    type: "confirmation" | "input" | "choice";
     resolve: (value: string[]) => void;
-    /** Permission list (for 'permission'), input descriptions (for 'input'), or option labels (for 'choice'). */
-    params?: RequiredPermission[] | string[];
+    /** Input descriptions (for 'input') or option labels (for 'choice'). */
+    params?: string[];
     /** Display context for PWAs that connect while this request is already open. */
     meta?: PendingRequestMeta;
 }