dsh-over-ssh 0.1.0 → 0.2.0

package/lib/types/src/client/roots/transfer-progress.d.ts

@@ -1,67 +0,0 @@
-/**
- * The transfer panel's **long-poll driver**: the thing that was a `setInterval` before task-19.
- *
- * ## Why a controller and not four `useEffect`s
- *
- * The behaviour that matters is a small state machine — one request in flight, the next one sent the moment the
- * answer lands, a user action that supersedes a parked request, and a dispose that aborts it. This repository cannot
- * render hooks in tests, so a controller with an injectable clock/timer is the only way those four rules are
- * verifiable (the same reason `roots-panel-state.ts` and `session-panel` exist).
- *
- * ## What is preserved from the polling version, deliberately
- *
- *  - **`clearing` / `clearError`**: `clear()` is a separate action from the list loop; a `cleared` list arriving
- *    while the clear request is in flight must not silently drop the "clearing…" state.
- *  - **A background read never raises `loading`.** `loading` is the *visible* "reading…" line, and only the user's
- *    own action (opening the panel, pressing refresh) may show it — a long-poll that times out every 25 s and
- *    flashed "reading…" would be the same flicker the 1 s timer used to cause (audit 0057).
- *  - **Newest answer wins.** Requests are strictly sequential, but a user refresh *aborts* the parked one; if the
- *    aborted request still resolves (a fetch can), its generation is stale and its rows are dropped instead of
- *    overwriting the answer that came after it.
- *
- * ## What changed
- *
- * The loop sends `waitMs` and re-arms **immediately** on every answer. A timeout is a normal answer, not an error;
- * only a real failure backs off ({@link TRANSFER_RETRY_MS}) so a dead host is not hammered.
- *
- * @module dsh-over-ssh/client/transfer-progress
- */
-import { type TransferPanelIo, type TransferPanelState } from './transfer-panel.ts';
-/** Long-poll budget the panel asks the host for (the route clamps it to 25 s as well). */
-export declare const TRANSFER_LONG_POLL_MS = 25000;
-/** Delay before re-asking after a **failed** read. A timeout is not a failure and never waits. */
-export declare const TRANSFER_RETRY_MS = 1000;
-/** One driver over the transfer list. */
-export interface TransferProgress {
-    /** The current state; a stable reference until something changed. */
-    getState(): TransferPanelState;
-    /** Subscribe to state changes; returns the unsubscriber. */
-    subscribe(listener: () => void): () => void;
-    /** Begin the loop. Idempotent. */
-    start(): void;
-    /** The user's refresh: abort the parked request and ask again **now**, visibly. */
-    refresh(): void;
-    /** The user's clear: only finished rows; keeps `clearing`/`clearError`. */
-    clear(): void;
-    /** Stop the loop and abort the in-flight request. Idempotent. */
-    dispose(): void;
-    /** How many snapshot requests were issued (tests and diagnostics). */
-    requests(): number;
-}
-/** What the driver needs from its caller. */
-export interface TransferProgressOptions {
-    readonly io: TransferPanelIo;
-    /** Override the long-poll budget (tests use a few milliseconds). */
-    readonly waitMs?: number;
-    /** Override the failure backoff (tests pass a no-op sleep). */
-    readonly retryDelayMs?: number;
-    /** Injected timer, so "backs off after a failure" costs nothing in a test. */
-    readonly sleep?: (ms: number) => Promise<void>;
-}
-/**
- * Build the driver.
- *
- * @param options - the io, the budget and the injected timer.
- * @returns the controller the React shell subscribes to.
- */
-export declare function createTransferProgress(options: TransferProgressOptions): TransferProgress;

package/lib/types/src/client/roots-panel-view.d.ts

@@ -1,236 +0,0 @@
-/**
- * The **editable** remote-workspaces section of the settings panel.
- *
- * Three layers, deliberately separated so the interesting parts can be tested without a browser:
- *
- *  1. {@link rootsPanelReducer} — a pure state machine over the panel's drafts, the last host answer and
- *     whether a request is in flight. No DOM, no I/O, no React: `tests/client-roots-view.test.ts` drives it
- *     directly.
- *  2. {@link createRootsPanelController} — the same state plus the two calls from
- *     `./roots-panel.ts` (`load` / `send`). Everything that is *not* pure lives here: validation gate,
- *     double-submit gate, the refresh after a success, and dropping answers that a newer request superseded.
- *  3. {@link RootsPanelSection} — a pure template (`createElement`, never JSX: Node's native type stripping
- *     cannot transform JSX) and {@link RootsPanelContainer}, the thin React shell that subscribes to the
- *     controller.
- *
- * Rules this file is responsible for, and where they are enforced:
- *
- *  - **A `config` root never gets a delete button.** The button is rendered from
- *    {@link RootRowView.removable} and from nothing else; the controller refuses such a key before a POST.
- *  - **Nothing is submitted before validation.** `validateRootDraft` / `validateConnectionDraft` are the only
- *    way a draft becomes a request body, and their `MessageKey` refusal is rendered as text through the
- *    locale dictionaries.
- *  - **No double submit.** `canEdit === false` (no answer yet, or a request in flight) disables every control
- *    and stops every handler.
- *  - **No credentials.** This file can only send the fields its drafts hold; the password field does not
- *    exist, and `validateConnectionDraft` refuses `authKind: 'password'` outright.
- *
- * @module dsh-remote-workspace/client/roots-panel-view
- */
-import { type ReactNode } from 'react';
-import type { SshDevKey } from './locale.ts';
-import { type MessageKey, type RootLocation, type RootsApi, type RootsSnapshot, type RootsView } from './roots-panel.ts';
-/** One shipped dictionary, resolved to plain strings. Passed to the component through the inject face. */
-export type RootsPanelCopy = Record<SshDevKey, string>;
-/** The three forms' contents. Kept flat so a patch is one spread and a test can name a single field. */
-export interface RootsPanelDrafts {
-    /** Local root path (form 1). */
-    readonly localPath: string;
-    /** Remote root path (form 2). */
-    readonly remotePath: string;
-    /** Connection chosen for the remote root (form 2). */
-    readonly remoteConnectionId: string;
-    /** Optional label for the remote root (form 2). */
-    readonly remoteLabel: string;
-    /** New connection: id. */
-    readonly newId: string;
-    /** New connection: host. */
-    readonly newHost: string;
-    /** New connection: user. */
-    readonly newUser: string;
-    /** New connection: authentication mode. `password` is not offered at all. */
-    readonly newAuthKind: 'agent' | 'key';
-    /** New connection: key path, only meaningful for `newAuthKind === 'key'`. */
-    readonly newKeyPath: string;
-    /** New connection: port as typed; parsed by the controller so a bad value can be refused, not coerced. */
-    readonly newPort: string;
-}
-/** A change to the drafts; every field is optional so one handler can serve every input. */
-export type RootsPanelDraftPatch = Partial<RootsPanelDrafts>;
-/** Where an inline form message belongs. */
-export type RootsPanelFormScope = 'roots' | 'connection';
-/** A refusal or a failed submit, shown next to the form it belongs to. */
-export interface RootsPanelFormNotice {
-    readonly scope: RootsPanelFormScope;
-    readonly message: MessageKey;
-}
-/** Everything the section renders from. */
-export interface RootsPanelState {
-    /** True once an initial `load()` has been asked for, so a remount does not re-fetch. */
-    readonly started: boolean;
-    /** True while a request is in flight; the edit gate is `buildRootsView`'s `canEdit`. */
-    readonly pending: boolean;
-    /** True once a `load()` answered (ok or not). */
-    readonly loaded: boolean;
-    /** The last host answer, if any. */
-    readonly snapshot?: RootsSnapshot;
-    /** The last transport-level failure, if any. */
-    readonly error?: string;
-    /** The forms' contents. */
-    readonly drafts: RootsPanelDrafts;
-    /** The last validation refusal or submit failure, with the form it belongs to. */
-    readonly formNotice?: RootsPanelFormNotice;
-    /** Bumped by every success; a container can watch it to know "the host changed, reload". */
-    readonly reloadToken: number;
-}
-/** What the reducer accepts. */
-export type RootsPanelAction = 
-/** A request is being sent; also marks the panel as started. */
-{
-    readonly type: 'load';
-} | {
-    readonly type: 'loaded';
-    readonly snapshot: RootsSnapshot;
-}
-/**
- * A request failed. With a `scope` it is a submit failure and is shown next to that form; without one it
- * is the initial load failing, which the view's own `notice` already reports — showing both would say the
- * same thing twice.
- */
- | {
-    readonly type: 'failed';
-    readonly error: string;
-    readonly scope?: RootsPanelFormScope;
-}
-/** One form field changed: clears the inline message, because the user is fixing it. */
- | {
-    readonly type: 'draft-changed';
-    readonly patch: RootsPanelDraftPatch;
-}
-/** A submit is in flight. */
- | {
-    readonly type: 'submitted';
-}
-/** A draft was refused before any request; nothing was sent. */
- | {
-    readonly type: 'refused';
-    readonly scope: RootsPanelFormScope;
-    readonly message: MessageKey;
-}
-/** A request succeeded. `resetDrafts` clears the forms (an add did); a removal keeps them. */
- | {
-    readonly type: 'succeeded';
-    readonly resetDrafts?: boolean;
-}
-/** A removal is in flight; the reducer itself refuses a row that is not removable. */
- | {
-    readonly type: 'remove';
-    readonly key: string;
-};
-/** The starting state: nothing loaded, no drafts, no queue. */
-export declare function emptyRootsPanelDrafts(): RootsPanelDrafts;
-/** @returns the state a freshly created controller holds. */
-export declare function initialRootsPanelState(): RootsPanelState;
-/**
- * The panel's state machine. Pure: same state + same action ⇒ same result, and an action that changes
- * nothing returns the **same object**, so a subscriber is never woken for a no-op.
- *
- * @param state - the current state.
- * @param action - what happened.
- * @returns the next state.
- */
-export declare function rootsPanelReducer(state: RootsPanelState, action: RootsPanelAction): RootsPanelState;
-/**
- * The view model for a state.
- *
- * @param state - the panel state.
- * @returns exactly what `buildRootsView` says: rows with `removable`, connections, notice and the edit gate.
- */
-export declare function selectRootsView(state: RootsPanelState): RootsView;
-/** True when the panel may accept input right now: an answer arrived and no request is in flight. */
-export declare function canEdit(state: RootsPanelState): boolean;
-/**
- * Turn one `MessageKey` into text, with its parameters substituted.
- *
- * The key union is closed at compile time, but a `MessageKey` is a plain string by contract (the pure module
- * cannot import the dictionary), so an unknown key is **shown as the key** rather than as an empty string: a
- * missing translation must be visible, never silent.
- *
- * @param copy - the dictionary of the active locale.
- * @param message - the key plus optional `{name}` parameters.
- * @returns the rendered text, or `''` when there is no message.
- */
-export declare function resolveMessage(copy: RootsPanelCopy, message: MessageKey | undefined): string;
-/** The calls the section makes. `roots-panel.ts` owns how they are implemented. */
-export interface RootsPanelController {
-    /** The current state; a stable reference until something changes (safe for `useSyncExternalStore`). */
-    readonly getState: () => RootsPanelState;
-    /** Watch for changes; returns the disposer. */
-    readonly subscribe: (listener: () => void) => () => void;
-    /** Ask for the first answer once; a remount does not re-fetch. */
-    readonly start: () => void;
-    /** Reload unconditionally (used after a successful change). */
-    readonly reload: () => Promise<void>;
-    /** Change one form field. */
-    readonly changeDraft: (patch: RootsPanelDraftPatch) => void;
-    /** Validate and add a root of the given location. */
-    readonly submitRoot: (location: RootLocation) => Promise<void>;
-    /** Validate and add a connection. */
-    readonly submitConnection: () => Promise<void>;
-    /** Remove one row, if the view allows it. */
-    readonly remove: (key: string) => Promise<void>;
-    /** Stop accepting results and drop listeners. */
-    readonly dispose: () => void;
-}
-/** What a controller needs: the two calls. */
-export interface RootsPanelControllerOptions {
-    readonly api: RootsApi;
-}
-/**
- * Build the stateful half of the panel.
- *
- * The refresh-after-success is the reason this exists at all: `POST` answers with the *persisted* state,
- * whose `roots` are the user's roots — the same field name `GET` uses for the *config* roots. Rendering that
- * answer directly would show a config root as a user root (or the reverse), so a success always ends with a
- * fresh `GET` and the POST body is used only as a signal.
- *
- * @param options - the injected API.
- * @returns the controller the container subscribes to.
- */
-export declare function createRootsPanelController(options: RootsPanelControllerOptions): RootsPanelController;
-/** What the section's controls call. All of them are no-ops when the gate is closed. */
-export interface RootsPanelSectionActions {
-    readonly onDraftChange: (patch: RootsPanelDraftPatch) => void;
-    readonly onSubmitRoot: (location: RootLocation) => void;
-    readonly onSubmitConnection: () => void;
-    readonly onRemove: (key: string) => void;
-}
-/** Props of the pure template: state in, callbacks out, no hooks and no store access. */
-export interface RootsPanelSectionProps {
-    readonly copy: RootsPanelCopy;
-    readonly state: RootsPanelState;
-    readonly actions: RootsPanelSectionActions;
-}
-/**
- * Render the editable section. Pure: calling it twice with the same props yields the same tree.
- *
- * @param props - copy, state and callbacks.
- * @returns the section element.
- */
-export declare function RootsPanelSection({ copy, state, actions }: RootsPanelSectionProps): ReactNode;
-/** Props of the React shell: the controller owns the state, the shell only subscribes. */
-export interface RootsPanelContainerProps {
-    readonly copy: RootsPanelCopy;
-    readonly controller: RootsPanelController;
-}
-/**
- * Subscribe to a controller and render {@link RootsPanelSection}.
- *
- * `useSyncExternalStore` is the whole reason this is a component and not a function call: the slot's inject
- * face is a synchronous snapshot, so the section has to be re-rendered by the store it reads.
- *
- * @param props - the dictionary and the controller.
- * @returns the section element.
- */
-export declare function RootsPanelContainer({ copy, controller }: RootsPanelContainerProps): ReactNode;
-//# sourceMappingURL=roots-panel-view.d.ts.map

package/lib/types/src/client/roots-panel.d.ts

@@ -1,347 +0,0 @@
-/**
- * The roots panel's whole decision surface: wire parsing, the HTTP calls to the host route, input validation
- * and the view model. **No React, no DOM, no `@deepseek-ai/*`** — the component renders what this module
- * returns and nothing else, which is what makes the panel testable without a browser (红线 2).
- *
- * Two rules this module owns:
- *
- *  1. **No credentials, ever.** {@link parseRootsSnapshot} copies field by field and drops anything else, so a
- *     host answer that leaked `keyPath` / `password` still cannot reach the DOM. The host route filters its
- *     side; this is the client's half of the same rule.
- *  2. **Password authentication is not editable here.** A password must never round-trip through a browser
- *     form and a same-origin POST, so {@link validateConnectionDraft} refuses it outright rather than
- *     growing a field that leaks secrets into web storage.
- *
- * @module dsh-remote-workspace/client/roots-panel
- */
-/**
- * Where the host route lives, as the browser must request it.
- *
- * **Relative on purpose, and this is the platform's own convention.** The GUI is served from two different
- * origins depending on the carrier, and only a relative path is correct in both:
- *
- *  - `dsh web` (browser): the page origin *is* the host, so `/api/…` reaches
- *    `ctx.webServer` directly;
- *  - the Desktop shell: the page is `dsh-app://app/` and `/api/…` resolves to
- *    `dsh-app://app/api/…`, which Electron's `protocol.handle('dsh-app')` forwards to the owned host with
- *    the browser-session cookie the shell keeps out of the page
- *    (`resources/app.asar/lib/main.js`, `forwardWebRequest`: non-asset paths are proxied with
- *    `headers.set('cookie', cookie)`; `serveWebDocument` never sees `/api/…`).
- *
- * The absolute host origin (`globalThis.__DSH_TRANSPORT__.streamBaseUrl`) is deliberately **not** used here:
- * the shell strips `set-cookie` from proxied responses and the session cookie is host-only + `HttpOnly`, so
- * a direct fetch to the host origin cannot authenticate — it would turn a working request into a 401. The
- * platform uses that origin for the WebSocket only (`dsh-api-gateway`, `REMOTE_STREAM_MUX_PATH`), and its
- * own HTTP callers resolve against `document.baseURI` (`dsh-client-file-upload`, `new URL(request.path,
- * document.baseURI)`).
- */
-export declare const ROOTS_API_PATH = "/api/remote-workspace/roots";
-/** A root either lives on this machine or behind a connection. */
-export type RootLocation = 'local' | 'remote';
-/** One root as the panel shows it. */
-export interface RootRow {
-    /** Stable identity: `<location>:<connectionId or '-'>:<path>`. */
-    readonly key: string;
-    readonly location: RootLocation;
-    readonly path: string;
-    readonly connectionId?: string;
-    readonly label?: string;
-    readonly writable: boolean;
-    /** `config` rows come from the profile patch; `user` rows were added in this panel. */
-    readonly source: 'config' | 'user';
-    /** Whether this root also appears in the panel's own file — only those may be deleted. */
-    readonly inUserFile: boolean;
-    /**
-     * The workspaces that list this root; absent means plugin-wide.
-     *
-     * The composer's card filters on it (one workspace must not inherit another's directories); the settings
-     * panel ignores it, because that panel manages the plugin-wide list.
-     */
-    readonly workspaces?: readonly string[];
-}
-/** A connection, narrowed to what the panel may display. **No credential fields exist on this type.** */
-export interface ConnectionSummary {
-    readonly id: string;
-    readonly host: string;
-    readonly user?: string;
-    readonly port?: number;
-    readonly authKind: 'agent' | 'key' | 'password';
-    /**
-     * The transport the record asks for, when it names one.
-     *
-     * The edit form prefills from this: a form that always showed the default would silently rewrite a
-     * connection the user had deliberately set to zero-install. Absent means "the reader's default" (the
-     * record carries no choice), which is a different fact from "the user chose the default".
-     */
-    readonly transport?: ConnectionTransportChoice;
-}
-/** Everything one GET answers. */
-export interface RootsSnapshot {
-    readonly roots: readonly RootRow[];
-    readonly connections: readonly ConnectionSummary[];
-    readonly warnings: readonly string[];
-}
-/** The outcome of one call: the panel never throws on a host failure, it shows it. */
-export type ApiResult<T> = {
-    readonly ok: true;
-    readonly value: T;
-} | {
-    readonly ok: false;
-    readonly error: string;
-};
-/** What this module needs from `fetch`; injected so tests run without a server (红线 3). */
-export type FetchLike = (input: string, init?: {
-    readonly method?: string;
-    readonly headers?: Record<string, string>;
-    readonly body?: string;
-    readonly signal?: AbortSignal;
-}) => Promise<{
-    readonly ok: boolean;
-    readonly status: number;
-    json: () => Promise<unknown>;
-}>;
-/** A message is a key plus its parameters; the component resolves it against the locale dictionaries. */
-export interface MessageKey {
-    readonly key: string;
-    readonly params?: Readonly<Record<string, string | number>>;
-}
-/** A validated draft, or the reason it was refused. */
-export type Validation<T> = {
-    readonly ok: true;
-    readonly value: T;
-} | {
-    readonly ok: false;
-    readonly message: MessageKey;
-};
-/** The payload the panel sends to add a root. */
-export interface RootDraft {
-    readonly location: RootLocation;
-    readonly path: string;
-    readonly connectionId?: string;
-    readonly label?: string;
-    readonly writable?: boolean;
-}
-/**
- * Which transport a connection should use, as the form offers it.
- *
- * Spelled out here rather than imported from the host's `TransportKind` (`host/domain/connection.ts`): this
- * module is the pure client half and imports nothing from the host (红线 2). The two unions must stay equal,
- * and the host re-validates whatever arrives (`normalizeConnectionEntry`), so a drift cannot reach the file.
- *
- * **Not to be confused with `authKind: 'agent'`**, which names the *local* ssh-agent as a credential source.
- * `transport: 'agent'` names the *remote* Tier 2 Go program this plugin uploads (ADR-0005/0007).
- */
-export type ConnectionTransportChoice = 'alias' | 'ssh2' | 'agent';
-/** Every transport the form may offer, in the order the selector lists them (the default first). */
-export declare const CONNECTION_TRANSPORTS: readonly ConnectionTransportChoice[];
-/** The transport a draft uses when it names none: the Tier 2 agent, matching the host's own default. */
-export declare const DEFAULT_CONNECTION_TRANSPORT: ConnectionTransportChoice;
-/**
- * Narrow an untrusted value to a transport this build knows.
- *
- * Anything unrecognised degrades to the default rather than reaching the wire: the field is a closed union, and
- * a value the host would reject as `CONNECTION_INVALID` is worse than the documented default.
- *
- * @param value - the raw field.
- * @returns the transport, or {@link DEFAULT_CONNECTION_TRANSPORT}.
- */
-export declare function toConnectionTransport(value: unknown): ConnectionTransportChoice;
-/**
- * The payload the panel sends to add a connection.
- *
- * `password` is the **only** secret this client ever holds, and only long enough to post it: the host writes
- * it into `ctx.credentials` and answers with a projection that never contains it (FR-2.1.2).
- */
-export interface ConnectionDraft {
-    readonly id: string;
-    readonly host: string;
-    readonly user: string;
-    readonly authKind: 'agent' | 'key' | 'password';
-    /**
-     * The transport to use. Optional on the way in (an omitted value means {@link DEFAULT_CONNECTION_TRANSPORT})
-     * and **always present on the way out**: the host persists the user's explicit choice, so "the default" is a
-     * decision the record carries rather than one every reader has to re-derive.
-     */
-    readonly transport?: ConnectionTransportChoice;
-    readonly keyPath?: string;
-    readonly password?: string;
-    readonly port?: number;
-}
-/** The identity the host also uses, so removals address the same row the list shows. */
-export declare function rootKey(location: RootLocation, path: string, connectionId?: string): string;
-/**
- * Narrow one GET answer to the panel's model, field by field.
- *
- * Unknown fields are dropped rather than copied: an answer carrying `keyPath` reaches the DOM only as a
- * missing field, never as a value. A malformed answer becomes an empty snapshot with a warning instead of a
- * throw — a broken channel must degrade the panel, not break the whole settings page.
- *
- * @param value - the parsed JSON the route answered with.
- * @returns a snapshot that is safe to render.
- */
-export declare function parseRootsSnapshot(value: unknown): RootsSnapshot;
-/** True when a string is an absolute path this machine can open (drive letter, POSIX root, or UNC). */
-export declare function isAbsoluteLocalPath(path: string): boolean;
-/**
- * Refuse a draft before it becomes a request.
- *
- * @param draft - what the form holds.
- * @param existing - roots already shown, to reject a duplicate.
- * @returns the wire payload, or the message key to show next to the field.
- */
-export declare function validateRootDraft(draft: RootDraft, existing?: readonly RootRow[]): Validation<RootDraft>;
-/**
- * Refuse a connection draft before it becomes a request.
- *
- * The id rule is the **host's** rule (a user-chosen name, Chinese included), so the panel refuses exactly
- * what `path-grammar.ts` would refuse instead of sending a request that comes back 400.
- *
- * Password auth is supported: the draft carries the password once, the host stores it in `ctx.credentials`,
- * and nothing in any answer ever carries it back (FR-2.1.2).
- *
- * The transport is **always** in the returned value, even when the draft omits it: the form has a selector,
- * and the host must receive the user's choice explicitly rather than re-deriving the default per reader.
- *
- * @param draft - what the form holds.
- * @param existing - connections already shown, to reject a duplicate id.
- * @returns the wire payload, or the message key to show next to the field.
- */
-export declare function validateConnectionDraft(draft: ConnectionDraft, existing?: readonly ConnectionSummary[]): Validation<ConnectionDraft>;
-/**
- * Refuse an **edit** draft before it becomes a request.
- *
- * The same rules as {@link validateConnectionDraft} for every field, with the three differences an edit
- * needs, and each one exists for a reason:
- *
- *  1. **A rename is allowed but must not collide with a *different* connection.** Uniqueness is checked
- *     against the rows except the one being edited  -  `validateConnectionDraft` cannot express that, and using
- *     it here would refuse every save that kept the id.
- *  2. **An empty password means "do not touch the stored secret", not "refuse".** No answer ever carries a
- *     secret back, so the form's password box is always empty on render; requiring it would make it
- *     impossible to change a host without retyping the password, and treating empty as "clear" would delete
- *     the password on every unrelated edit. The field is therefore **omitted** from the payload unless the
- *     user typed one, which is exactly how the host reads it.
- *  3. **`keyPath` follows the same rule as the password: blank means "keep the stored one".** The panel
- *     cannot prefill it, because the host's answer deliberately never carries a `keyPath` (it names a real
- *     file). Refusing a blank one would therefore make it impossible to edit a key connection's host without
- *     retyping its private-key path, and *filling* it with a guess would silently repoint the connection.
- *     So it is omitted unless the user typed one  -  the host's merge keeps what is stored.
- *
- * @param draft - what the form holds.
- * @param originalId - the id of the connection being edited (the lookup key the host needs).
- * @param existing - connections already shown, to reject a colliding rename.
- * @returns the wire payload, or the message key to show next to the field.
- */
-export declare function validateConnectionEdit(draft: ConnectionDraft, originalId: string, existing?: readonly ConnectionSummary[]): Validation<Record<string, unknown>>;
-/** One row as the component renders it. */
-export interface RootRowView {
-    readonly key: string;
-    readonly location: RootLocation;
-    readonly title: string;
-    readonly subtitle: string;
-    readonly badgeKey: string;
-    readonly removable: boolean;
-}
-/** The panel's complete render input. */
-export interface RootsView {
-    readonly rows: readonly RootRowView[];
-    readonly connections: readonly ConnectionSummary[];
-    /** Set when the host did not answer, so the panel can say why instead of looking empty. */
-    readonly notice?: MessageKey;
-    /** False while a request is in flight, so the form cannot double-submit. */
-    readonly canEdit: boolean;
-}
-/**
- * Turn a snapshot (or the failure to get one) into render input.
- *
- * @param input - the last answer, or the last error, plus whether a request is running.
- * @returns rows, connections, notice and the edit gate.
- */
-export declare function buildRootsView(input: {
-    readonly snapshot?: RootsSnapshot;
-    readonly error?: string;
-    readonly pending?: boolean;
-}): RootsView;
-/** The calls the panel makes. */
-export interface RootsApi {
-    load(signal?: AbortSignal): Promise<ApiResult<RootsSnapshot>>;
-    send(body: Record<string, unknown>): Promise<ApiResult<RootsSnapshot>>;
-    /**
-     * A POST whose answer is **not** a snapshot.
-     *
-     * The import actions answer a candidate list and an import report, neither of which is a roots snapshot. It
-     * is a separate method rather than a looser return type on {@link RootsApi.send} so that every existing call
-     * keeps the snapshot it already depends on: widening `send` would make `state` optional for all of them.
-     */
-    sendRaw(body: Record<string, unknown>): Promise<ApiResult<Record<string, unknown>>>;
-}
-/** One importable `~/.ssh/config` alias, as the import dialog renders it. */
-export interface SshConfigCandidate {
-    /** The literal alias; also the `ssh` target. Shown verbatim so the user recognises their own config. */
-    readonly alias: string;
-    /** Resolved host name. */
-    readonly host: string;
-    readonly user?: string;
-    readonly port?: number;
-    /** Whether the block named an identity file. The path itself never reaches the client. */
-    readonly hasIdentityFile: boolean;
-    readonly hasProxyJump: boolean;
-    /** The id the import would create. Editable in spirit: the user sees it before committing. */
-    readonly suggestedId: string;
-}
-/** One alias the host refused, with the machine-readable reason. */
-export interface SshConfigSkipped {
-    readonly pattern: string;
-    readonly reason: string;
-    readonly line: number;
-}
-/** What `list-ssh-config` answers. */
-export interface SshConfigListing {
-    readonly candidates: readonly SshConfigCandidate[];
-    readonly skipped: readonly SshConfigSkipped[];
-}
-/**
- * Narrow the host's `list-ssh-config` answer.
- *
- * Defensive in the same way {@link parseRootsSnapshot} is: the client never trusts the wire's shape, and a row
- * without a usable alias or id is **dropped** rather than rendered as a checkbox that would import nothing.
- *
- * @param value - the parsed JSON body.
- * @returns the listing, with unusable rows removed.
- */
-export declare function parseSshConfigListing(value: unknown): SshConfigListing;
-/**
- * The human-readable reason one alias was refused.
- *
- * The mapping lives here rather than in the view so the reasons are testable without rendering, and an unknown
- * reason from a newer host still produces a sentence instead of an empty cell.
- *
- * @param reason - the machine-readable reason.
- * @returns a message key.
- */
-export declare function sshConfigSkipKey(reason: string): string;
-/** A candidate's one-line summary: `user@host:port`, with the flags that matter for the import. */
-export declare function sshConfigCandidateSummary(candidate: SshConfigCandidate): string;
-/**
- * The reason a failed response reports, when the host did not name one.
- *
- * The path is part of the text on purpose: `http-404` alone cannot distinguish "this route is not
- * registered" (the host half never claimed it — that was a real defect) from "the request never reached the
- * host" (the shell's proxy or the composition is at fault). Both are shown verbatim in the panel's notice.
- *
- * @param status - the HTTP status.
- * @param path - the exact URL that was requested.
- * @returns the machine-readable reason.
- */
-export declare function transportFailureReason(status: number, path: string): string;
-/**
- * Bind the route to the panel's two operations.
- *
- * @param fetchImpl - `window.fetch` in the app, a stub in tests.
- * @param path - override for tests; defaults to {@link ROOTS_API_PATH}.
- * @returns the calls the component uses.
- */
-export declare function createRootsApi(fetchImpl: FetchLike, path?: string): RootsApi;
-/** The field names the panel must never send, asserted by tests rather than trusted to reviewers. */
-export declare function isForbiddenField(name: string): boolean;
-//# sourceMappingURL=roots-panel.d.ts.map