shell-dsl 0.0.40 → 0.0.42

package/dist/types/src/shell-session.d.ts

@@ -0,0 +1,30 @@
+import type { Command, CommandCompleter, CompletionResult, ShellCommandFallback, ShellConfig, ShellExecution, ShellExecutionOptions, TerminalInfo, VirtualFS } from "./types.ts";
+import type { Program } from "./shell-dsl.ts";
+export interface ShellSessionOptions {
+    fs: VirtualFS;
+    cwd: string;
+    env: Record<string, string>;
+    commands: Record<string, Command>;
+    completions?: Record<string, CommandCompleter>;
+    isTTY?: boolean;
+    terminal?: TerminalInfo;
+    externalCommand?: ShellCommandFallback;
+}
+export declare class ShellSession {
+    private fs;
+    private commands;
+    private completions;
+    private terminal;
+    private interpreter;
+    constructor(options: ShellSessionOptions);
+    run(source: string, options?: ShellExecutionOptions): ShellExecution;
+    runProgram(program: Program, options?: ShellExecutionOptions): ShellExecution;
+    getCwd(): string;
+    getEnv(): Record<string, string>;
+    getLastExitCode(): number;
+    complete(source: string, cursor?: number): Promise<CompletionResult>;
+    dispose(): Promise<void>;
+    private completePath;
+    private createImmediateExecution;
+}
+export declare function createShellSession(config: ShellConfig): ShellSession;

package/dist/types/src/types.d.ts

@@ -49,6 +49,30 @@ export interface ShellCommandApi {
     getLastExitCode(): number;
     exit(exitCode?: number): never;
 }
+export interface TerminalInfo {
+    isTTY: boolean;
+    columns?: number;
+    rows?: number;
+    colorDepth?: number;
+}
+export interface CompletionContext {
+    source: string;
+    cursor: number;
+    command: string;
+    args: string[];
+    word: string;
+    wordStart: number;
+    wordEnd: number;
+    cwd: string;
+    env: Record<string, string>;
+    fs: VirtualFS;
+    terminal: TerminalInfo;
+}
+export interface CompletionResult {
+    replacement: string;
+    matches: string[];
+}
+export type CommandCompleter = (ctx: CompletionContext) => CompletionResult | Promise<CompletionResult>;
 export interface CommandContext {
     args: string[];
     stdin: Stdin;
@@ -57,16 +81,27 @@ export interface CommandContext {
     fs: VirtualFS;
     cwd: string;
     env: Record<string, string>;
+    terminal: TerminalInfo;
+    signal: AbortSignal;
     setCwd: (path: string) => void;
     exec?: (name: string, args: string[]) => Promise<ExecResult>;
     shell?: ShellCommandApi;
 }
+export interface ExternalCommandContext extends CommandContext {
+    name: string;
+}
+export type ShellCommandFallback = (ctx: ExternalCommandContext) => Promise<number>;
 export interface Stdin {
     stream(): AsyncIterable<Uint8Array>;
     buffer(): Promise<Buffer>;
     text(): Promise<string>;
     lines(): AsyncIterable<string>;
 }
+export interface ShellInputController extends AsyncIterable<Uint8Array> {
+    write(chunk: Uint8Array | string): Promise<void>;
+    close(): void;
+    abort(reason?: unknown): void;
+}
 export interface Stdout {
     write(chunk: Uint8Array): Promise<void>;
     writeText(str: string): Promise<void>;
@@ -87,12 +122,35 @@ export interface ExecResult {
     stderr: Buffer;
     exitCode: number;
 }
+export interface ShellOutputEvent {
+    fd: 1 | 2;
+    chunk: Uint8Array;
+}
+export type ShellInputSource = AsyncIterable<Uint8Array> | Buffer | string | null;
+export interface ShellExecutionOptions {
+    stdin?: ShellInputSource;
+    stdout?: Stdout;
+    stderr?: Stderr;
+    terminal?: TerminalInfo;
+    signal?: AbortSignal;
+    outputMode?: "separate" | "merged";
+}
+export interface ShellExecution {
+    stdout: AsyncIterable<Uint8Array>;
+    stderr: AsyncIterable<Uint8Array>;
+    output: AsyncIterable<ShellOutputEvent>;
+    exit: Promise<ExecResult>;
+    kill(reason?: unknown): void;
+}
 export interface ShellConfig {
     fs: VirtualFS;
     cwd: string;
     env: Record<string, string>;
     commands: Record<string, Command>;
+    completions?: Record<string, CommandCompleter>;
     isTTY?: boolean;
+    terminal?: TerminalInfo;
+    externalCommand?: ShellCommandFallback;
 }
 export interface RawValue {
     raw: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shell-dsl",
-  "version": "0.0.40",
+  "version": "0.0.42",
   "description": "A sandboxed shell-style DSL for running scriptable command pipelines in-process without host OS access",
   "author": "ricsam <oss@ricsam.dev>",
   "license": "MIT",