@fungi.computer/truffle 0.5.0 → 0.6.0

package/dist/internal/sandbox-metafile.json

@@ -1934,8 +1934,8 @@
       ],
       "format": "esm"
     },
-    "../../packages/forage/dist/schemas.js": {
-      "bytes": 5755,
+    "../../packages/forage/dist/normalization.js": {
+      "bytes": 3520,
       "imports": [
         {
           "path": "../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/index.js",
@@ -1945,24 +1945,29 @@
       ],
       "format": "esm"
     },
-    "../../packages/forage/dist/errors.js": {
-      "bytes": 396,
-      "imports": [],
-      "format": "esm"
-    },
-    "../../packages/forage/dist/normalization.js": {
-      "bytes": 3477,
+    "../../packages/forage/dist/schemas.js": {
+      "bytes": 5698,
       "imports": [
         {
           "path": "../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/index.js",
           "kind": "import-statement",
           "original": "zod"
+        },
+        {
+          "path": "../../packages/forage/dist/normalization.js",
+          "kind": "import-statement",
+          "original": "./normalization.js"
         }
       ],
       "format": "esm"
     },
+    "../../packages/forage/dist/errors.js": {
+      "bytes": 396,
+      "imports": [],
+      "format": "esm"
+    },
     "../../packages/forage/dist/rendering.js": {
-      "bytes": 13533,
+      "bytes": 11613,
       "imports": [
         {
           "path": "../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/index.js",
@@ -1978,17 +1983,12 @@
           "path": "../../packages/forage/dist/normalization.js",
           "kind": "import-statement",
           "original": "./normalization.js"
-        },
-        {
-          "path": "../../packages/forage/dist/schemas.js",
-          "kind": "import-statement",
-          "original": "./schemas.js"
         }
       ],
       "format": "esm"
     },
     "../../packages/forage/dist/describe.js": {
-      "bytes": 2934,
+      "bytes": 3157,
       "imports": [
         {
           "path": "../../packages/forage/dist/schemas.js",
@@ -2014,7 +2014,7 @@
       "format": "esm"
     },
     "../../packages/forage/dist/search.js": {
-      "bytes": 9616,
+      "bytes": 9656,
       "imports": [
         {
           "path": "../../packages/forage/dist/schemas.js",
@@ -2066,8 +2066,13 @@
       "format": "esm"
     },
     "../../packages/forage/dist/catalog.js": {
-      "bytes": 4793,
+      "bytes": 6091,
       "imports": [
+        {
+          "path": "../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/index.js",
+          "kind": "import-statement",
+          "original": "zod"
+        },
         {
           "path": "../../packages/forage/dist/errors.js",
           "kind": "import-statement",
@@ -2107,7 +2112,7 @@
       "format": "esm"
     },
     "../../packages/forage/dist/app-api.js": {
-      "bytes": 5198,
+      "bytes": 6114,
       "imports": [
         {
           "path": "../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/index.js",
@@ -2129,7 +2134,7 @@
       "format": "esm"
     },
     "../../packages/forage/dist/index.js": {
-      "bytes": 981,
+      "bytes": 996,
       "imports": [
         {
           "path": "../../packages/forage/dist/schemas.js",
@@ -6533,8 +6538,11 @@
         "../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/index.js": {
           "bytesInOutput": 0
         },
+        "../../packages/forage/dist/normalization.js": {
+          "bytesInOutput": 2663
+        },
         "../../packages/forage/dist/schemas.js": {
-          "bytesInOutput": 5686
+          "bytesInOutput": 5531
         },
         "../../packages/forage/dist/index.js": {
           "bytesInOutput": 127
@@ -6542,26 +6550,23 @@
         "../../packages/forage/dist/errors.js": {
           "bytesInOutput": 299
         },
-        "../../packages/forage/dist/normalization.js": {
-          "bytesInOutput": 2924
-        },
         "../../packages/forage/dist/rendering.js": {
-          "bytesInOutput": 10894
+          "bytesInOutput": 9821
         },
         "../../packages/forage/dist/describe.js": {
-          "bytesInOutput": 2413
+          "bytesInOutput": 2570
         },
         "../../packages/forage/dist/search.js": {
-          "bytesInOutput": 8128
+          "bytesInOutput": 8262
         },
         "../../packages/forage/dist/list.js": {
           "bytesInOutput": 1793
         },
         "../../packages/forage/dist/catalog.js": {
-          "bytesInOutput": 3677
+          "bytesInOutput": 4697
         },
         "../../packages/forage/dist/app-api.js": {
-          "bytesInOutput": 1649
+          "bytesInOutput": 1723
         },
         "../../packages/forage/dist/definitions.js": {
           "bytesInOutput": 1100
@@ -6720,7 +6725,7 @@
           "bytesInOutput": 4648
         }
       },
-      "bytes": 993376
+      "bytes": 993272
     }
   }
 }

package/dist/local-extensions.d.ts

@@ -78,7 +78,7 @@ export declare function localExtensions(options: LocalExtensionsOptions): {
      * is pinned to the commit Bun's lockfile resolved; updating is another
      * explicit `add`. Missing declared artifacts are a refusal.
      */
-    add(source: string): Promise<LocalInstalledExtension>;
+    add(source: string, cwd: string): Promise<LocalInstalledExtension>;
     /** Remove the package and every activation that references it. */
     remove(id: string): Promise<boolean>;
     list(): Promise<readonly LocalExtensionSummary[]>;
@@ -101,7 +101,7 @@ export declare function localExtensions(options: LocalExtensionsOptions): {
         agentStoreDirectory: string;
     }>): Promise<{
         revision: string;
-        capabilities: ("state" | "attention" | "settled" | "send" | "timers" | "commands" | "projection" | "run_tools" | "files" | "prompt" | "compaction_handoff")[];
+        capabilities: ("state" | "prompt" | "attention" | "settled" | "send" | "timers" | "commands" | "projection" | "run_tools" | "files" | "compaction_handoff")[];
         skills: boolean;
     }>;
     /**

package/dist/local-extensions.js

@@ -6,6 +6,7 @@ import { Mycelium } from "@fungi.computer/mycelium";
 import { defineExtension, ExtensionId, } from "@fungi.computer/shiitake/extensions";
 import * as Predicate from "effect/Predicate";
 import * as Schema from "effect/Schema";
+import npa from "npm-package-arg";
 import writeFileAtomic from "write-file-atomic";
 import { z } from "zod";
 import { describeExtensionSkills, } from "./local-skill-source.js";
@@ -337,29 +338,52 @@ export function localExtensions(options) {
          * is pinned to the commit Bun's lockfile resolved; updating is another
          * explicit `add`. Missing declared artifacts are a refusal.
          */
-        async add(source) {
+        async add(source, cwd) {
+            if (source.length === 0)
+                throw new LocalExtensionError("install", "An extension source is required");
+            // Bun installs in private staging, not the caller's project. Let the
+            // maintained package-spec parser resolve only local sources there first;
+            // leave Git and registry specifications to Bun unchanged.
+            const parsed = npa(source, cwd);
+            const installSource = parsed.type === "directory" || parsed.type === "file"
+                ? z.string().parse(parsed.fetchSpec)
+                : source;
             await mkdir(join(root, "staging"), { recursive: true, mode: 0o700 });
             const staging = await mkdtemp(join(root, "staging", "install-"));
             try {
+                const runBun = async (args, directory) => {
+                    const child = Bun.spawn([process.execPath, ...args], {
+                        cwd: directory,
+                        // A private cache resolves the named ref afresh instead of a
+                        // cached checkout of an earlier commit.
+                        env: {
+                            ...process.env,
+                            BUN_BE_BUN: "1",
+                            BUN_INSTALL_CACHE_DIR: join(staging, ".install-cache"),
+                        },
+                        stdout: "ignore",
+                        stderr: "pipe",
+                    });
+                    const [status, stderr] = await Promise.all([
+                        child.exited,
+                        new Response(child.stderr).text(),
+                    ]);
+                    if (status !== 0)
+                        throw new LocalExtensionError("install", `Could not install ${source}: ${stderr.trim().slice(0, 2_000)}`);
+                };
+                // Bun links a directory dependency's files back to its source, even
+                // with --backend=copyfile. Its ordinary pack operation supplies an
+                // isolated package snapshot and the install lock supplies its integrity.
+                // Both operations keep lifecycle scripts disabled.
+                const archive = join(staging, "source.tgz");
+                if (parsed.type === "directory")
+                    await runBun(["pm", "pack", "--ignore-scripts", "--filename", archive], installSource);
                 await writeFile(join(staging, "package.json"), `${JSON.stringify({ private: true })}\n`);
-                const child = Bun.spawn([process.execPath, "add", "--ignore-scripts", source], {
-                    cwd: staging,
-                    // A private cache resolves the named ref afresh instead of a
-                    // cached checkout of an earlier commit.
-                    env: {
-                        ...process.env,
-                        BUN_BE_BUN: "1",
-                        BUN_INSTALL_CACHE_DIR: join(staging, ".install-cache"),
-                    },
-                    stdout: "pipe",
-                    stderr: "pipe",
-                });
-                const [status, stderr] = await Promise.all([
-                    child.exited,
-                    new Response(child.stderr).text(),
-                ]);
-                if (status !== 0)
-                    throw new LocalExtensionError("install", `Could not install ${source}: ${stderr.trim().slice(0, 2_000)}`);
+                await runBun([
+                    "add",
+                    "--ignore-scripts",
+                    parsed.type === "directory" ? archive : installSource,
+                ], staging);
                 const lock = lockSchema.parse(Bun.JSONC.parse(await readFile(join(staging, "bun.lock"), "utf8")));
                 const dependencies = Object.keys(z
                     .looseObject({ dependencies: z.record(z.string(), z.string()) })

package/dist/private-fungi-mcp-connection.js

@@ -2,6 +2,7 @@ import { FungiSignInRequiredError } from "./private-fungi-auth-error.js";
 import { createRequire } from "node:module";
 import { Client, StreamableHTTPClientTransport, UnauthorizedError, } from "@modelcontextprotocol/client";
 import { Mycelium } from "@fungi.computer/mycelium";
+import { forageDiscoveryInstructions } from "@fungi.computer/mycelium/effect";
 import { z } from "zod";
 import { parseFungiMcpEndpoint } from "./private-fungi-mcp-endpoint.js";
 import { registerMcpFormElicitation, McpFormApprovalError, } from "./private-mcp-form-elicitation.js";
@@ -83,7 +84,11 @@ export function createPrivateFungiMcpConnection(options) {
                                 operations: {
                                     execute: Mycelium.operation({
                                         replay: "unsafe",
-                                        description: "Execute JavaScript on the connected Fungi MCP server. Discover permitted Team Computer operations with await forage.search({query: 'read'}) and await forage.describe({path: 'files.read'}). Explicitly return the result. Returns the original MCP content and isError; it does not run on the local machine.",
+                                        description: [
+                                            "This operation sends its code to the connected Fungi MCP server's execute tool. The following discovery instructions apply inside that remote call, not the outer Local call.",
+                                            forageDiscoveryInstructions,
+                                            "Explicitly return the result. Returns the original MCP content and isError; it does not run on the local machine.",
+                                        ].join(" "),
                                         input: z.strictObject({ code: z.string() }),
                                         execute: async (input, context) => {
                                             try {

package/dist/private-invocation-computer.d.ts

@@ -21,6 +21,7 @@ declare const execInput: z.ZodUnion<readonly [z.ZodObject<{
         justification: z.ZodString;
     }, z.core.$strict>>;
     cwd: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     timeoutMs: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strict>, z.ZodObject<{
     executable: z.ZodString;
@@ -31,6 +32,7 @@ declare const execInput: z.ZodUnion<readonly [z.ZodObject<{
         justification: z.ZodString;
     }, z.core.$strict>>;
     cwd: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     timeoutMs: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strict>]>;
 declare const completedOutput: z.ZodObject<{
@@ -247,7 +249,9 @@ export type LocalExecPolicyRun = (input: Parameters<LocalExecEscapeStage>[0]) =>
 /** Run the recorded command through the normal bounded process door, without a sandbox.
  * The host supplies the captured PATH and canonical cwd; the record supplies the
  * exact original request. No model invocation can call this door directly. */
-export declare function dispatchApprovedLocalExec(input: unknown, cwd: string, executionPath: string, home: string, processes: PrivateLocalProcessScope, mode: LocalPermissionMode): Promise<ExecOutput | z.output<typeof backgroundExecOutput>>;
+export declare function dispatchApprovedLocalExec(input: unknown, cwd: string, executionPath: string, home: string, processes: PrivateLocalProcessScope, mode: LocalPermissionMode, 
+/** Only inline rule matches have a live execute sink; ledger dispatch does not. */
+sink?: InvocationContext["output"]): Promise<ExecOutput | z.output<typeof backgroundExecOutput>>;
 export type ExecOutput = z.output<typeof execOutput>;
 export type ProcessOutput = z.output<typeof completedOutput> | z.output<typeof deadlineOutput>;
 /**
@@ -262,7 +266,7 @@ export declare function runPrivateInvocationProcess(processCommand: ChildProcess
     requestedMs?: number;
     /** The real command text, for the timeout message; omitted when not meaningful (e.g. a native helper). */
     describeCommand?: () => string;
-}>): Promise<ProcessOutput>;
+}>, output?: InvocationContext["output"]): Promise<ProcessOutput>;
 /**
  * Construct one private invocation-root Computer: bounded shell exec, plus the
  * background-process operations of `processes` when the host supplies a scope.

package/dist/private-invocation-computer.js

@@ -17,7 +17,7 @@ import { z } from "zod";
 import { backgroundExecInput, backgroundExecOutput, callBackgroundExec, } from "./private-local-computer-processes.js";
 import { capturePrivateLocalExecPath, parsePrivateLocalExecPath, } from "./private-local-exec-path.js";
 import { combinedArgvBytes, launchCwdSchema, launchStdinSchema, maximumLaunchTextLength, } from "./private-local-exec-launch.js";
-import { privateLocalExecEnvironment } from "./private-local-exec-environment.js";
+import { privateLocalExecEnvironment, privateLocalExecEnvironmentInput, } from "./private-local-exec-environment.js";
 import { capturePrivateLocalConfigRoot } from "./private-local-config-root.js";
 const maximumStreamBytes = 64 * 1_024;
 /** Room inside the stream cap for the visible truncation marker. */
@@ -50,6 +50,7 @@ const runCommonFields = {
         .strictObject({ justification: z.string().min(1).max(2048) })
         .optional(),
     cwd: launchCwdSchema.optional(),
+    env: privateLocalExecEnvironmentInput.optional(),
     // Accepted up to the full invocation deadline and silently clamped to
     // maximumCommandTimeoutMs (see runCommandAtInvocationBoundary); rejecting
     // outright here would just trade one confusing failure for another.
@@ -139,10 +140,12 @@ export const shellOutput = z.union([
 /** Run the recorded command through the normal bounded process door, without a sandbox.
  * The host supplies the captured PATH and canonical cwd; the record supplies the
  * exact original request. No model invocation can call this door directly. */
-export async function dispatchApprovedLocalExec(input, cwd, executionPath, home, processes, mode) {
+export async function dispatchApprovedLocalExec(input, cwd, executionPath, home, processes, mode, 
+/** Only inline rule matches have a live execute sink; ledger dispatch does not. */
+sink) {
     const request = shellInput.parse(input);
     if (request.operation === "run") {
-        const result = await runCommandAtInvocationBoundary(request, cwd, executionPath, home, new AbortController().signal);
+        const result = await runCommandAtInvocationBoundary(request, cwd, executionPath, home, new AbortController().signal, undefined, sink);
         return execOutput.parse({
             ...result,
             sandbox: { mode, likelyDenied: false, ranOutsideSandbox: true },
@@ -316,9 +319,13 @@ function nativeGroupFinalizer(process) {
         })));
     })));
 }
-function captureBoundedOutput(stream) {
+function captureBoundedOutput(stream, name, output) {
     const initial = { chunks: [], byteLength: 0, totalBytes: 0 };
-    return Stream.runFold(stream, () => initial, (captured, chunk) => {
+    return Stream.runFold(output === undefined
+        ? stream
+        : Stream.tap(stream, (bytes) => Effect.sync(() => {
+            output.write(name, bytes);
+        })), () => initial, (captured, chunk) => {
         const remaining = keptStreamBytes - captured.byteLength;
         const totalBytes = captured.totalBytes + chunk.byteLength;
         if (remaining <= 0)
@@ -406,7 +413,7 @@ function buildRunCommand(request, cwd, executionPath, home, sandbox) {
         HOME: home,
         XDG_RUNTIME_DIR: process.env.XDG_RUNTIME_DIR,
         DBUS_SESSION_BUS_ADDRESS: process.env.DBUS_SESSION_BUS_ADDRESS,
-    });
+    }, request.env);
     // Effect's own default stdin is an open "pipe" that nothing closes, so an
     // executable that reads stdin (`cat`, `python3 -`) would otherwise hang
     // for the full timeout. "ignore" gives it immediate EOF, matching the
@@ -446,14 +453,14 @@ function isMissingExecutableFailure(cause) {
         (cause.reason._tag === "NotFound" ||
             cause.reason._tag === "PermissionDenied"));
 }
-async function runCommandAtInvocationBoundary(request, cwd, executionPath, home, signal, sandbox) {
+async function runCommandAtInvocationBoundary(request, cwd, executionPath, home, signal, sandbox, output) {
     const processCommand = buildRunCommand(request, cwd, executionPath, home, sandbox);
     const timeoutMs = Math.min(request.timeoutMs, maximumCommandTimeoutMs);
     try {
         return await runPrivateInvocationProcess(processCommand, signal, timeoutMs, {
             requestedMs: request.timeoutMs,
             describeCommand: () => describeRunRequest(request),
-        });
+        }, output);
     }
     catch (cause) {
         // Spawning the direct form's named executable can fail at the OS level
@@ -475,7 +482,7 @@ async function runCommandAtInvocationBoundary(request, cwd, executionPath, home,
     }
 }
 /** Shared bounded native process owner; callers supply argv/stdin, never shell interpolation. */
-export function runPrivateInvocationProcess(processCommand, signal, timeoutMs, describe) {
+export function runPrivateInvocationProcess(processCommand, signal, timeoutMs, describe, output) {
     return Effect.runPromise(Effect.scoped(Effect.gen(function* () {
         const startedAt = yield* Clock.currentTimeMillis;
         const executor = yield* ChildProcessSpawner.ChildProcessSpawner;
@@ -483,8 +490,8 @@ export function runPrivateInvocationProcess(processCommand, signal, timeoutMs, d
         const process = yield* Effect.acquireRelease(executor.spawn(processCommand), nativeGroupFinalizer).pipe(Effect.provideService(Scope.Scope, processScope));
         // Keep both readers alive when the exit wait times out. Killing and
         // reaping the owned group closes the pipes, preserving bounded output.
-        const stdoutFiber = yield* Effect.forkChild(captureBoundedOutput(process.stdout));
-        const stderrFiber = yield* Effect.forkChild(captureBoundedOutput(process.stderr));
+        const stdoutFiber = yield* Effect.forkChild(captureBoundedOutput(process.stdout, "stdout", output));
+        const stderrFiber = yield* Effect.forkChild(captureBoundedOutput(process.stderr, "stderr", output));
         const exited = yield* timeoutMs === undefined
             ? Effect.map(process.exitCode, Option.some)
             : Effect.timeoutOption(process.exitCode, timeoutMs);
@@ -519,7 +526,7 @@ async function execute(root, executionPath, home, request, context, sandbox, mod
     context.signal.throwIfAborted();
     const cwd = await resolveCwd(root, request.cwd);
     context.signal.throwIfAborted();
-    const result = await runCommandAtInvocationBoundary(request, cwd, executionPath, home, context.signal, sandbox);
+    const result = await runCommandAtInvocationBoundary(request, cwd, executionPath, home, context.signal, sandbox, context.output);
     return execOutput.parse({
         ...result,
         sandbox: {
@@ -614,7 +621,7 @@ currentMode = () => "full-access", stageEscape, runPolicy) {
                 return result;
             }
             if (processes !== undefined) {
-                const output = await callBackgroundExec(processes, request, (requested) => resolveCwd(root, requested), path, context.signal, sandbox);
+                const output = await callBackgroundExec(processes, request, (requested) => resolveCwd(root, requested), path, context.signal, sandbox, context.output);
                 return jsonValueSchema.parse("text" in output
                     ? {
                         ...output,

package/dist/private-local-computer-processes.d.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import type { LocalSandboxLaunch } from "./private-invocation-computer.js";
+import type { InvocationContext } from "@fungi.computer/mycelium";
 declare const processSchema: z.ZodObject<{
     id: z.ZodString & z.ZodType<import("@fungi.computer/cairn").CairnId<"local-computer-process", "process", 1>, string, z.core.$ZodTypeInternals<import("@fungi.computer/cairn").CairnId<"local-computer-process", "process", 1>, string>>;
     command: z.ZodString;
@@ -92,11 +93,13 @@ export type PrivateLocalProcessCommandSpec = Readonly<{
     readonly kind: "shell";
     readonly command: string;
     readonly stdin?: string;
+    readonly env?: Readonly<Record<string, string>>;
 } | {
     readonly kind: "direct";
     readonly executable: string;
     readonly args: readonly string[];
     readonly stdin?: string;
+    readonly env?: Readonly<Record<string, string>>;
 }>;
 /** One Session's (or invocation's) view of the host's background processes. */
 export type PrivateLocalProcessScope = Readonly<{
@@ -104,7 +107,7 @@ export type PrivateLocalProcessScope = Readonly<{
     status: (id: string) => PrivateLocalProcess;
     list: () => readonly PrivateLocalProcess[];
     read: (id: string, offset: number, maxBytes: number) => Promise<z.output<typeof readOutput>>;
-    wait: (id: string, timeoutMs: number, signal: AbortSignal) => Promise<z.output<typeof waitOutput>>;
+    wait: (id: string, timeoutMs: number, signal: AbortSignal, output?: InvocationContext["output"]) => Promise<z.output<typeof waitOutput>>;
     kill: (id: string) => Promise<z.output<typeof killOutput>>;
 }>;
 /** The host's one background-process owner. */
@@ -133,6 +136,7 @@ export declare const backgroundExecInput: z.ZodUnion<readonly [z.ZodObject<{
     }, z.core.$strict>>;
     command: z.ZodString;
     stdin: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     cwd: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>, z.ZodObject<{
     operation: z.ZodLiteral<"start">;
@@ -142,6 +146,7 @@ export declare const backgroundExecInput: z.ZodUnion<readonly [z.ZodObject<{
     executable: z.ZodString;
     args: z.ZodDefault<z.ZodArray<z.ZodString>>;
     stdin: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     cwd: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>, z.ZodObject<{
     id: z.ZodString & z.ZodType<import("@fungi.computer/cairn").CairnId<"local-computer-process", "process", 1>, string, z.core.$ZodTypeInternals<import("@fungi.computer/cairn").CairnId<"local-computer-process", "process", 1>, string>>;
@@ -213,5 +218,5 @@ export declare const backgroundExecOutput: z.ZodUnion<readonly [z.ZodObject<{
     }, z.core.$strict>>;
 }, z.core.$strict>]>;
 /** Reuse Session ownership and logs; a wait deadline never cancels the command. */
-export declare function callBackgroundExec(scope: PrivateLocalProcessScope, request: z.output<typeof backgroundExecInput>, resolveCwd: (requested: string | undefined) => Promise<string>, executionPath: string, signal: AbortSignal, sandbox?: LocalSandboxLaunch): Promise<z.output<typeof backgroundExecOutput>>;
+export declare function callBackgroundExec(scope: PrivateLocalProcessScope, request: z.output<typeof backgroundExecInput>, resolveCwd: (requested: string | undefined) => Promise<string>, executionPath: string, signal: AbortSignal, sandbox?: LocalSandboxLaunch, sink?: InvocationContext["output"]): Promise<z.output<typeof backgroundExecOutput>>;
 export {};

package/dist/private-local-computer-processes.js

@@ -7,7 +7,7 @@ import { setTimeout as delay } from "node:timers/promises";
 import { defineIdFamily } from "@fungi.computer/cairn";
 import { z } from "zod";
 import { combinedArgvBytes, launchCwdSchema, launchStdinSchema, maximumLaunchTextLength, } from "./private-local-exec-launch.js";
-import { privateLocalExecEnvironment } from "./private-local-exec-environment.js";
+import { privateLocalExecEnvironment, privateLocalExecEnvironmentInput, } from "./private-local-exec-environment.js";
 import { capturePrivateLocalConfigRoot } from "./private-local-config-root.js";
 import { Writable } from "node:stream";
 /**
@@ -70,6 +70,7 @@ const shellStartInput = z.strictObject({
         .optional(),
     command: z.string().min(1).max(maximumLaunchTextLength),
     stdin: launchStdinSchema.optional(),
+    env: privateLocalExecEnvironmentInput.optional(),
     cwd: launchCwdSchema.optional(),
 });
 /** The direct form of background `start`: argv run with no shell interpretation. */
@@ -82,6 +83,7 @@ const directStartInput = z
     executable: z.string().min(1),
     args: z.array(z.string()).default([]),
     stdin: launchStdinSchema.optional(),
+    env: privateLocalExecEnvironmentInput.optional(),
     cwd: launchCwdSchema.optional(),
 })
     .refine((value) => combinedArgvBytes(value.executable, value.args) <=
@@ -166,18 +168,18 @@ function groupAlive(groupId) {
     }
 }
 function toCommandSpec(request) {
-    if ("command" in request) {
-        const spec = { kind: "shell", command: request.command };
-        return request.stdin === undefined
-            ? spec
-            : { ...spec, stdin: request.stdin };
-    }
-    const spec = {
-        kind: "direct",
-        executable: request.executable,
-        args: request.args,
-    };
-    return request.stdin === undefined ? spec : { ...spec, stdin: request.stdin };
+    let spec = "command" in request
+        ? { kind: "shell", command: request.command }
+        : {
+            kind: "direct",
+            executable: request.executable,
+            args: request.args,
+        };
+    if (request.stdin !== undefined)
+        spec = { ...spec, stdin: request.stdin };
+    if (request.env !== undefined)
+        spec = { ...spec, env: request.env };
+    return spec;
 }
 /**
  * A one-line, human-readable label for a spec; never used for execution.
@@ -221,6 +223,7 @@ class ManagedProcess {
     #signal = null;
     #endedAt = null;
     #leaderExited = false;
+    #output = new Map();
     command;
     constructor(spec, cwd, logDirectory, executionPath, home, launch) {
         this.spec = spec;
@@ -234,7 +237,7 @@ class ManagedProcess {
             HOME: home,
             XDG_RUNTIME_DIR: process.env.XDG_RUNTIME_DIR,
             DBUS_SESSION_BUS_ADDRESS: process.env.DBUS_SESSION_BUS_ADDRESS,
-        });
+        }, spec.env);
         if (launch !== undefined) {
             delete env.XDG_RUNTIME_DIR;
             delete env.DBUS_SESSION_BUS_ADDRESS;
@@ -300,11 +303,12 @@ class ManagedProcess {
             pid !== undefined && Number.isSafeInteger(pid) && pid > 1
                 ? pid
                 : undefined;
-        const append = (chunk) => {
-            this.#append(chunk);
-        };
-        this.#child.stdout?.on("data", append);
-        this.#child.stderr?.on("data", append);
+        this.#child.stdout?.on("data", (chunk) => {
+            this.#append(chunk, "stdout");
+        });
+        this.#child.stderr?.on("data", (chunk) => {
+            this.#append(chunk, "stderr");
+        });
         this.#child.on("error", (error) => {
             this.#append(Buffer.from(`\n[fungi: process failed: ${error.message}]\n`));
             this.#finish(closed.resolve);
@@ -327,7 +331,7 @@ class ManagedProcess {
     get running() {
         return this.#endedAt === null;
     }
-    #append(chunk) {
+    #append(chunk, stream = "stderr") {
         const fd = this.#fd;
         if (fd === undefined)
             return;
@@ -342,6 +346,22 @@ class ManagedProcess {
             writeSync(fd, kept, first, kept.byteLength - first, 0);
         this.#logBytes += chunk.byteLength;
         this.#logTruncated = this.#logBytes > maximumLogBytes;
+        for (const output of this.#output.keys())
+            output.write(stream, chunk);
+    }
+    /** Observe only new chunks during this wait; no extra pipe reader or replay. */
+    observeOutput(output) {
+        if (output !== undefined)
+            this.#output.set(output, (this.#output.get(output) ?? 0) + 1);
+        return () => {
+            if (output === undefined)
+                return;
+            const remaining = (this.#output.get(output) ?? 1) - 1;
+            if (remaining === 0)
+                this.#output.delete(output);
+            else
+                this.#output.set(output, remaining);
+        };
     }
     /** Read atomically with appends, including a wrap in circular storage. */
     read(offset, maxBytes) {
@@ -504,8 +524,10 @@ export function createPrivateLocalComputerProcesses(root, home = capturePrivateL
             status: (id) => find(id).snapshot(),
             list: () => [...(scopes.get(key)?.values() ?? [])].map((r) => r.snapshot()),
             read: (id, offset, maxBytes) => Promise.resolve(find(id).read(offset, maxBytes)),
-            wait: async (id, timeoutMs, signal) => {
+            wait: async (id, timeoutMs, signal, output) => {
+                signal.throwIfAborted();
                 const record = find(id);
+                const stopOutput = record.observeOutput(output);
                 const controller = new AbortController();
                 const abandon = () => {
                     controller.abort();
@@ -519,6 +541,7 @@ export function createPrivateLocalComputerProcesses(root, home = capturePrivateL
                     return waitOutput.parse({ process: record.snapshot(), timedOut });
                 }
                 finally {
+                    stopOutput();
                     signal.removeEventListener("abort", abandon);
                     controller.abort();
                 }
@@ -589,7 +612,7 @@ const backgroundResult = readOutput.extend({
 });
 export const backgroundExecOutput = z.union([backgroundResult, listOutput]);
 /** Reuse Session ownership and logs; a wait deadline never cancels the command. */
-export async function callBackgroundExec(scope, request, resolveCwd, executionPath, signal, sandbox) {
+export async function callBackgroundExec(scope, request, resolveCwd, executionPath, signal, sandbox, sink) {
     signal.throwIfAborted();
     if (request.operation === "list")
         return { processes: [...scope.list()] };
@@ -605,7 +628,8 @@ export async function callBackgroundExec(scope, request, resolveCwd, executionPa
         }
         case "wait":
             id = request.id;
-            timedOut = (await scope.wait(id, request.timeoutMs, signal)).timedOut;
+            timedOut = (await scope.wait(id, request.timeoutMs, signal, sink))
+                .timedOut;
             break;
         case "kill":
             id = request.id;