dsh-over-ssh 0.1.0 → 0.1.1

package/lib/types/src/host/infra/transport/agent-transport.d.ts

@@ -1,353 +0,0 @@
-/**
- * 代理传输：把协议客户端适配成 {@link Transport}。
- *
- * 从原 3,388 行文件拆出（审计 0077）：协议层（帧 / 类型 / 客户端）已移到
- * `agent-protocol-{frames,types,client}.ts`，本文件只剩**传输适配**——连接状态机、
- * 能力探测、各方法的 RPC 调用、以及真实启动器。
- *
- * 兼容性：下面 re-export 三个协议模块，既有调用方（integration / wiring / tests）
- * 从 `agent-transport.ts` 取符号的路径不变。
- *
- * @module dsh-remote-workspace/infra/transport/agent-transport
- */
-export * from './agent-protocol-frames.ts';
-export * from './agent-protocol-types.ts';
-export * from './agent-protocol-codec.ts';
-export * from './agent-protocol-errors.ts';
-export * from './agent-protocol-client.ts';
-import { type RemoteCapabilities } from '../../domain/capability.ts';
-import { type ExecRequest, type ExecResult, type ReadFileRangeRequest, type ReadFileRequest, type RemoteFileChunk, type RemoteStatResult, type RemoteWriteOutcome, type RemoveRequest, type RenameRequest, type Transport, type WriteFileRangeRequest, type WriteFileRequest } from './transport.ts';
-import type { EditFileRequest, EditFileResult, HashFileRequest, HashFileResult, JobStdinRequest, JobStdinResult, MakeDirRequest, GlobPathsRequest, GlobPathsResult, RemovePathRequest, RenamePathRequest } from './transport.ts';
-import { TransportBase } from './transport-base.ts';
-import type { AgentLauncher, AgentTransportOptions, AgentIndexScanResult, AgentProcStartRequest, AgentJobStatus, AgentJobKill, AgentJobOutput, AgentLspStartRequest, AgentLspStatus, AgentLspRead, AgentIndexScanRequest, AgentSearchResult, AgentSearchGrepRequest, AgentWatchStartResult, AgentWatchStartRequest, AgentWatchPollResult, AgentWatchPollRequest, AgentWatchStopResult, AgentCapabilities } from './agent-protocol-types.ts';
-export declare class AgentTransport extends TransportBase implements Transport {
-    #private;
-    readonly id: string;
-    constructor(options: AgentTransportOptions);
-    /**
-     * Session the agent echoed at handshake (`hello.result.sessionId`), or `undefined` when it sent none.
-     *
-     * `undefined` is the honest answer for an agent that predates sessions, and callers must not treat it as
-     * `"default"`: doing so would claim per-session isolation the agent never agreed to.
-     */
-    get negotiatedSessionId(): string | undefined;
-    /**
-     * Whether the agent said jobs outlive this connection (`hello.result.daemon`).
-     *
-     * `false` until a handshake says otherwise, because today's agent does tie job lifetime to the
-     * connection; assuming `true` would make callers skip the cleanup that is still required.
-     */
-    get daemon(): boolean;
-    /**
-     * The agent's own capability record (Tier 2 facts).
-     *
-     * `capabilities` is deliberately the Tier 1 shape, so the agent's extra bits (`watch`, `index`,
-     * `atomicWrite`, `landlock`, `exec`) would otherwise be dropped on the floor. Tier 2 callers must gate
-     * on **this** record: `watch !== 'native'` means no `watch.*`, and `exec !== true` means no `proc.exec`.
-     * Empty until the first handshake.
-     */
-    get agentCapabilities(): AgentCapabilities;
-    /** `uname` derived from the agent's `os`, or `undefined` when the agent reported nothing usable. */
-    get agentUname(): string | undefined;
-    /**
-     * Open the session and handshake. Idempotent and single-flight: concurrent callers share one attempt.
-     *
-     * @throws SshDevError `CONNECTION_LOST` when the handshake fails or the protocol version mismatches
-     *   (the only correct reaction is falling back to Tier 1), `CONNECTION_UNREACHABLE` when the session
-     *   cannot be started at all.
-     */
-    connect(signal?: AbortSignal): Promise<void>;
-    /**
-     * Close the session. Idempotent, and safe to call while connecting (the attempt is abandoned).
-     *
-     * A later `connect` opens a fresh session, so the transport is reusable after a disconnect.
-     */
-    dispose(): Promise<void>;
-    /**
-     * Run one command through the agent.
-     *
-     * Protocol v1 has no arbitrary-command method, so there are exactly two paths:
-     *
-     *  - an injected {@link AgentExecCommand} (a deployment whose agent build does add one);
-     *  - otherwise the client asks `proc.exec` and maps `E_METHOD` onto `REMOTE_UNSUPPORTED` — an honest
-     *    "this agent version cannot run commands", never a silent fallback to the Tier 1 transport.
-     */
-    exec(request: ExecRequest, signal?: AbortSignal): Promise<ExecResult>;
-    /**
-     * Stat a path with the agent's own `fs.stat`, so the token is the **same one `fs.read` reports**.
-     *
-     * This is the member that closes the read→write token gap on Tier 2. `fs.stat` returns the agent's
-     * `Version{Size, MtimeNs}.String()` (`size:mtimeNs`), which is exactly what `fs.read` returns and exactly
-     * what `fs.write`'s `expectedVersion` guard compares against. Deriving a token here instead — or letting
-     * the caller fall back to a shell `stat -c '%Y'` — would produce seconds and make every guard mismatch.
-     *
-     * The agent's `version` string is passed through **untouched** rather than re-formatted locally: there is
-     * one token producer (the agent) and this is not a second one.
-     */
-    statPath(path: string, signal?: AbortSignal): Promise<RemoteStatResult>;
-    /**
-     * Read a remote file: `fs.read` (control frame) followed by its blob frame.
-     *
-     * The version token is the string the **agent** returned (`size:mtimeNs`), passed through untouched:
-     * re-deriving it locally would produce a token that no longer matches the guard the agent applies on
-     * the next write. Note this is *not* byte-identical to the Tier 1 `size:mtimeSeconds` token, because
-     * the agent reports nanoseconds (verified in its `Version.String()`); {@link statPath} exists so a caller
-     * can obtain the *same* Tier 2 token from a stat instead of comparing the two shapes.
-     */
-    readFile(request: ReadFileRequest, signal?: AbortSignal): Promise<RemoteFileChunk>;
-    /**
-     * Write a remote file: `fs.write` (control frame, then one blob frame with the content).
-     *
-     * **The guard here is a version comparison, not a digest comparison.** Protocol v1's `fs.write` accepts
-     * `expectedVersion` and nothing else, so the guard is implemented as: `fs.stat` the target, refuse when the
-     * observed version differs from the caller's token, and otherwise pass that same version to the agent as
-     * `expectedVersion` so the agent re-checks it at write time (that is the compare-and-swap closing the race
-     * between our stat and our write). When the target does not exist, no version token can match, so the write
-     * is refused with `TRANSFER_CONFLICT` rather than overwriting blind.
-     *
-     * **Which field carries the token.** {@link WriteFileRequest.expectedVersion} is the explicit channel and
-     * wins when present. {@link WriteFileRequest.expectedSha256} is still accepted as a *version* token for
-     * callers written before the explicit field existed, and that legacy overloading is exactly what this
-     * transport used to do implicitly; the error details say `guard: 'version'` in both cases so a caller is
-     * never told a digest was verified when a version was.
-     *
-     * The alternative — refusing every guarded write with `REMOTE_UNSUPPORTED` — was rejected because the
-     * version round trip is available, cheap, and strictly safer than an unguarded overwrite.
-     */
-    writeFile(request: WriteFileRequest, signal?: AbortSignal): Promise<RemoteWriteOutcome>;
-    /**
-     * Offset read: the agent's own `fs.read` with `offset`.
-     *
-     * This used to borrow `proc.exec` (`tail -c +N | head -c M | base64`) because protocol v1's `fs.read` had no
-     * offset. The agent now serves `offset` natively (audit 0006), so the shell hop is gone: no `tail`/`head`/
-     * `base64` on the remote, no shell quoting, and the bytes are framed instead of base64-inflated (the old path
-     * asked for `2 * cap + 4096` bytes of headroom precisely because of that inflation).
-     *
-     * The agent's `truncated` already means "there is more after this window", so it is passed through rather
-     * than recomputed from `size - offset`.
-     */
-    readFileRange(request: ReadFileRangeRequest, signal?: AbortSignal): Promise<RemoteFileChunk>;
-    /**
-     * Positioned write: `fs.write` with `offset` (the agent's `WriteAt`).
-     *
-     * This used to shell out (`dd of=… seek=… conv=notrunc`) because protocol v1's `fs.write` only replaced a
-     * whole file. The agent serves `offset` natively now (audit 0006), so the payload travels as a real blob
-     * frame instead of base64-on-stdin: no `dd`, no shell quoting, and no 4/3 size inflation. The agent owns the
-     * POSIX rules (offset 0 may create and keeps the tail, offset > 0 refuses a missing file) — see
-     * `WriteAt` in the agent, which is the single place those rules are written down.
-     */
-    writeFileRange(request: WriteFileRangeRequest, signal?: AbortSignal): Promise<RemoteWriteOutcome>;
-    /** Move a path; a cross-device move fails instead of silently copying. */
-    /** {@inheritDoc Transport.editFile} — atomic in-place edit: one round trip, no file transfer. */
-    editFile(request: EditFileRequest, signal?: AbortSignal): Promise<EditFileResult>;
-    /** {@inheritDoc Transport.removePath} */
-    removePath(request: RemovePathRequest, signal?: AbortSignal): Promise<void>;
-    /** {@inheritDoc Transport.renamePath} */
-    renamePath(request: RenamePathRequest, signal?: AbortSignal): Promise<void>;
-    /** {@inheritDoc Transport.hashFile} */
-    hashFile(request: HashFileRequest, signal?: AbortSignal): Promise<HashFileResult>;
-    /** {@inheritDoc Transport.makeDir} */
-    makeDir(request: MakeDirRequest, signal?: AbortSignal): Promise<void>;
-    /** {@inheritDoc Transport.globPaths} */
-    globPaths(request: GlobPathsRequest, signal?: AbortSignal): Promise<GlobPathsResult>;
-    /** `proc.stdin` for the job layer: same call, job-shaped arguments (审计 0030). */
-    procStdin(id: string, data: string, close: boolean, signal?: AbortSignal): Promise<JobStdinResult>;
-    /** {@inheritDoc Transport.jobStdin} */
-    jobStdin(request: JobStdinRequest, signal?: AbortSignal): Promise<JobStdinResult>;
-    rename(request: RenameRequest, signal?: AbortSignal): Promise<void>;
-    /** Remove a file or (with `recursive`) a directory tree. */
-    remove(request: RemoveRequest, signal?: AbortSignal): Promise<void>;
-    /**
-     * Enumerate remote files for `@` completion: `index.scan`.
-     *
-     * Gated on `agentCapabilities.index === true` **before** anything is written; when the agent did not
-     * advertise indexing this throws `REMOTE_UNSUPPORTED` and leaves `agent.methods()` untouched, so a
-     * caller can fall back to Tier 1 without a wasted round trip.
-     *
-     * The returned numbers are **the agent's own report** (entry count, strategy, truncation); this client
-     * does not re-validate them, and an unrecognised `strategy` stays unrecognised (`"unknown"`).
-     *
-     * This is the **full** scan. When the agent has a snapshot from a previous scan it can refresh
-     * incrementally instead — see {@link scanIndexRefresh}, which is what a caller polling for `@` completion
-     * should use after the first scan.
-     *
-     * The agent's per-scan deadline is the request's `timeoutMs` (it has its own 5 s default); the *client's*
-     * deadline is the transport's `requestTimeoutMs`.
-     *
-     * @throws SshDevError `REMOTE_UNSUPPORTED` when the capability is absent, `REMOTE_COMMAND_FAILED`
-     *   (`E_PARAMS`) for an empty `roots`, `CANCELLED`/`CONNECTION_LOST` per the shared request rules.
-     */
-    scanIndex(request: AgentIndexScanRequest, signal?: AbortSignal): Promise<AgentIndexScanResult>;
-    /**
-     * Refresh the remote index **incrementally**: `index.refresh`.
-     *
-     * The agent keeps a bounded snapshot per (roots, caps) identity from the last scan and reuses the file
-     * listing of every directory whose mtime did not move, so a poll after the first scan costs
-     * `O(directories)` instead of `O(files)`. Measured on a synthetic 13-directory / 52-file tree:
-     * 65 syscalls → 13.
-     *
-     * **The agent's own report is what the caller gets.** When it cannot refresh safely (no snapshot yet,
-     * different roots, expired entry) it answers with a full scan and says so in `strategy`/`warnings` — this
-     * method never pretends an incremental answer was incremental.
-     *
-     * ## The boundary a caller must know
-     *
-     * A reused directory keeps the `size`/`mtimeNs` recorded at the last scan: a directory's mtime does not
-     * change when a file's **content** changes, only when its set of entries does. So this is right for
-     * `@` completion (which needs paths and kinds, and where added/removed/renamed files *are* picked up), and
-     * wrong for anything that needs current file sizes. Use {@link scanIndex} for that.
-     *
-     * @throws SshDevError same vocabulary as {@link scanIndex}. An agent predating `index.refresh` answers
-     *   `E_METHOD`, which maps to `REMOTE_UNSUPPORTED` — callers should treat that as "fall back to scanIndex".
-     */
-    scanIndexRefresh(request: AgentIndexScanRequest, signal?: AbortSignal): Promise<AgentIndexScanResult>;
-    /**
-     * Start a background command and return immediately: `proc.start`.
-     *
-     * The agent runs it in a job table and answers with an id; progress and output come from
-     * {@link procStatus} / {@link procOutput}. **Nothing is pushed** - v1's frame discipline (a control
-     * frame plus an optional blob frame, strictly paired, written by one goroutine) has no room for
-     * server-initiated frames, so the caller polls.
-     *
-     * Jobs die with the connection: the agent kills them all when the ssh channel closes. This is
-     * "reconnectable within one connection", not a durable task queue.
-     *
-     * @throws SshDevError `REMOTE_UNSUPPORTED` when the agent predates `proc.start` (`E_METHOD`).
-     */
-    procStart(request: AgentProcStartRequest, signal?: AbortSignal): Promise<AgentJobStatus>;
-    /**
-     * One job's state: `proc.status`.
-     *
-     * @throws SshDevError `REMOTE_NOT_FOUND` for an unknown (or already forgotten) id.
-     */
-    procStatus(id: string, signal?: AbortSignal, waitMs?: number): Promise<AgentJobStatus>;
-    /**
-     * Incremental output read: `proc.output`.
-     *
-     * `offset` is a **position, not a cursor**: pass `nextOffset` from the previous call to get only what is
-     * new. Re-reading an older offset re-sends that span (nothing is remembered as already read).
-     *
-     * The agent keeps a bounded ring buffer that drops the **oldest** bytes (errors tend to be at the end),
-     * so a result with `lost: true` means the requested span was already discarded - the caller must not
-     * treat it as continuous output.
-     */
-    procOutput(id: string, offset?: number, signal?: AbortSignal, waitMs?: number): Promise<AgentJobOutput>;
-    /** Terminate a job: `proc.kill`. Idempotent - an already-finished job answers `killed: false`. */
-    procKill(id: string, signal?: AbortSignal): Promise<AgentJobKill>;
-    /**
-     * End one session explicitly: kill its running jobs and drop its finished ones (`session.end`).
-     *
-     * With `--shared` (the default) a daemon keeps jobs alive across connections, so a session that
-     * simply goes away leaves its long-running commands behind — "survives reconnects" would silently
-     * become "leaks forever" (protocol.md §9.4). Callers end the session when it is genuinely over.
-     *
-     * Idempotent: an unknown or already-clean session reports `killed: 0, forgotten: 0`.
-     */
-    endSession(session?: string, signal?: AbortSignal): Promise<{
-        readonly session: string;
-        readonly killed: number;
-        readonly forgotten: number;
-        readonly lspStopped: number;
-    }>;
-    /** Every job this connection has started: `proc.list`. */
-    procList(signal?: AbortSignal): Promise<readonly AgentJobStatus[]>;
-    /**
-     * Host a language server: `lsp.start`.
-     *
-     * The agent is a **stdio pipe**, not an LSP implementation: it starts the process and moves bytes.
-     * `lspWrite` takes bytes (base64 on the wire) and `lspRead` pages the server's output by offset - the
-     * caller owns all JSON-RPC framing and semantics.
-     *
-     * @throws SshDevError `REMOTE_UNSUPPORTED` when the agent predates `lsp.start`.
-     */
-    lspStart(request: AgentLspStartRequest, signal?: AbortSignal): Promise<AgentLspStatus>;
-    /** Send bytes to a language server's stdin: `lsp.write` (base64 on the wire). */
-    lspWrite(id: string, bytes: Uint8Array, signal?: AbortSignal): Promise<{
-        readonly id: string;
-        readonly written: number;
-        readonly state: string;
-    }>;
-    /** Read a language server's output from `offset`: `lsp.read`. Same offset semantics as {@link procOutput}. */
-    lspRead(id: string, offset?: number, signal?: AbortSignal): Promise<AgentLspRead>;
-    /** One language-server session's state: `lsp.status`. */
-    lspStatus(id: string, signal?: AbortSignal): Promise<AgentLspStatus>;
-    /** Terminate a language-server session: `lsp.stop` (closes stdin, then kills if it will not exit). */
-    lspStop(id: string, signal?: AbortSignal): Promise<AgentLspStatus>;
-    /**
-     * Bounded content search: `search.grep`, always available in protocol v1 (no capability bit gates it).
-     *
-     * `literal` defaults to the wire default (`true`); `ignoreCase` defaults to `true` and is written as
-     * the agent's inverted `caseSensitive` flag. Everything the caller omits is omitted from the frame, so
-     * the agent's own default applies — this client does not pre-fill values it cannot see the effect of.
-     *
-     * A regex that the *agent* cannot compile comes back as `E_PARAMS` → `REMOTE_COMMAND_FAILED`; v1 has no
-     * cancel frame, so a long search is bounded only by `timeoutMs` and the workload caps.
-     *
-     * @throws SshDevError `REMOTE_COMMAND_FAILED` for an empty `paths`/`query` (refused locally),
-     *   `REMOTE_UNSUPPORTED` when the agent answers `E_METHOD` (plugin/agent version mismatch).
-     */
-    searchGrep(request: AgentSearchGrepRequest, signal?: AbortSignal): Promise<AgentSearchResult>;
-    /**
-     * Start (or replace) the remote native watcher: `watch.start`.
-     *
-     * Requires `agentCapabilities.watch === 'native'`. `'poll'` (darwin/windows builds) and `'none'` are
-     * **not** enough: on those platforms the protocol answers `E_UNSUPPORTED`, and the intended Tier 1
-     * behaviour is polling by the plugin — so this method refuses locally with `REMOTE_UNSUPPORTED`.
-     *
-     * `watched` is the list of **roots** that were really registered — not every subdirectory — and
-     * `truncated` (not a thrown error) is how `maxWatches` / the kernel's `max_user_watches` report that
-     * only part of a tree is covered. Calling `start` while a watcher runs replaces it; a failed
-     * replacement leaves no watcher behind, because the old one is stopped first.
-     */
-    startWatch(request: AgentWatchStartRequest, signal?: AbortSignal): Promise<AgentWatchStartResult>;
-    /**
-     * Collect queued watch events: `watch.poll`.
-     *
-     * Since ADR-0009 the agent dispatches requests concurrently, so a poll no longer blocks the connection:
-     * a concurrent `fs.read`/`search.grep` proceeds and is answered as soon as the agent gets to it. The poll
-     * still *occupies one in-flight slot* for up to `timeoutMs`, so a loop of long polls can crowd the
-     * {@link DEFAULT_AGENT_MAX_IN_FLIGHT}-slot window; keep `timeoutMs` small and poll in a loop, or use a
-     * second connection when you need a dedicated watcher.
-     *
-     * Keep `timeoutMs` below the transport's `requestTimeoutMs` (default 15 s): the client deadline is a
-     * separate clock, and when it fires first the poll fails with `CONNECTION_LOST` even though the agent
-     * is healthy. `timeout: true` with few or no events is the normal "nothing happened" outcome, not an
-     * error; when `truncated` is true the remaining events are still queued, so poll again.
-     *
-     * `dropped` is **cumulative since `watch.start`**; a growing value (or `truncated`) means the event
-     * stream is incomplete and the honest reaction is a full `scanIndex` rescan.
-     */
-    pollWatch(request?: AgentWatchPollRequest, signal?: AbortSignal): Promise<AgentWatchPollResult>;
-    /**
-     * Stop one remote watcher: `watch.stop`. Idempotent, and stopping an absent watcher is **not** an
-     * error — the agent answers `{ "stopped": false }`, which is returned as-is.
-     *
-     * `watcherId` selects which watcher to stop; omit it for the agent's `"default"` watcher, which is what
-     * a caller that never sets one has always stopped. Stopping one id never touches another, so two
-     * sessions sharing a connection cannot stop each other's listener.
-     *
-     * The first parameter also still accepts an `AbortSignal` (the pre-`watcherId` signature), so a caller
-     * written against the old positional form keeps working instead of having its signal silently read as a
-     * watcher name. Prefer the explicit two-argument form.
-     *
-     * Unpolled events are discarded by the agent, so a caller that needs a consistent view must rescan
-     * rather than assume the queue survives the stop.
-     */
-    stopWatch(watcherId?: string | AbortSignal, signal?: AbortSignal): Promise<AgentWatchStopResult>;
-    /**
-     * Discover capabilities from the agent, cached like the other transports.
-     *
-     * The handshake already carries the capability record, so a fresh connection answers from cache;
-     * `maxAgeMs` (default 5 minutes) decides when to re-ask.
-     */
-    probeCapabilities(signal?: AbortSignal, maxAgeMs?: number): Promise<RemoteCapabilities>;
-}
-/**
- * The real launcher: `ssh <alias> <agent> --stdio` through `node:child_process`.
- *
- * Only this function touches the process API; every test injects its own launcher. stdout carries
- * protocol frames only (the agent writes diagnostics to stderr), so stderr is inherited for the
- * operator and stdin is the pipe this client owns.
- */
-export declare const defaultLauncher: AgentLauncher;
-//# sourceMappingURL=agent-transport.d.ts.map

package/lib/types/src/host/infra/transport/alias-transport.d.ts

@@ -1,206 +0,0 @@
-/**
- * The `alias` transport: the system OpenSSH client in ControlMaster mode.
- *
- * Why the system client: it inherits everything the user already configured — `~/.ssh/config`
- * aliases, identity files, `ProxyJump`, `known_hosts`, ssh-agent — which is exactly the
- * "import type { MultiplexingCache } from './transport.ts';
-
-import my ssh config and it just works" requirement. Password authentication is not offered
- * here (a non-interactive `ssh` must not block on a prompt); the `ssh2` transport covers that.
- *
- * Remote file bytes travel as base64 over the multiplexed connection, so the plugin needs
- * nothing installed on the remote host beyond POSIX `sh`, `base64` and (for version tokens)
- * `stat` or `wc`.
- *
- * @module dsh-remote-workspace/infra/transport/alias-transport
- */
-import { type RemoteCapabilities } from '../../domain/capability.ts';
-import type { HostKeyPolicy } from '../../domain/connection.ts';
-import { type ExecRequest, type ExecResult, type ReadFileRangeRequest, type ReadFileRequest, type RemoteFileChunk, type RemoteWriteOutcome, type RemoveRequest, type RenameRequest, type Transport, type TransportState, type WriteFileRangeRequest, type WriteFileRequest } from './transport.ts';
-import type { MultiplexingCache } from './transport.ts';
-export type { MultiplexingCache } from './transport.ts';
-/** One spawned process result as reported by the injected spawner. */
-export interface SpawnResult {
-    readonly code: number;
-    readonly signal: string | null;
-    readonly stdout: string;
-    readonly stderr: string;
-    /** Whether the spawner cut stdout at the requested cap. */
-    readonly truncated?: boolean;
-    /**
-     * Whether the spawner dropped stderr bytes.
-     *
-     * Optional because a spawner is free not to track it; absent means "this spawner cannot say", and the
-     * transport then reports `false` rather than guessing. `createNodeSpawner` keeps only the first 64 stderr
-     * chunks, so it **does** drop bytes and must set this.
-     */
-    readonly stderrTruncated?: boolean;
-    /**
-     * Whether the spawner's **own deadline** ended the process.
-     *
-     * Optional because a spawner that has no deadline cannot report it; absent means "this spawner cannot
-     * say", and the transport then reports `false` rather than blaming a timeout it never observed.
-     * `createNodeSpawner` kills the child on `timeoutMs` and **does** know, so it sets this.
-     */
-    readonly timedOut?: boolean;
-}
-/** Spawn options honoured by the injected spawner. */
-export interface SpawnOptions {
-    readonly timeoutMs?: number;
-    readonly signal?: AbortSignal;
-    readonly stdin?: string;
-    readonly maxBytes?: number;
-    /**
-     * Environment entries merged over the parent's environment for this child only.
-     *
-     * Exists for the `SSH_ASKPASS` wiring (`askpass.ts`): a password must reach the `ssh` child without being
-     * written to a file or interpolated into a command line. Absent means "inherit unchanged", which is what
-     * every other caller wants.
-     */
-    readonly env?: Record<string, string>;
-}
-/** Injected process spawner (real: `node:child_process`; tests: a scripted fake). */
-export type SpawnFn = (argv: readonly string[], options: SpawnOptions) => Promise<SpawnResult>;
-/** How connection reuse is behaving for one transport. */
-export type MultiplexingMode = 'unknown' | 'master' | 'unsupported' | 'off';
-/**
- * Remembers hosts whose `ssh` client cannot multiplex.
- *
- * The measurement that motivates this: the OpenSSH client shipped with Windows fails
- * ControlMaster with `getsockname failed: Not a socket`, so retrying the master on every connect
- * would cost a failed process per command sequence. See `doc/03-decisions/0006-…`.
- */
-/** Create an in-memory multiplexing cache (one per process by default). */
-export declare function createMultiplexingCache(): MultiplexingCache;
-/** Process-wide cache shared by every alias transport. */
-export declare const sharedMultiplexingCache: MultiplexingCache;
-/**
- * Whether a failed `ssh` run failed *because multiplexing is unavailable*, as opposed to a real
- * connection problem.
- *
- * Deliberately narrow: a vanished control socket also mentions "control socket", but that is a
- * connection loss (retryable), not "this client cannot multiplex" (permanent for this client).
- *
- * @param stderr - the failed client's stderr.
- * @returns whether the failure indicates missing multiplexing support.
- */
-export declare function isMultiplexingFailure(stderr: string): boolean;
-/** Construction options for the alias transport. */
-export interface AliasTransportOptions {
-    /** Connection id (also the pool key). */
-    readonly connectionId: string;
-    /** OpenSSH alias that carries user/port/identity/jump configuration. */
-    readonly alias: string;
-    /** Directory holding this plugin's ControlMaster sockets. */
-    readonly controlDir: string;
-    /** `ssh` executable; defaults to `ssh` on PATH. */
-    readonly sshBinary?: string;
-    /**
-     * Identity file to pass as `-i`.
-     *
-     * The alias transport inherits `~/.ssh/config`, but when the connection **itself** names a key
-     * (`auth.kind === 'key'`) that key must win: silently ignoring it means the user's explicit choice only
-     * works if their config happens to agree (found by the agent-path e2e).
-     */
-    readonly identityFile?: string;
-    /** Known-hosts file to pass as `-o UserKnownHostsFile`; omitted means ssh's own default. */
-    readonly knownHostsFile?: string;
-    /**
-     * Remote user to pass as `-l`.
-     *
-     * Same reasoning as {@link identityFile}: when the connection names a user, that user must win. Without
-     * this, `ssh <bare-host>` silently used the **local** username (found by the agent-path e2e: the ladder
-     * failed with `yerier@host: Permission denied` even though the profile said `root`).
-     */
-    readonly user?: string;
-    readonly hostKeyPolicy?: HostKeyPolicy;
-    readonly connectTimeoutMs?: number;
-    readonly commandTimeoutMs?: number;
-    readonly keepAliveSeconds?: number;
-    /** When true (default) authentication never prompts. */
-    readonly batchMode?: boolean;
-    /**
-     * Extra environment for every `ssh` child this transport spawns.
-     *
-     * The askpass wiring lives here (`askpass.ts`): with a password connection the transport must both stop
-     * forbidding prompts ({@link batchMode} false) and hand ssh the helper that answers them. Passing it at
-     * construction means master, command and shutdown invocations all authenticate the same way — the drift
-     * that a per-call override would reintroduce.
-     */
-    readonly env?: Record<string, string>;
-    /** `auto` (default) probes multiplexing and degrades; `off` never opens a master. */
-    readonly multiplexing?: 'auto' | 'off';
-    /** Injected cache so tests stay isolated; defaults to the process-wide cache. */
-    readonly multiplexingCache?: MultiplexingCache;
-    /** Injected spawner; the transport never touches `node:child_process` itself. */
-    readonly spawn: SpawnFn;
-    /** Injectable clock for diagnostics. */
-    readonly now?: () => number;
-}
-interface ParsedReadHeaders {
-    readonly size: number;
-    readonly mtime: number;
-    readonly bodyStart: number;
-}
-/** System-ssh transport with ControlMaster session reuse. */
-export declare class AliasTransport implements Transport {
-    #private;
-    readonly id: string;
-    constructor(options: AliasTransportOptions);
-    get state(): TransportState;
-    get capabilities(): RemoteCapabilities;
-    /** Whether commands share one master connection, and why not when they do not. */
-    get multiplexing(): MultiplexingMode;
-    /** Human-readable reason when {@link multiplexing} is `unsupported`. */
-    multiplexingReason(): string | undefined;
-    /** Path of this connection's ControlMaster socket. */
-    controlPath(): string;
-    /** The argv that establishes (and persists) the multiplexed master connection. */
-    buildMasterArgv(): readonly string[];
-    /**
-     * The argv for one command.
-     *
-     * `-S` is only attached when a master connection actually exists: on a client without
-     * multiplexing it would make every command fail with a socket error.
-     */
-    buildCommandArgv(command: string): readonly string[];
-    /** Establish the connection; concurrent calls share one attempt. */
-    connect(signal?: AbortSignal): Promise<void>;
-    /** Close the master connection when one exists. Idempotent. */
-    dispose(): Promise<void>;
-    /** Run one remote command. */
-    exec(request: ExecRequest, signal?: AbortSignal): Promise<ExecResult>;
-    /** Read a remote file with a version token from the same round trip. */
-    readFile(request: ReadFileRequest, signal?: AbortSignal): Promise<RemoteFileChunk>;
-    /** Write a remote file, optionally guarded by the digest of the current content. */
-    writeFile(request: WriteFileRequest, signal?: AbortSignal): Promise<RemoteWriteOutcome>;
-    /**
-     * Read `[offset, offset+maxBytes)` in one round trip.
-     *
-     * The command comes from `fs-commands.ts`, the same module the agent transport uses, so a shell offset read
-     * cannot drift between the two.
-     */
-    readFileRange(request: ReadFileRangeRequest, signal?: AbortSignal): Promise<RemoteFileChunk>;
-    /** Write at `offset`, leaving the earlier bytes untouched (`dd conv=notrunc`). */
-    writeFileRange(request: WriteFileRangeRequest, signal?: AbortSignal): Promise<RemoteWriteOutcome>;
-    /** Move a path; a cross-device move fails instead of silently copying. */
-    rename(request: RenameRequest, signal?: AbortSignal): Promise<void>;
-    /** Remove a file or (with `recursive`) a directory tree. */
-    remove(request: RemoveRequest, signal?: AbortSignal): Promise<void>;
-    /**
-     * Probe the remote host once and remember the result.
-     *
-     * @param signal - cancellation.
-     * @param maxAgeMs - reuse a previous probe inside this window (default 5 minutes).
-     * @returns the discovered capabilities.
-     */
-    probeCapabilities(signal?: AbortSignal, maxAgeMs?: number): Promise<RemoteCapabilities>;
-}
-/**
- * Parse the header lines emitted by {@link AliasTransport.readFile}.
- *
- * @param stdout - raw stdout of the read script.
- * @returns size, mtime and the base64 body, or `undefined` when the headers are missing.
- */
-export declare function parseReadHeaders(stdout: string): ParsedReadHeaders | undefined;
-//# sourceMappingURL=alias-transport.d.ts.map

package/lib/types/src/host/infra/transport/askpass-fs.d.ts

@@ -1,20 +0,0 @@
-/**
- * The real filesystem behind {@link AskpassIo}.
- *
- * Deliberately tiny and separate, for the same reason `node-spawn.ts` is: the askpass logic is pure and
- * testable, and this is the only module that touches a disk. Nothing here ever writes a secret — the
- * helper it materialises reads the secret from the environment at run time.
- *
- * @module dsh-remote-workspace/infra/transport/askpass-fs
- */
-import type { AskpassIo } from './askpass.ts';
-/**
- * Build the production {@link AskpassIo}.
- *
- * The helper lives in a fresh private directory under the OS temp root, named with the plugin's prefix so a
- * leftover is recognisable. Files are created `0o600`/`0o700` where the platform supports modes.
- *
- * @returns a filesystem adapter for {@link createAskpass}.
- */
-export declare function createAskpassFs(): AskpassIo;
-//# sourceMappingURL=askpass-fs.d.ts.map