palmier 1.1.22 → 1.1.24

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, undefined, ctx.task.frontmatter.yolo_mode ? "yolo" : ctx.transientPermissions);
-        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/index.js

@@ -11,7 +11,6 @@ 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 { passwordsListCommand, passwordsDeleteCommand, passwordsClearCommand } from "./commands/passwords.js";
 import { agentsCommand } from "./commands/agents.js";
 import { uninstallCommand } from "./commands/uninstall.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -78,27 +77,6 @@ clientsCmd
     .action(async () => {
     await clientsRevokeAllCommand();
 });
-const passwordsCmd = program
-    .command("passwords")
-    .description("Manage saved passwords");
-passwordsCmd
-    .command("list")
-    .description("List saved passwords (origin and username only)")
-    .action(async () => {
-    await passwordsListCommand();
-});
-passwordsCmd
-    .command("delete <origin> [username]")
-    .description("Delete a saved password (omit username to delete all for the origin)")
-    .action(async (origin, username) => {
-    await passwordsDeleteCommand(origin, username);
-});
-passwordsCmd
-    .command("clear")
-    .description("Delete all saved passwords")
-    .action(async () => {
-    await passwordsClearCommand();
-});
 program
     .command("agents")
     .description("List, install, and uninstall agent CLIs")

package/dist/password-store.d.ts

@@ -8,6 +8,4 @@ export declare function normalizeOrigin(url: string): string;
 export declare function lookupPassword(origin: string, username: string): string | undefined;
 export declare function savePassword(origin: string, username: string, password: string): void;
 export declare function listPasswords(): PasswordIdentity[];
-/** Delete one (origin, username) entry, or every entry for an origin when username is omitted. */
-export declare function deletePassword(origin: string, username?: string): boolean;
-export declare function clearPasswords(): number;
+export declare function deletePassword(origin: string, username: string): boolean;

package/dist/password-store.js

@@ -80,17 +80,11 @@ export function savePassword(origin, username, password) {
 export function listPasswords() {
     return readFile().map(({ origin, username }) => ({ origin, username }));
 }
-/** Delete one (origin, username) entry, or every entry for an origin when username is omitted. */
 export function deletePassword(origin, username) {
     const entries = readFile();
-    const remaining = entries.filter((e) => username === undefined ? e.origin !== origin : !(e.origin === origin && e.username === username));
+    const remaining = entries.filter((e) => !(e.origin === origin && e.username === username));
     if (remaining.length === entries.length)
         return false;
     writeFile(remaining);
     return true;
 }
-export function clearPasswords() {
-    const entries = readFile();
-    writeFile([]);
-    return entries.length;
-}

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;
 }