@toddzheng024/dscode-desktop 0.0.0-stage → 0.7.34

package/vendor/terminal/types/config.d.ts

@@ -0,0 +1,82 @@
+/** Validated configuration for the local PTY backend. */
+import z from '@deepseek-ai/schemastery';
+/** One supported interactive shell dialect. */
+export type ShellDialect = 'bash' | 'pwsh';
+/** Public plugin configuration. */
+export interface Config {
+    /** Backend registry type (default: `shell`). */
+    backendType?: string;
+    /** Interactive shell dialect (default: `bash`); selects the argv/env/startup defaults. */
+    shellDialect?: ShellDialect;
+    /** Interactive shell executable (default per dialect: `/bin/bash`, or the resolved pwsh). */
+    shellPath?: string;
+    /** Shell arguments (default per dialect: bash `--noprofile --norc -i`, pwsh `-NoLogo -NoProfile`). */
+    shellArgs?: string[];
+    /** Terminal rows. */
+    rows?: number;
+    /** Terminal columns. */
+    cols?: number;
+    /** Maximum retained logical lines. */
+    scrollbackLines?: number;
+    /** Maximum retained UTF-8 bytes. */
+    scrollbackMaxBytes?: number;
+    /** Maximum bytes returned by one read or settled viewport. */
+    maxReadBytes?: number;
+    /** Readiness polling interval. */
+    pollIntervalMs?: number;
+    /** Delay before Linux exact syscall probes. */
+    exactProbeAfterMs?: number;
+    /** Silence duration that yields `inferred_idle`. */
+    idleSilenceMs?: number;
+    /**
+     * Extra wait beyond `idleSilenceMs`, once a prompt marker was seen, for the shell to
+     * regain the foreground before `inferred_idle` settles; at least one `pollIntervalMs`.
+     */
+    handoffGraceMs?: number;
+    /**
+     * Extra wait beyond `idleSilenceMs` and `handoffGraceMs`, once a prompt marker was seen but
+     * its printable tail has not arrived, before `inferred_idle` settles. The marker is written
+     * by the shell's own prompt function and the tail by the same render, so a missing tail is a
+     * delivery delay on a contended host rather than an absent prompt. Zero keeps the bound at
+     * `idleSilenceMs + handoffGraceMs`; any other value covers at least one `pollIntervalMs`, so a
+     * nonzero tolerance always contains a readiness poll.
+     */
+    promptTailGraceMs?: number;
+    /** Absolute bound for one send and the complete pwsh startup sequence. */
+    timeoutMs?: number;
+    /** Grace before teardown escalates to `SIGKILL`. */
+    disposeGraceMs?: number;
+}
+/** Configuration after Schemastery defaults and dialect resolution. */
+export type ResolvedConfig = Omit<Required<Config>, 'shellDialect' | 'shellPath' | 'shellArgs'> & {
+    shellDialect: ShellDialect;
+    shellPath: string;
+    shellArgs: string[];
+};
+/** Bash dialect default executable. */
+export declare const DEFAULT_BASH_SHELL = "/bin/bash";
+/** Bash dialect default arguments (interactive, profile-free). */
+export declare const DEFAULT_BASH_ARGS: string[];
+/** Pwsh dialect default arguments (interactive host, profile-free). */
+export declare const DEFAULT_PWSH_ARGS: string[];
+/**
+ * Resolve the effective per-dialect shell specification. Defaulting is this
+ * explicit step: an unset or empty `shellPath`/`shellArgs` selects the
+ * dialect's defaults, while a non-empty explicit value always wins.
+ * (Schemastery materializes an absent optional array as `[]`, so emptiness —
+ * not just `undefined` — means "dialect default".)
+ * @param config - Schemastery-resolved plugin configuration.
+ * @returns the fully resolved configuration.
+ */
+export declare function resolveConfig(config: Config): ResolvedConfig;
+/** Schemastery config exposed by the plugin. */
+export declare const Config: z<Config>;
+/**
+ * Assert every effective numeric config field is a positive safe integer — except
+ * `promptTailGraceMs`, whose zero is the documented "no extension" value — and that bounds
+ * compose.
+ * @param config - Schemastery-resolved plugin configuration.
+ * @returns Narrows the input to the fully resolved configuration.
+ */
+export declare function validateConfig(config: Config): asserts config is ResolvedConfig;
+//# sourceMappingURL=config.d.ts.map

package/vendor/terminal/types/index.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Persistent shell PTY backend over the subprocess terminal primitive, shared
+ * sandbox policy, bounded output, and provider-owned session cleanup.
+ * @module @deepseek-ai/dsh-terminal-bash
+ */
+import { Context } from '@deepseek-ai/cordis';
+import type { TerminalBackend, TerminalBackendSpawnSpec } from '@deepseek-ai/dsh-terminal';
+import type { SubprocessTerminalHandle, SubprocessTerminalSpawnSpec } from '@deepseek-ai/dsh-subprocess';
+import { type Config, type ResolvedConfig } from './config.ts';
+import { LocalPtySession } from './session.ts';
+export { Config } from './config.ts';
+export type { Config as TerminalLocalConfig } from './config.ts';
+/** Cordis plugin name. */
+export declare const name = "terminal-bash";
+/** Required services: terminal registry, shared confinement policy, projection registry, and process substrate. */
+export declare const inject: string[];
+/**
+ * The pwsh prompt function that emits the shared OSC `133;D;` + BEL marker
+ * before every prompt, mirroring bash's PROMPT_COMMAND. `[char]27`/`[char]7`
+ * build the control bytes at runtime because raw ESC characters in submitted
+ * input are unreliable under PSReadLine.
+ */
+export declare const PWSH_PROMPT_SETUP: string;
+/** Local shell backend registered under the configured type. */
+export declare class BashTerminalBackend implements TerminalBackend {
+    private readonly ctx;
+    private readonly config;
+    private readonly spawnTerminal;
+    private readonly createSession;
+    readonly type: string;
+    constructor(ctx: Context, config: ResolvedConfig, spawnTerminal?: (spec: SubprocessTerminalSpawnSpec) => Promise<SubprocessTerminalHandle>, createSession?: (terminal: SubprocessTerminalHandle, config: ResolvedConfig) => LocalPtySession);
+    spawn(spec: TerminalBackendSpawnSpec): Promise<LocalPtySession>;
+}
+/** Register the local PTY backend. */
+export declare function apply(ctx: Context, config: Config): void;
+//# sourceMappingURL=index.d.ts.map

package/vendor/terminal/types/sanitize.d.ts

@@ -0,0 +1,47 @@
+/** Streaming terminal-control sanitizer for the line-oriented first release. */
+/** OSC marker emitted by the controlled bash before each prompt. */
+export declare const PROMPT_MARKER_PREFIX = "133;D;";
+/** Exact printable prompt emitted after the private marker. */
+export declare const CONTROLLED_PROMPT = "dsh> ";
+/** One sanitized chunk plus whether it contained the owned prompt marker. */
+export interface SanitizedChunk {
+    text: string;
+    prompt: boolean;
+    /** Printable text after the latest owned marker in this chunk. */
+    promptTail?: string;
+}
+/**
+ * Remove CSI/OSC/short escape sequences while preserving split-sequence carry.
+ * Full terminal emulation is deliberately deferred; ordinary line output and
+ * the private prompt marker are the supported contract.
+ */
+export declare class TerminalSanitizer {
+    private readonly maxPendingBytes;
+    private pending;
+    private discardMode;
+    private discardOscEscape;
+    private trailingCarriageReturn;
+    private trackingPromptTail;
+    constructor(maxPendingBytes: number);
+    /**
+     * Consume one decoded `node-pty` data chunk.
+     * @param chunk - decoded terminal data.
+     * @returns Printable text and whether the private prompt marker completed.
+     */
+    push(chunk: string): SanitizedChunk;
+    /**
+     * Flush a trailing printable fragment when the PTY exits.
+     * @returns Remaining printable text; incomplete escapes are discarded.
+     */
+    flush(): string;
+    private normalizeText;
+    private enforcePendingBound;
+    private discardPrefix;
+}
+/**
+ * Normalize CRLF and standalone carriage returns for line-oriented rendering.
+ * @param text - sanitized terminal text.
+ * @returns Line-normalized text with BEL removed.
+ */
+export declare function normalizeTerminalText(text: string): string;
+//# sourceMappingURL=sanitize.d.ts.map

package/vendor/terminal/types/session.d.ts

@@ -0,0 +1,87 @@
+/** Persistent PTY session with bounded output, readiness, and terminal-protocol replies. */
+import type { SubprocessTerminalHandle } from '@deepseek-ai/dsh-subprocess';
+import type { TerminalBackendSession, TerminalReadRequest, TerminalReadResult, TerminalSendOperation, TerminalSendRequest, TerminalSessionStatus, TerminalSignal, TerminalSignalResult } from '@deepseek-ai/dsh-terminal';
+import type { ResolvedConfig } from './config.ts';
+/** Backend session wrapping one provider-owned terminal process. */
+export declare class LocalPtySession implements TerminalBackendSession {
+    private readonly terminal;
+    private readonly config;
+    motd: string;
+    readonly pid: number;
+    private readonly decoder;
+    /** Protocol state only; the sanitizer and bounded buffers own returned text. */
+    private readonly emulator;
+    private readonly emulatorData;
+    private readonly sanitizer;
+    private readonly scrollback;
+    private readonly outputEnded;
+    private readonly completion;
+    private statusValue;
+    private active;
+    private activeTimer;
+    private activeDeadlineTimer;
+    private activeAbort;
+    private interrupting;
+    private activeWrite;
+    private pollingReady;
+    private polling;
+    private promptSeen;
+    private promptTextSeen;
+    private promptTail;
+    private shellPgid;
+    private initializing;
+    private lastOutputAt;
+    private closing;
+    private closePromise;
+    private transportFailure;
+    private emulatorWrites;
+    private emulatorWriteDone;
+    private emulatorBuffer;
+    private emulatorWriting;
+    private responseWrites;
+    private pendingResponseWrites;
+    private emulatorClosed;
+    constructor(terminal: SubprocessTerminalHandle, config: ResolvedConfig);
+    /**
+     * Capture startup output through the same readiness contract as later sends.
+     * @param signal - optional cancellation while the shell reaches its first prompt.
+     * @returns Resolves after startup readiness; rejects on exit or readiness timeout.
+     */
+    initialize(signal?: AbortSignal): Promise<void>;
+    startSend(request: TerminalSendRequest): TerminalSendOperation;
+    private beginSend;
+    private resetReadinessEvidence;
+    read(request: TerminalReadRequest): TerminalReadResult;
+    signal(signal: TerminalSignal): Promise<TerminalSignalResult>;
+    status(): TerminalSessionStatus;
+    close(reason: string): Promise<void>;
+    private readonly onTerminalData;
+    private readonly onTerminalEnd;
+    private readonly onTerminalError;
+    private onData;
+    private onExit;
+    private onTransportFailure;
+    private appendOutput;
+    private schedulePoll;
+    private pollReadiness;
+    /** Wait until generated replies reach the provider before another send can publish. */
+    private drainTerminalProtocol;
+    /** Sample foreground state only after protocol replies are quiet for the entire inspection. */
+    private inspectForegroundAfterProtocol;
+    private protocolStateChanged;
+    private protocolWorkPending;
+    private queueEmulatorData;
+    private pumpEmulator;
+    private finishResponseWrite;
+    private releaseSettledActive;
+    private closeEmulator;
+    private settleActive;
+    private stopPolling;
+    private stopReadinessPolling;
+    private clearActive;
+    private failActive;
+    private interrupt;
+    private interruptOnce;
+    private closeOnce;
+}
+//# sourceMappingURL=session.d.ts.map