pi-better-background-tasks 0.2.4 → 0.2.6

package/src/tools.ts

@@ -5,6 +5,7 @@ import { refreshBackgroundTasksNavigator } from "./navigator-provider.js";
 import { cancelCallbackBatch } from "./shared-callback-batcher.js";
 import { listMetas, readMeta, writeMeta } from "./registry.js";
 import { resumeRunningTask, spawnTask, startWatchTask, stopTask } from "./runtime.js";
+import { ForegroundSandboxBlockedError } from "./sandbox.js";
 import type { BackgroundTaskCallbackOrigin, BackgroundTaskMeta } from "./types.js";
 import { isTerminalStatus } from "./types.js";
 
@@ -68,7 +69,7 @@ const ListParams = Type.Object({
 });
 const LogParams = Type.Object({
   id: Type.String({ description: "Background task id." }),
-  tail_lines: Type.Optional(Type.Number({ description: "Number of trailing lines. Default 20 for compact model ingestion. Set <=0 only when the full log is explicitly required." })),
+  tail_lines: Type.Optional(Type.Number({ description: "Number of trailing lines. Default 5 for compact model ingestion. Set <=0 only when the full log is explicitly required." })),
 });
 
 const ActionParams = Type.Object({
@@ -121,26 +122,26 @@ export function registerTools(pi: ExtensionAPI): void {
   pi.registerTool({
     name: "bg_task_spawn",
     label: "BG Spawn",
-    description: "Start a long-running background process and return immediately with its task id. For remote work, prefer structured ssh: pass ssh:{host,user} and put the remote command in command; spawn defaults to a remote tmux session with durable local logs and real remote stop. If tmux is missing, the preset attempts to install tmux non-interactively and fails closed with operator guidance when setup cannot proceed. Explicit remote.session=direct skips tmux, but direct mode has weaker stop semantics and may leave the remote process running. Never wait or poll in the foreground.",
+    description: "Start a long-running background process and return immediately with its task id. For remote work, prefer structured ssh: pass ssh:{host,user} and put the remote command in command; spawn defaults to a remote tmux session with durable local logs and real remote stop. For short synchronous remote commands that should return output now, use remote_bash from pi-better-ssh. If tmux is missing, the preset attempts to install tmux non-interactively and fails closed with operator guidance when setup cannot proceed. Explicit remote.session=direct skips tmux, but direct mode has weaker stop semantics and may leave the remote process running. Never wait or poll in the foreground.",
     parameters: SpawnParams,
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       activeSession = getCallbackOrigin(ctx);
-      const meta = spawnTask(pi, params, ctx.cwd, activeSession, getActiveSession);
+      const launched = reportLaunch(() => spawnTask(pi, params, ctx.cwd, activeSession, getActiveSession));
       refreshBackgroundTasksNavigator(ctx);
-      return text(formatLaunch(meta));
+      return text(launched);
     },
   });
 
   pi.registerTool({
     name: "bg_task_watch",
     label: "BG Watch",
-    description: "Poll a command in the background until success_when, failure_when, or timeout matches. For remote work, prefer structured ssh: pass ssh:{host,user} and provide the remote command in command; each interval opens a direct one-shot SSH poll without tmux installation. Returns immediately with its task id. Default timeout 900 seconds; pass timeout_seconds:0 to disable.",
+    description: "Poll a command in the background until success_when, failure_when, or timeout matches. For remote work, prefer structured ssh: pass ssh:{host,user} and provide the remote command in command; each interval opens a direct one-shot SSH poll without tmux installation. For short synchronous remote commands that should return output now, use remote_bash from pi-better-ssh. Returns immediately with its task id. Default timeout 900 seconds; pass timeout_seconds:0 to disable.",
     parameters: WatchParams,
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       activeSession = getCallbackOrigin(ctx);
-      const meta = startWatchTask(pi, params, ctx.cwd, activeSession, getActiveSession);
+      const launched = reportLaunch(() => startWatchTask(pi, params, ctx.cwd, activeSession, getActiveSession));
       refreshBackgroundTasksNavigator(ctx);
-      return text(formatLaunch(meta));
+      return text(launched);
     },
   });
 
@@ -168,7 +169,7 @@ export function registerTools(pi: ExtensionAPI): void {
   pi.registerTool({
     name: "bg_task_log",
     label: "BG Log",
-    description: "Read a background task log. Default output is a compact 20-line terminal-aware tail for model ingestion. Pass tail_lines for a bounded tail; tail_lines:0 returns the retained raw log, capped at 512 KiB for safe recovery. Nonblocking.",
+    description: "Read a background task log. Default output is a compact 5-line terminal-aware tail for model ingestion. Pass tail_lines for a bounded tail; tail_lines:0 returns the retained raw log, capped at 512 KiB for safe recovery. Nonblocking.",
     parameters: LogParams,
     renderResult(result: unknown, options: unknown, theme: unknown) {
       return renderBackgroundTaskLogDisplay(result, options, theme);
@@ -194,7 +195,7 @@ export function registerTools(pi: ExtensionAPI): void {
   pi.registerTool({
     name: "bg_task",
     label: "BG Task",
-    description: "Action wrapper for background tasks: spawn, watch, list, status, log, stop, or clear. For remote work, prefer structured ssh: pass ssh:{host,user} and provide the remote command in command. SSH spawn defaults to durable tmux; SSH watches use direct one-shot polls without tmux installation; remote.session=direct is a weaker-stop spawn escape hatch. Spawn/watch return immediately; do not poll in foreground. For action:status, default compact output and use verbose:true only for full metadata. For action:log, default compact tail and use tail_lines:0 only for explicit full logs.",
+    description: "Action wrapper for background tasks: spawn, watch, list, status, log, stop, or clear. For remote work, prefer structured ssh: pass ssh:{host,user} and provide the remote command in command. For short synchronous remote commands that should return output now, use remote_bash from pi-better-ssh. SSH spawn defaults to durable tmux; SSH watches use direct one-shot polls without tmux installation; remote.session=direct is a weaker-stop spawn escape hatch. Spawn/watch return immediately; do not poll in foreground. For action:status, default compact output and use verbose:true only for full metadata. For action:log, default compact tail and use tail_lines:0 only for explicit full logs.",
     parameters: ActionParams,
     renderResult(result: unknown, options: unknown, theme: unknown) {
       return renderBackgroundTaskLogDisplay(result, options, theme);
@@ -246,10 +247,10 @@ async function runAction(
 ): Promise<string> {
   switch (params.action) {
     case "spawn":
-      return withNavigatorRefresh(ctx, formatLaunch(spawnTask(pi, params, ctx.cwd, callbackOrigin, getActiveSession)));
+      return withNavigatorRefresh(ctx, reportLaunch(() => spawnTask(pi, params, ctx.cwd, callbackOrigin, getActiveSession)));
     case "watch":
       if (!params.success_when) return "Invalid parameters: watch requires success_when.";
-      return withNavigatorRefresh(ctx, formatLaunch(startWatchTask(pi, params as never, ctx.cwd, callbackOrigin, getActiveSession)));
+      return withNavigatorRefresh(ctx, reportLaunch(() => startWatchTask(pi, params as never, ctx.cwd, callbackOrigin, getActiveSession)));
     case "list":
       return formatList(resolveList(params.status as string[] | undefined, params.limit as number | undefined));
     case "status":
@@ -268,6 +269,21 @@ async function runAction(
   }
 }
 
+/**
+ * Report a launch, or why the foreground sandbox refused it.
+ *
+ * A blocked launch is an operator-facing answer, not a tool crash: the task was
+ * never started, and nothing about it is retried unconfined.
+ */
+function reportLaunch(launch: () => BackgroundTaskMeta): string {
+  try {
+    return formatLaunch(launch());
+  } catch (error) {
+    if (error instanceof ForegroundSandboxBlockedError) return error.message;
+    throw error;
+  }
+}
+
 function withNavigatorRefresh(ctx: ExtensionContext, result: string): string {
   refreshBackgroundTasksNavigator(ctx);
   return result;
@@ -338,7 +354,7 @@ function formatCompactStatus(meta: BackgroundTaskMeta): string {
   if (meta.lastState !== undefined) lines.push(`last state: ${oneLine(meta.lastState, 800)}`);
   if (meta.logDiscardedBytes) lines.push(`log retention: ${meta.logDiscardedBytes} bytes discarded in ${meta.logRetentionEvents ?? 1} compaction(s).`);
   lines.push(`log: ${meta.logPath}`);
-  lines.push(`For full metadata use bg_task_status id=${meta.id} verbose=true. For logs use bg_task_log id=${meta.id} tail_lines=20, or tail_lines=0 for the retained raw log.`);
+  lines.push(`For full metadata use bg_task_status id=${meta.id} verbose=true. For logs use bg_task_log id=${meta.id} tail_lines=5, or tail_lines=0 for the retained raw log.`);
   return lines.join("\n");
 }
 
@@ -360,7 +376,7 @@ function oneLine(value: unknown, maxLength: number): string {
 function formatLog(id: string, tailLines?: number): string {
   const meta = readMeta(id);
   if (!meta) return `No background task found for id ${id}.`;
-  const log = readLog(meta.logPath, tailLines ?? 20);
+  const log = readLog(meta.logPath, tailLines ?? 5);
   const prefix = log.truncated ? `[showing tail of ${meta.logPath}]\n` : `[${meta.logPath}]\n`;
   return prefix + (log.text || "(log is empty)");
 }

package/src/types.ts

@@ -1,3 +1,7 @@
+import type { ResolvedSshIdentity, SshConnectionParams } from "./shared-ssh-core/index.js";
+
+export type { ResolvedSshIdentity, SshConnectionParams };
+
 export type BackgroundTaskStatus =
   | "running"
   | "succeeded"
@@ -32,31 +36,12 @@ export interface CommandResult {
   timedOut?: boolean;
 }
 
-export interface SshConnectionParams {
-  host: string;
-  user?: string;
-  port?: number;
-  identity_file?: string;
-  jump?: string;
-  options?: Record<string, string>;
-}
-
 export interface RemoteTaskParams {
   session?: "tmux" | "direct";
   install_tmux?: boolean;
   workdir?: string;
 }
 
-export interface ResolvedSshIdentity {
-  host: string;
-  user?: string;
-  port?: number;
-  identityFile?: string;
-  jump?: string;
-  options?: Record<string, string>;
-  target: string;
-}
-
 export interface ResolvedRemoteTaskMetadata {
   command: string;
   session?: "tmux" | "direct";
@@ -105,6 +90,15 @@ export interface BackgroundTaskMeta {
   shell?: boolean;
   cwd: string;
   env?: Record<string, string>;
+  /**
+   * The executable and argv this task was actually launched with, when that
+   * differs from `command`/`argv` above — today, an OS write-sandbox wrapper
+   * captured from the foreground policy at launch. Re-running a watch poll uses
+   * it verbatim, which is how a running task keeps the policy it started under
+   * even after the foreground policy changes. `command`/`argv` stay the operator's
+   * own request, so status, navigator, and goal surfaces read unchanged.
+   */
+  launchArgv?: string[];
   maxLogBytes?: number;
   logDiscardedBytes?: number;
   logRetentionEvents?: number;