@demicodes/shell 0.18.0 → 0.19.1

package/dist/index.d.mts

@@ -1,6 +1,6 @@
 import { a as HostFileSystem, c as HostProcessOutputChunk, d as HostSpawnParams, f as HostStore, i as HostFileStat, l as HostSpawnExit, m as createLogicalHostCwd, n as HostCwd, o as HostIdentity, p as SpawnErrorKind, r as HostDirent, s as HostProcess, t as Host, u as HostSpawnHandle } from "./host-BupAFtK6.mjs";
 import { HostBackedFileSystem, HostBackedFileSystemOptions } from "./host-fs.mjs";
-import { _ as runRegisteredCommand, a as CommandIO, c as CommandRegistry, d as CommandStdin, f as CommandStorage, g as renderCommandHelp, h as parseCommandInput, i as CommandExecutionContext, l as CommandRunContext, m as emptyStdin, n as COMMAND_HELP_DEFAULTS, o as CommandInputSpec, p as ParsedCommandInput, r as Command, s as CommandOutputSpec, t as AgentSessionCommandStorage, u as CommandRunResult } from "./storage-CAc1N6MN.mjs";
+import { _ as runRegisteredCommand, a as CommandIO, c as CommandRegistry, d as CommandStdin, f as CommandStorage, g as renderCommandHelp, h as parseCommandInput, i as CommandExecutionContext, l as CommandRunContext, m as emptyStdin, n as COMMAND_HELP_DEFAULTS, o as CommandInputSpec, p as ParsedCommandInput, r as Command, s as CommandOutputSpec, t as AgentSessionCommandStorage, u as CommandRunResult } from "./storage-BDRwHNOB.mjs";
 import { CommandName } from "@demicodes/just-bash/commands";
 import { Interpreter, InterpreterState } from "@demicodes/just-bash/interpreter";
 import { CommandRegistry as CommandRegistry$1, ExecResult } from "@demicodes/just-bash/types";

package/dist/index.mjs

@@ -128,6 +128,7 @@ function emptyStdin() {
 		bytes: /* @__PURE__ */ new Uint8Array(0)
 	};
 }
+async function* emptyStdinStream() {}
 const EXECUTION_ONLY_FIELDS = [
 	"successOutput",
 	"failureOutput",
@@ -221,7 +222,7 @@ function parseArgs(command, path, argv, startIndex, stdin) {
 		setParsedValue(values, field, token);
 		positionalIndex += 1;
 	}
-	if (command.stdinField) values[command.stdinField] = stdin.text;
+	if (command.stdinField && values[command.stdinField] === void 0) values[command.stdinField] = stdin.text;
 	return {
 		path: [...path],
 		help: false,
@@ -262,7 +263,9 @@ async function runRegisteredCommand(root, ctx) {
 		cwd: ctx.cwd,
 		io: parsed.json ? capture : ctx.io,
 		storage: ctx.storage,
-		host: ctx.host
+		host: ctx.host,
+		signal: ctx.signal ?? new AbortController().signal,
+		stdinStream: ctx.stdinStream ?? emptyStdinStream()
 	});
 	if (parsed.json && result.exitCode === 0) {
 		const raw = capture.stdoutText();
@@ -696,24 +699,34 @@ var CommandArtifactStore = class {
 };
 //#endregion
 //#region src/registered-command-adapter.ts
-function commandToForkCommand(session, command, storage, host) {
+/**
+* Runs a registered command as a shell foreground job: it exposes the same
+* control surface as a host process (abort signal, live stdout/stderr view,
+* stdin as a post-start chunk stream) through a virtual process handle, so
+* `shell_status` / `shell_write` / `shell_abort` apply uniformly.
+*/
+function commandToForkCommand(session, command, storage, host, captureLimitBytes) {
 	return {
 		name: command.name,
 		consumesStdin: treeConsumesStdin(command),
 		execute: async (args, ctx) => {
 			const stdin = decodeForkStdin(ctx.stdin);
-			const io = createForwardingIO();
 			const argv = [command.name, ...args];
+			const job = new VirtualForegroundJob(session, command.name, args, ctx.cwd, captureLimitBytes);
+			job.install();
 			try {
-				const result = await runRegisteredCommand(command, {
+				const result = await Promise.race([runRegisteredCommand(command, {
 					argv,
 					stdin,
 					env: mapToRecord(ctx.env),
 					cwd: ctx.cwd,
-					io,
+					io: job.io,
 					storage,
-					host
-				});
+					host,
+					signal: job.signal,
+					stdinStream: job.stdinChunks()
+				}), job.killedResult()]);
+				if (job.foreground.captureOverflowed) return job.overflowResult();
 				session.accumulator.audit.push({
 					kind: "registered-command",
 					name: command.name,
@@ -727,12 +740,13 @@ function commandToForkCommand(session, command, storage, host) {
 					metadata: result.metadata
 				});
 				return {
-					stdout: io.stdoutLatin1(),
+					stdout: job.stdoutLatin1(),
 					stdoutKind: "bytes",
-					stderr: io.stderrText(),
+					stderr: job.stderrText(),
 					exitCode: result.exitCode
 				};
 			} catch (error) {
+				if (job.foreground.captureOverflowed) return job.overflowResult();
 				const message = error instanceof Error ? error.message : String(error);
 				session.accumulator.audit.push({
 					kind: "registered-command",
@@ -741,35 +755,171 @@ function commandToForkCommand(session, command, storage, host) {
 					exitCode: 1
 				});
 				return {
-					stdout: io.stdoutLatin1(),
+					stdout: job.stdoutLatin1(),
 					stdoutKind: "bytes",
-					stderr: `${io.stderrText()}${command.name}: ${message}\n`,
+					stderr: `${job.stderrText()}${command.name}: ${message}\n`,
 					exitCode: 1
 				};
+			} finally {
+				job.release();
 			}
 		}
 	};
 }
-/** Collects command output as raw bytes; stdout stays byte-clean for the pipe. */
-var ForwardingIO = class {
-	stdoutChunks = [];
-	stderrChunks = [];
-	async stdout(data) {
-		this.stdoutChunks.push(typeof data === "string" ? encodeUtf8(data) : data);
+/**
+* In-process stand-in for an OS process. `kill` maps to the abort signal
+* (there is no OS process to signal); a SIGKILL additionally abandons the
+* run so the shell never waits on an in-process function that ignores its
+* signal.
+*/
+var VirtualForegroundJob = class {
+	session;
+	captureLimitBytes;
+	foreground;
+	io;
+	abortController = new AbortController();
+	stdinQueue = new StdinChunkQueue();
+	settleExit;
+	killed;
+	killedPromise;
+	exitPromise;
+	installed = false;
+	constructor(session, command, args, cwd, captureLimitBytes) {
+		this.session = session;
+		this.captureLimitBytes = captureLimitBytes;
+		this.exitPromise = new Promise((resolve) => {
+			this.settleExit = resolve;
+		});
+		this.killedPromise = new Promise((_resolve, reject) => {
+			this.killed = reject;
+		});
+		this.killedPromise.catch(() => {});
+		const handle = {
+			stdout: emptyByteStream(),
+			stderr: emptyByteStream(),
+			writeStdin: async (data) => this.stdinQueue.push(data),
+			closeStdin: async () => this.stdinQueue.close(),
+			kill: async (signal) => {
+				this.abortController.abort();
+				this.stdinQueue.close();
+				if (signal === "SIGKILL") {
+					this.settleExit({
+						exitCode: 137,
+						signal: "SIGKILL"
+					});
+					this.killed(/* @__PURE__ */ new Error(`${command}: killed`));
+				}
+			},
+			wait: () => this.exitPromise
+		};
+		const startedAt = Date.now();
+		this.foreground = {
+			commandId: session.activeCommandId ?? "",
+			command,
+			args,
+			cwd,
+			handle,
+			startedAt,
+			lastOutputAt: startedAt,
+			rawStdoutBuffer: "",
+			rawStdoutBytes: [],
+			rawStderrBuffer: "",
+			stdoutBuffer: "",
+			stderrBuffer: "",
+			outputChunks: [],
+			outputBytes: 0,
+			capturedBytes: 0,
+			captureOverflowed: false,
+			audit: [],
+			stdoutPump: Promise.resolve(),
+			stderrPump: Promise.resolve(),
+			exitPromise: this.exitPromise,
+			outputSinks: createOutputSinks(session.fs, cwd, void 0),
+			abortController: this.abortController
+		};
+		this.io = {
+			stdout: (data) => {
+				recordForegroundChunk(this.foreground, 1, toBytes(data), this.captureLimitBytes);
+			},
+			stderr: (data) => {
+				recordForegroundChunk(this.foreground, 2, toBytes(data), this.captureLimitBytes);
+			}
+		};
 	}
-	async stderr(data) {
-		this.stderrChunks.push(typeof data === "string" ? encodeUtf8(data) : data);
+	get signal() {
+		return this.abortController.signal;
+	}
+	stdinChunks() {
+		return this.stdinQueue.stream();
+	}
+	killedResult() {
+		return this.killedPromise;
+	}
+	/** Registers this job as the session foreground so shell control verbs route here. */
+	install() {
+		if (this.session.foreground || !this.foreground.commandId) return;
+		this.session.foreground = this.foreground;
+		this.installed = true;
+		notifyForegroundWaiters(this.session.foregroundWaiters, this.foreground);
+	}
+	release() {
+		this.stdinQueue.close();
+		this.settleExit({ exitCode: 0 });
+		if (this.installed && this.session.foreground === this.foreground) this.session.foreground = void 0;
 	}
 	stdoutLatin1() {
-		return decodeLatin1(concatBytes(this.stdoutChunks));
+		return decodeLatin1(concatBytes(this.foreground.rawStdoutBytes));
 	}
 	stderrText() {
-		return decodeUtf8(concatBytes(this.stderrChunks));
+		return this.foreground.rawStderrBuffer;
+	}
+	overflowResult() {
+		return {
+			stdout: "",
+			stdoutKind: "bytes",
+			stderr: `${this.foreground.command}: output exceeded the ${this.captureLimitBytes}-byte capture limit and the command was stopped; the shell buffers whole command outputs in memory — narrow the output at the source (filters, head, tighter paths)\n`,
+			exitCode: 137
+		};
+	}
+};
+/** Async chunk queue: each pushed chunk is delivered once, in order; close ends the stream. */
+var StdinChunkQueue = class {
+	chunks = [];
+	waiter = null;
+	isClosed = false;
+	push(data) {
+		if (this.isClosed) return;
+		this.chunks.push(data);
+		this.wake();
+	}
+	close() {
+		if (this.isClosed) return;
+		this.isClosed = true;
+		this.wake();
+	}
+	async *stream() {
+		while (true) {
+			const chunk = this.chunks.shift();
+			if (chunk) {
+				yield chunk;
+				continue;
+			}
+			if (this.isClosed) return;
+			await new Promise((resolve) => {
+				this.waiter = resolve;
+			});
+		}
+	}
+	wake() {
+		const waiter = this.waiter;
+		this.waiter = null;
+		waiter?.();
 	}
 };
-function createForwardingIO() {
-	return new ForwardingIO();
+function toBytes(data) {
+	return typeof data === "string" ? encodeUtf8(data) : data;
 }
+async function* emptyByteStream() {}
 function treeConsumesStdin(command) {
 	if (command.stdinField) return true;
 	return command.subcommands?.some(treeConsumesStdin) ?? false;
@@ -1082,7 +1232,7 @@ var BashEnvironment = class {
 		};
 		for (const command of createPortableCommands(session)) forkCommands.set(command.name, command);
 		const storage = new AgentSessionCommandStorage(this.host.store, commandStorageId);
-		for (const command of this.commands.list()) forkCommands.set(command.name, commandToForkCommand(session, command, storage, this.host));
+		for (const command of this.commands.list()) forkCommands.set(command.name, commandToForkCommand(session, command, storage, this.host, this.captureLimitBytes));
 		session.abortController = new AbortController();
 		const limits = resolveLimits({
 			maxOutputSize: this.captureLimitBytes,

package/dist/{storage-CAc1N6MN.d.mts → storage-BDRwHNOB.d.mts}

@@ -47,6 +47,13 @@ interface CommandRunContext {
   storage: CommandStorage;
   /** Host of the BashEnvironment executing this command. */
   host: Host;
+  /** Aborted when the shell command is aborted (shell_abort, shell teardown). */
+  signal: AbortSignal;
+  /**
+   * Stdin written after the command started: each `shell_write` call arrives
+   * as one chunk. Ends when the command's shell job is released.
+   */
+  stdinStream: AsyncIterable<Uint8Array>;
 }
 interface CommandRunResult {
   exitCode: number;
@@ -77,6 +84,8 @@ interface CommandExecutionContext {
   io: CommandIO;
   storage: CommandStorage;
   host: Host;
+  signal?: AbortSignal;
+  stdinStream?: AsyncIterable<Uint8Array>;
 }
 declare class CommandRegistry {
   private readonly commands;

package/dist/storage.d.mts

@@ -1,2 +1,2 @@
-import { t as AgentSessionCommandStorage } from "./storage-CAc1N6MN.mjs";
+import { t as AgentSessionCommandStorage } from "./storage-BDRwHNOB.mjs";
 export { AgentSessionCommandStorage };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@demicodes/shell",
   "description": "Sandboxable bash engine and Host contract for Demi.",
-  "version": "0.18.0",
+  "version": "0.19.1",
   "private": false,
   "type": "module",
   "exports": {
@@ -20,7 +20,7 @@
   },
   "dependencies": {
     "@demicodes/just-bash": "^3.1.0-demi.4",
-    "@demicodes/utils": "^0.18.0",
+    "@demicodes/utils": "^0.19.1",
     "zod": "^4.0.0"
   },
   "license": "Apache-2.0",