praxis-agent 0.59.0 → 0.60.0

package/README.md

@@ -126,8 +126,11 @@ troubleshooting. Run `praxis --help` for the authoritative command surface.
   composer grammar, compact stable tool rows, responsive density,
   terminal-native background, and a minimal composer/status row. Successful
   background Bash completion bursts collapse in normal reading, while
-  failed/stopped notifications remain detailed. Interactive
-  surfaces share the same presentation across terminals, with English
+  failed/stopped notifications remain detailed.
+  Prompt-like background Bash output that remains unchanged for 50 seconds
+  raises one warning and model follow-up without stopping or reclassifying the
+  running task; silent and ordinary output remain quiet.
+  Interactive surfaces share the same presentation across terminals, with English
   permission/configuration choices and a taught `❯` / Up/Down / Enter / Esc
   interaction grammar. While a regular turn is active, the composer remains
   editable: Enter steers at the next safe continuation boundary, Tab or
@@ -232,8 +235,12 @@ troubleshooting. Run `praxis --help` for the authoritative command surface.
   imports, memory, skills, commands, agents, hooks, settings, MCP servers,
   plugins, and append-only `praxis.transcript` JSONL sessions under `~/.praxis`,
   with bounded MCP connection, discovery, and tool operations plus safe
-  disconnect recovery that never replays an already-dispatched call. Default
-  tool selection defers `mcp__*` schemas behind a turn-scoped `ToolSearch`;
+  disconnect recovery that never replays an already-dispatched call. Stdio MCP
+  environment grants expand defined `${NAME}` references at launch without
+  exposing unrelated ambient credentials or shell-startup variables; reconnect
+  retains the derived grants, while reload derives them again from the current
+  environment. Default tool selection defers `mcp__*` schemas behind a
+  turn-scoped `ToolSearch`;
   each query activates at most eight deterministic matches for the next model
   request, and published MCP tool descriptions are capped at 2,048 Unicode
   code points. Text-only MCP results above 100,000 UTF-8 bytes are redacted

package/dist/application/background-bash-manager.d.ts

@@ -18,6 +18,7 @@ export interface BackgroundBashManagerOptions {
     stateRoot: string;
     maxOutputBytes?: number;
     eventSink?: RuntimeEventSink;
+    stallWatchdogMs?: number;
 }
 export interface BackgroundBashLaunchInput {
     command: string;
@@ -40,6 +41,7 @@ export declare class BackgroundBashManager {
     private readonly runner;
     private readonly outputRoot;
     private readonly sessionStateRoot;
+    private readonly stallWatchdogMs;
     constructor(options: BackgroundBashManagerOptions);
     has(taskId: string): boolean;
     snapshots(): Promise<readonly BackgroundBashSnapshot[]>;
@@ -56,6 +58,8 @@ export declare class BackgroundBashManager {
     stop(taskId: string): Promise<BackgroundBashToolResult>;
     notifications(waitForRunning: boolean): Promise<string[]>;
     private run;
+    private clearWatchdog;
+    private rearmWatchdog;
     private emitNotification;
     private complete;
     private outputResult;

package/dist/application/background-bash-manager.js

@@ -53,14 +53,48 @@ function escapeXml(value) {
         .replaceAll('"', '"')
         .replaceAll("'", ''');
 }
+function isPromptTail(output) {
+    const tail = output
+        .slice(-1024)
+        .replace(new RegExp(`${String.fromCharCode(27)}\\[[0-?]*[ -/]*[@-~]`, 'gu'), '');
+    const lines = tail.split(/\r?\n/u);
+    const line = [...lines].reverse().find((item) => item.trim() !== '');
+    if (!line)
+        return false;
+    const value = line.trim().replace(/[\t ]+$/u, '');
+    if (/\?\s*(?:\[[^\]]{1,20}\]|\([^)]{1,20}\))$/u.test(value))
+        return true;
+    if (/^(?:password|passphrase|username)\s*:\s*$/iu.test(value) ||
+        /^(?:enter|input|select|selection|choice|confirm)\b[^\n:]{0,100}:\s*$/iu.test(value))
+        return true;
+    return /^(?:press|hit)\s+(?:enter|return|any key)(?:\s+to\b[^\n]*)?[.!?:…]?$/iu.test(value);
+}
+function watchdogNotification(task, summary) {
+    return `<task-notification>\n<task-id>${escapeXml(task.taskId)}</task-id>\n<tool-use-id>${escapeXml(task.toolUseId)}</tool-use-id>\n<output-file>${escapeXml(task.outputFile)}</output-file>\n<summary>${escapeXml(summary)}</summary>\n</task-notification>\nLast output:\n${task.output}\n\nThe command is likely blocked on an interactive prompt. Stop this task and re-run with piped input (e.g., \`echo y | command\`) or a non-interactive flag if one exists.`;
+}
+function createWatchdogWake() {
+    let resolveWake;
+    const promise = new Promise((resolve) => {
+        resolveWake = resolve;
+    });
+    return { promise, resolve: resolveWake };
+}
 export class BackgroundBashManager {
     options;
     tasks = new Map();
     runner;
     outputRoot;
     sessionStateRoot;
+    stallWatchdogMs;
     constructor(options) {
         this.options = options;
+        if (options.stallWatchdogMs !== undefined &&
+            (!Number.isFinite(options.stallWatchdogMs) ||
+                !Number.isInteger(options.stallWatchdogMs) ||
+                options.stallWatchdogMs <= 0)) {
+            throw new RangeError('stallWatchdogMs must be a positive integer');
+        }
+        this.stallWatchdogMs = options.stallWatchdogMs ?? 50_000;
         this.runner = new BoundedProcessRunner({
             cwd: options.cwd,
             maxOutputBytes: options.maxOutputBytes ?? 128 * 1024,
@@ -88,6 +122,7 @@ export class BackgroundBashManager {
         const outputFile = resolve(this.outputRoot, `${id}.output`);
         await writeFile(outputFile, '', { mode: 0o600 });
         const controller = new AbortController();
+        const watchdogWake = createWatchdogWake();
         const task = {
             taskId: id,
             command: input.command,
@@ -108,6 +143,11 @@ export class BackgroundBashManager {
                     parentAbort: () => controller.abort(),
                 }
                 : {}),
+            watchdogTimer: null,
+            watchdogFired: false,
+            pendingWatchdogMessage: null,
+            watchdogWake: watchdogWake.promise,
+            watchdogWakeResolve: watchdogWake.resolve,
         };
         if (task.parentSignal && task.parentAbort) {
             if (task.parentSignal.aborted)
@@ -192,12 +232,25 @@ export class BackgroundBashManager {
     async notifications(waitForRunning) {
         await this.hydratePersistedTasks();
         if (waitForRunning) {
-            await Promise.all([...this.tasks.values()]
-                .filter(({ status }) => status === 'running')
-                .map(({ completion }) => completion));
+            const hasPendingWatchdog = [...this.tasks.values()].some(({ pendingWatchdogMessage }) => pendingWatchdogMessage !== null);
+            const running = [...this.tasks.values()].filter(({ status }) => status === 'running');
+            const completions = Promise.all(running.map(({ completion }) => completion));
+            const wakes = running
+                .filter((task) => !task.watchdogFired)
+                .map(({ watchdogWake }) => watchdogWake);
+            if (!hasPendingWatchdog && wakes.length > 0)
+                await Promise.race([completions, ...wakes]);
+            else if (!hasPendingWatchdog)
+                await completions;
         }
         const messages = [];
         for (const task of this.tasks.values()) {
+            if (task.pendingWatchdogMessage) {
+                const pendingWatchdogMessage = task.pendingWatchdogMessage;
+                task.pendingWatchdogMessage = null;
+                if (!task.notified && task.status !== 'stopped')
+                    messages.push(pendingWatchdogMessage);
+            }
             if (task.status === 'running' ||
                 task.status === 'stopped' ||
                 task.notified) {
@@ -219,6 +272,7 @@ export class BackgroundBashManager {
                 signal: task.controller.signal,
                 onOutput: async (output) => {
                     task.output = output;
+                    this.rearmWatchdog(task);
                     await writeFile(task.outputFile, output, { mode: 0o600 });
                 },
             });
@@ -244,12 +298,45 @@ export class BackgroundBashManager {
             });
         }
         finally {
+            this.clearWatchdog(task);
             this.emitNotification(task);
             if (task.parentSignal && task.parentAbort) {
                 task.parentSignal.removeEventListener('abort', task.parentAbort);
             }
         }
     }
+    clearWatchdog(task) {
+        if (task.watchdogTimer !== null) {
+            clearTimeout(task.watchdogTimer);
+            task.watchdogTimer = null;
+        }
+    }
+    rearmWatchdog(task) {
+        this.clearWatchdog(task);
+        if (task.status !== 'running' ||
+            task.watchdogFired ||
+            !isPromptTail(task.output))
+            return;
+        task.watchdogTimer = setTimeout(() => {
+            task.watchdogTimer = null;
+            if (task.status !== 'running' ||
+                task.watchdogFired ||
+                !isPromptTail(task.output))
+                return;
+            task.watchdogFired = true;
+            const summary = `Background command "${task.description}" appears to be waiting for interactive input`;
+            task.pendingWatchdogMessage = watchdogNotification(task, summary);
+            this.options.eventSink?.({
+                type: 'task-input-waiting',
+                taskId: task.taskId,
+                toolUseId: task.toolUseId,
+                outputFile: task.outputFile,
+                summary,
+            });
+            task.watchdogWakeResolve?.();
+            task.watchdogWakeResolve = null;
+        }, this.stallWatchdogMs);
+    }
     emitNotification(task) {
         if (task.status === 'running')
             return;
@@ -330,6 +417,11 @@ export class BackgroundBashManager {
                 completion: Promise.resolve(),
                 startedAt: state.startedAt ?? Math.floor(metadata.mtimeMs),
                 durationMs: state.durationMs ?? null,
+                watchdogTimer: null,
+                watchdogFired: false,
+                pendingWatchdogMessage: null,
+                watchdogWake: createWatchdogWake().promise,
+                watchdogWakeResolve: null,
             };
             this.tasks.set(taskId, task);
             return task;

package/dist/cli/interactive.js

@@ -1968,6 +1968,9 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
                     },
                 });
                 break;
+            case 'task-input-waiting':
+                append({ kind: 'warning', text: event.summary });
+                break;
             case 'compact-boundary':
                 append({
                     kind: 'notice',

package/dist/cli/protocol.js

@@ -2206,6 +2206,21 @@ export class StreamJsonOutput {
             });
             return;
         }
+        if (event.type === 'task-input-waiting') {
+            this.write({
+                type: 'system',
+                subtype: 'task_notification',
+                task_id: event.taskId,
+                ...(event.toolUseId === undefined
+                    ? {}
+                    : { tool_use_id: event.toolUseId }),
+                output_file: event.outputFile,
+                summary: event.summary,
+                uuid: randomUUID(),
+                session_id: this.sessionId,
+            });
+            return;
+        }
         if (event.type === 'session-state-changed') {
             this.writeSessionState(event.state);
             return;

package/dist/core/runtime.d.ts

@@ -275,6 +275,12 @@ export type RuntimeEvent = {
         toolUses: number;
         durationMs: number;
     };
+} | {
+    type: 'task-input-waiting';
+    taskId: string;
+    toolUseId?: string;
+    outputFile: string;
+    summary: string;
 } | {
     type: 'session-state-changed';
     state: 'idle' | 'running' | 'requires_action';

package/dist/mcp/claude-mcp-tools.js

@@ -257,12 +257,12 @@ export function validateClaudeMcpConfiguration(resources) {
     });
     return { servers, warnings };
 }
-async function transport(serverName, config, cwd, configRoot) {
+async function transport(serverName, config, cwd, configRoot, environment = process.env) {
     if (config.type === 'stdio') {
         return new StdioClientTransport({
             command: config.command,
             args: config.args,
-            env: sanitizeChildEnvironment(config.env),
+            env: sanitizeChildEnvironment(config.env, environment),
             cwd: config.cwd ?? cwd,
             stderr: 'pipe',
         });
@@ -280,6 +280,21 @@ async function transport(serverName, config, cwd, configRoot) {
             ...(authProvider ? { authProvider } : {}),
         });
 }
+function deriveMcpServerConfig(config, environment) {
+    if (config.type !== 'stdio')
+        return config;
+    const env = Object.fromEntries(Object.entries(config.env).map(([name, value]) => [
+        name,
+        value.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/gu, (match, variable) => {
+            const replacement = environment[variable];
+            return Object.prototype.hasOwnProperty.call(environment, variable) &&
+                typeof replacement === 'string'
+                ? replacement
+                : match;
+        }),
+    ]));
+    return { ...config, env };
+}
 function toolContent(result, sensitiveValues) {
     if (!Array.isArray(result.content)) {
         throw new Error('MCP tool result content must be an array');
@@ -883,7 +898,6 @@ export class ClaudeMcpToolRegistry {
                 warn(`MCP server ${server.name} unavailable: ${error instanceof Error ? error.message : String(error)}`);
                 continue;
             }
-            this.serverSensitiveValues.set(server.name, configSensitiveValues(config, server.sensitiveValues ?? [], this.options.environment ?? process.env));
             await this.connectServer(server.name, config, server.sensitiveValues);
         }
         this.publishPrompts();
@@ -1091,7 +1105,10 @@ export class ClaudeMcpToolRegistry {
     async connectServer(serverName, config, additionalSensitiveValues = [], expectedGeneration = this.generation) {
         this.assertOpenGeneration(expectedGeneration);
         this.statuses.set(serverName, { name: serverName, status: 'failed' });
-        const sensitiveValues = configSensitiveValues(config, additionalSensitiveValues, this.options.environment ?? process.env);
+        const environment = this.options.environment ?? process.env;
+        const launchConfig = deriveMcpServerConfig(config, environment);
+        const sensitiveValues = configSensitiveValues(launchConfig, additionalSensitiveValues, environment);
+        this.serverSensitiveValues.set(serverName, sensitiveValues);
         const session = new McpServerSession({
             serverName,
             connectionTimeoutMs: this.timeouts.connectionTimeoutMs,
@@ -1099,7 +1116,7 @@ export class ClaudeMcpToolRegistry {
             ...(this.options.signal ? { lifetimeSignal: this.options.signal } : {}),
             createTransport: async () => {
                 const configRoot = this.options.configRoot ?? join(homedir(), '.praxis');
-                return (await transport(serverName, config, this.options.cwd, configRoot));
+                return (await transport(serverName, launchConfig, this.options.cwd, configRoot, environment));
             },
             configureClient: (client) => {
                 client.setRequestHandler(ElicitRequestSchema, async (request) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "praxis-agent",
-  "version": "0.59.0",
+  "version": "0.60.0",
   "description": "Local-first, single-user general agent for the command line.",
   "license": "MIT",
   "author": "wuqisen",