@tiphareth/dsh-hardssh 0.1.2

package/lib/types/base/ledger.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Generic workspace ledger — the provider-agnostic persistence and routing
+ * index for workspace records. It generalizes the SSH-bound ledger's proven
+ * mechanics (atomic write, sync anchor index, subscription) without any
+ * SSH-typed fields: a record is a `WorkspaceRecord` whose `provider` ref
+ * names the owning provider, and anchors are plain local directories.
+ *
+ * Concrete providers keep their own specialized stores (e.g. the SSH host
+ * store) and reference them through `provider.connectionRef`; the ledger
+ * itself never touches provider configs.
+ *
+ * @module @tiphareth/dsh-hardssh/base/ledger
+ */
+import type { WorkspaceRecord } from './model.ts';
+/** One committed ledger snapshot. */
+export interface LedgerSnapshot {
+    revision: number;
+    records: readonly WorkspaceRecord[];
+}
+/** One committed mutation delivered to subscribers. */
+export type LedgerChange = {
+    type: 'created';
+    revision: number;
+    record: WorkspaceRecord;
+} | {
+    type: 'renamed';
+    revision: number;
+    before: WorkspaceRecord;
+    record: WorkspaceRecord;
+} | {
+    type: 'removed';
+    revision: number;
+    record: WorkspaceRecord;
+};
+export type LedgerListener = (change: LedgerChange) => void;
+/** Normalize an anchor for comparison (Windows case-insensitive; POSIX not). */
+export declare function normalizeAnchorPath(path: string): string;
+/** True when `candidate` equals `anchor` or is one of its descendants (lexical). */
+export declare function isPathUnderAnchor(anchor: string, candidate: string): boolean;
+/**
+ * The generic ledger. Persisted as a JSON file; mutations serialized through
+ * a per-instance queue with atomic rename; a synchronous anchor index is
+ * maintained so the switch layer can resolve a cwd without awaiting I/O.
+ */
+export declare class WorkspaceLedger {
+    private readonly fileOverride?;
+    private readonly anchorOverride?;
+    private records;
+    private loadPromise;
+    private anchorIndex;
+    private mutationTail;
+    private currentRevision;
+    private readonly listeners;
+    constructor(fileOverride?: string | undefined, anchorOverride?: string | undefined);
+    private file;
+    private anchors;
+    private ensureLoaded;
+    private readRecords;
+    private reindex;
+    private save;
+    private enqueueMutation;
+    private commit;
+    private emit;
+    load(): Promise<WorkspaceRecord[]>;
+    list(): Promise<WorkspaceRecord[]>;
+    snapshot(): Promise<LedgerSnapshot>;
+    snapshotSync(): LedgerSnapshot;
+    revision(): number;
+    subscribe(listener: LedgerListener): () => void;
+    get(id: string): Promise<WorkspaceRecord | undefined>;
+    findByAnchor(path: string): Promise<WorkspaceRecord | undefined>;
+    findByAnchorSync(path: string): WorkspaceRecord | undefined;
+    /** Create a record: materialize the anchor (managed mode), persist, commit. */
+    create(input: Omit<WorkspaceRecord, 'id' | 'createdAt' | 'updatedAt'> & {
+        id?: string;
+    }): Promise<WorkspaceRecord>;
+    rename(id: string, title: string): Promise<WorkspaceRecord | undefined>;
+    /** Remove a record. The anchor directory is left in place (caller decides). */
+    remove(id: string): Promise<boolean>;
+    anchorsRoot(): string;
+}
+//# sourceMappingURL=ledger.d.ts.map

package/lib/types/base/model.d.ts

@@ -0,0 +1,108 @@
+/**
+ * The generic workspace model — the platform-neutral core of the workspace
+ * base. A `WorkspaceRecord` describes ONE bound workspace: a local anchor
+ * directory (what sessions see as their cwd) mapped to a location on some
+ * provider (local disk, SSH host, container, object store, …). The record
+ * never holds secrets — only references into a provider-managed credential
+ * store.
+ *
+ * Everything in this module is provider-agnostic: it imports no SSH, no
+ * Cordis, no React, and no `@deepseek-ai/*` runtime package.
+ *
+ * @module @tiphareth/dsh-hardssh/base/model
+ */
+/** Opaque workspace id (uuid or provider-assigned). */
+export type WorkspaceId = string;
+/** A connection reference into a provider's own credential/config store. */
+export interface ConnectionRef {
+    /** Provider-local stable id (e.g. the SSH host record id). */
+    id: string;
+    /** Optional display alias kept for humans; never used as identity. */
+    alias?: string;
+}
+/** Identifies which provider owns a workspace and how to reach its config. */
+export interface WorkspaceProviderRef {
+    /** Provider type id: 'local' | 'ssh' | 'docker' | 'wsl' | … (registry key). */
+    id: string;
+    /** Optional multiple-config instance within one provider. */
+    instanceId?: string;
+    /** Reference into the provider's credential/config store (no secrets). */
+    connectionRef?: ConnectionRef;
+}
+/** Where a workspace lives, interpreted by its provider. */
+export interface WorkspaceLocation {
+    /** Path kind: 'native' | 'posix' | 'uri' | 'object-prefix' | … */
+    kind: string;
+    /** Provider-specific root (e.g. /srv/repo, C:\repo, bucket/prefix). */
+    root: string;
+    /** Provider-defined options; must be JSON-serializable. No secrets. */
+    options?: Record<string, unknown>;
+}
+/** How the workspace is anchored on the local host (the session-visible dir). */
+export interface WorkspaceAnchor {
+    /** Absolute local anchor directory path. */
+    path: string;
+    /** 'managed' = base owns a dir under its anchor root; 'existing' = user dir. */
+    mode: 'managed' | 'existing';
+}
+/** One persisted workspace record. */
+export interface WorkspaceRecord {
+    /** Schema identifier so future migrations can be detected. */
+    schemaVersion: number;
+    id: WorkspaceId;
+    /** Human-readable sidebar title. */
+    title: string;
+    provider: WorkspaceProviderRef;
+    location: WorkspaceLocation;
+    anchor?: WorkspaceAnchor;
+    createdAt: string;
+    updatedAt: string;
+    /** Free-form labels (env, team, …). */
+    labels?: Record<string, string>;
+    /** Provider/feature extension bag. Never holds secrets. */
+    extensions?: Record<string, unknown>;
+}
+/** One provider capability key (extensible via module augmentation). */
+export interface WorkspaceCapabilityMap {
+    'workspace.fs': import('./capability.ts').WorkspaceFileSystem;
+    'workspace.process': import('./capability.ts').WorkspaceProcessRuntime;
+    'workspace.terminal': import('./capability.ts').WorkspaceTerminalService;
+    'workspace.search': import('./capability.ts').WorkspaceSearchService;
+}
+/** A resolved, open connection to one workspace's provider. */
+export interface WorkspaceConnection {
+    readonly workspaceId: WorkspaceId;
+    readonly providerId: string;
+    /** Fetch a capability; undefined when this provider does not offer it. */
+    get<K extends keyof WorkspaceCapabilityMap>(capability: K): WorkspaceCapabilityMap[K] | undefined;
+    /** Connection lifecycle status. */
+    status(): 'connecting' | 'ready' | 'degraded' | 'closed';
+    /** Release every resource (connections, pool leases, PTYs). Idempotent. */
+    close(): Promise<void>;
+}
+/** Context handed to a provider when opening a workspace. */
+export interface WorkspaceOpenContext {
+    signal?: AbortSignal;
+    logger?: Pick<Console, 'warn' | 'error' | 'info' | 'debug'>;
+}
+/** The interface every workspace provider implements. */
+export interface WorkspaceProvider {
+    /** Static identity (registry key, capabilities, display name). */
+    readonly manifest: WorkspaceProviderManifest;
+    /** Validate a record before open (e.g. root shape, ref resolvable). */
+    validate(record: WorkspaceRecord): void | Promise<void>;
+    /** Open a connection for one record. */
+    open(record: WorkspaceRecord, context?: WorkspaceOpenContext): Promise<WorkspaceConnection>;
+}
+/** Static provider identity, checked before any plugin code runs. */
+export interface WorkspaceProviderManifest {
+    /** Provider type id (registry key; unique across the deployment). */
+    id: string;
+    version: string;
+    /** Compatibility gate: big-version mismatches refuse to load. */
+    apiVersion: number;
+    displayName: string;
+    /** Capabilities this provider implements. */
+    capabilities: Array<keyof WorkspaceCapabilityMap | string>;
+}
+//# sourceMappingURL=model.d.ts.map

package/lib/types/base/namespace.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Workspace namespace codec — how a routable target key is encoded.
+ *
+ * New format is a URI style that carries ONLY the workspace id and the
+ * provider-agnostic path:
+ *
+ *   wfs://<encoded-workspace-id>/<path>
+ *
+ * - The workspace id survives provider migration (ssh → container → …), so
+ *   a key never needs re-routing when a workspace changes providers.
+ * - It cannot collide with Windows drive paths (`C:\…`) or bare POSIX paths.
+ * - It contains no provider name, so the switch layer never branches on
+ *   "which provider" — only on "which workspace".
+ *
+ * The legacy SSH format (`ssh:<recordId>:`) is still accepted (decode only)
+ * so existing persisted targets keep resolving during the migration window.
+ *
+ * @module @tiphareth/dsh-hardssh/base/namespace
+ */
+/** The URI scheme used for explicit workspace-namespaced target keys. */
+export declare const WFS_SCHEME: "wfs:";
+/** ASCII-encode a workspace id for safe embedding in a URL-ish key. */
+export declare function encodeWorkspaceId(id: string): string;
+/** Decode a workspace id back from its encoded form. */
+export declare function decodeWorkspaceId(encoded: string): string;
+/** One parsed route: which workspace, and the raw path inside it. */
+export interface WorkspaceRoute {
+    workspaceId: string;
+    /** The path portion as it appeared (provider-relative). */
+    path: string;
+}
+/** Namespace codec contract (make the switch layer provider-agnostic). */
+export interface WorkspaceNamespaceCodec {
+    encode(route: WorkspaceRoute): string;
+    decode(input: string): WorkspaceRoute | undefined;
+    /** True when `input` is an explicit workspace namespace (not a plain path). */
+    isExplicitNamespace(input: string): boolean;
+}
+/**
+ * Encode a route as `wfs://<id>/<path>`. A leading slash on the path is
+ * preserved after the namespace marker.
+ */
+export declare function encodeRoute(route: WorkspaceRoute): string;
+/** Decode a `wfs://<id>/<path>` key (strict). */
+export declare function decodeWfsKey(input: string): WorkspaceRoute | undefined;
+/**
+ * Decode a legacy `ssh:<recordId>:<key>` key. Kept during the migration
+ * window so persisted remote targets keep resolving; the record id maps to
+ * the workspace id 1:1 (old record ids ARE the workspace ids).
+ */
+export declare function decodeLegacySshKey(input: string): WorkspaceRoute | undefined;
+/**
+ * The default codec: emits `wfs://…` and accepts both `wfs://…` and legacy
+ * `ssh:<id>:…`.
+ */
+export declare const defaultNamespaceCodec: WorkspaceNamespaceCodec;
+//# sourceMappingURL=namespace.d.ts.map

package/lib/types/base/plugin.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Plugin registration / distribution — the extension contract that lets ANY
+ * third-party plugin (not just SSH) contribute workspace capability.
+ *
+ * Two plugin kinds share one manifest+activate shape:
+ * - **Provider plugins** register `WorkspaceProvider`s (local, ssh, docker,
+ *   wsl, cloud devbox, …) through the plugin context.
+ * - **Feature plugins** attach provider-agnostic features (indexing, audit
+ *   tools, diagnostics, UI) to workspaces that expose the capabilities they
+ *   need — without importing any provider implementation.
+ *
+ * DSH-specific surfaces (agent tools, routes, prompt sections, client
+ * entries) are contributed through the runtime bridge, never through this
+ * core contract, so `base` stays free of Cordis/React.
+ *
+ * @module @tiphareth/dsh-hardssh/base/plugin
+ */
+import type { WorkspaceProvider, WorkspaceRecord } from './model.ts';
+import type { WorkspaceRegistry } from './registry.ts';
+/** A disposable registration handle. */
+export interface Disposable {
+    dispose(): void;
+}
+/** Static plugin identity, readable before any plugin code executes. */
+export interface WorkspacePluginManifest {
+    /** Stable plugin id (dotted, reverse-dns style recommended). */
+    id: string;
+    version: string;
+    /** Compatibility gate; aligned with the base API major. */
+    apiVersion: number;
+    displayName: string;
+    /** What this plugin contributes (for capability gating / UI). */
+    contributes?: {
+        providers?: string[];
+        features?: string[];
+        clientEntries?: string[];
+    };
+}
+/** Context handed to a plugin's `activate`. */
+export interface WorkspacePluginContext {
+    /** Register one provider; returns a disposer. */
+    registerProvider(provider: WorkspaceProvider): Disposable;
+    /** Register one provider-agnostic feature. */
+    registerFeature(feature: WorkspaceFeature): Disposable;
+    /** The shared workspace registry (list / watch workspaces). */
+    workspaces: WorkspaceRegistry;
+    /** Fired when a workspace record changes (for feature lifecycle). */
+    onWorkspaceChange(listener: (workspace: WorkspaceRecord) => void): Disposable;
+}
+/** A provider-agnostic feature attached to compatible workspaces. */
+export interface WorkspaceFeature {
+    id: string;
+    /** True when this feature wants the given workspace (capability gating). */
+    supports(input: {
+        workspace: WorkspaceRecord;
+        capabilities: ReadonlySet<string>;
+    }): boolean;
+    /** Called once per compatible workspace while the feature is active. */
+    activate(context: WorkspaceFeatureContext): void | Promise<void>;
+    deactivate?(): void | Promise<void>;
+}
+/** Feature context: per-workspace connection + lifecycle. */
+export interface WorkspaceFeatureContext {
+    workspace: WorkspaceRecord;
+    /** Open connection; undefined only if the provider failed to open. */
+    connection: import('./model.ts').WorkspaceConnection | undefined;
+    /** Mark the feature unusable for this workspace (degrades gracefully). */
+    unavailable(): void;
+}
+/** The full plugin shape: static manifest + activate. */
+export interface WorkspacePlugin {
+    readonly manifest: WorkspacePluginManifest;
+    activate(context: WorkspacePluginContext): void | Promise<void>;
+    deactivate?(): void | Promise<void>;
+}
+/**
+ * Registry of loaded plugins (provider + feature plugins together). Keeps
+ * the workspace registry and plugin lifecycle in one place.
+ */
+export declare class WorkspacePluginHost {
+    private readonly registries;
+    private readonly plugins;
+    private readonly features;
+    /** Per-plugin disposers collected from activate (provider/feature/workspace listeners). */
+    private readonly pluginDisposers;
+    constructor(registries: {
+        workspaces: WorkspaceRegistry;
+    });
+    /** Load a plugin: validate manifest, run activate. Throws on failure. */
+    load(plugin: WorkspacePlugin): Promise<void>;
+    /** Unload a plugin, disposing every contribution (providers, features, listeners). */
+    unload(id: string): Promise<void>;
+    private registerProvider;
+    /** Active features (for a runtime to wire up per-workspace surfaces). */
+    featuresFor(workspace: WorkspaceRecord, capabilities: ReadonlySet<string>): WorkspaceFeature[];
+}
+/**
+ * Minimal capability set surface used by the DSH runtime to decide which
+ * features apply to a workspace. Computed from the provider manifest.
+ */
+export declare function capabilitiesOf(provider: WorkspaceProvider): ReadonlySet<string>;
+//# sourceMappingURL=plugin.d.ts.map

package/lib/types/base/registry.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Workspace provider registry — the single place providers register and are
+ * looked up by id. The registry is provider-agnostic: SSH, local, and any
+ * future provider all register here, and the switch layer resolves
+ * workspaces through the registry without knowing which provider backs them.
+ *
+ * Registration is idempotent per (id, version, apiVersion): re-registering
+ * the same provider is a no-op / reuse; registering a different or
+ * incompatible implementation with the same id is an error.
+ *
+ * @module @tiphareth/dsh-hardssh/base/registry
+ */
+import type { WorkspaceProvider, WorkspaceProviderManifest } from './model.ts';
+/** Fired when a provider registers (for surface mounts / cache invalidation). */
+export type ProviderListener = (provider: WorkspaceProvider) => void;
+/** Duplicate / incompatible registration error. */
+export declare class ProviderRegistrationError extends Error {
+    constructor(message: string);
+}
+/** In-memory provider registry (process-wide singleton by default). */
+export declare class WorkspaceProviderRegistry {
+    private readonly providers;
+    private readonly listeners;
+    /** Register a provider. Throws on id collision with an incompatible impl. */
+    register(provider: WorkspaceProvider): () => void;
+    /** Look up a provider by id. */
+    get(id: string): WorkspaceProvider | undefined;
+    /** Unregister a provider by id (no-op when absent or different version). */
+    unregister(id: string): void;
+    /** All registered providers. */
+    list(): WorkspaceProvider[];
+    /** Subscribe to registrations. Returns a disposer. */
+    subscribe(listener: ProviderListener): () => void;
+    /** True when a provider id is registered. */
+    has(id: string): boolean;
+    /** Static identity of a registered provider (for manifests / UI). */
+    manifestOf(id: string): WorkspaceProviderManifest | undefined;
+}
+/** The process-wide shared registry. */
+export declare const globalWorkspaceRegistry: WorkspaceProviderRegistry;
+/**
+ * Workspace registry surface used by plugins: list / watch workspace records
+ * and register providers. Implemented by the runtime over the ledger + the
+ * provider registry.
+ */
+export interface WorkspaceRegistry {
+    /** All known workspace records (provider-agnostic). */
+    listWorkspaces(): Promise<import('./model.ts').WorkspaceRecord[]>;
+    /** Subscribe to workspace record changes. Returns a disposer. */
+    subscribe(listener: (workspace: import('./model.ts').WorkspaceRecord) => void): () => void;
+    /** Register a provider (idempotent same-version; throws on conflict). */
+    register(provider: WorkspaceProvider): void;
+    /** Unregister a provider by id (no-op when absent). */
+    unregister?(providerId: string): void;
+    /** Look up a provider by id. */
+    provider(id: string): WorkspaceProvider | undefined;
+    /** All registered providers. */
+    providers(): WorkspaceProvider[];
+}
+//# sourceMappingURL=registry.d.ts.map

package/lib/types/base/router.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Generic workspace routing — the switch-layer contracts. A `WorkspaceRouter`
+ * decides, for a session cwd or a namespaced target key, which workspace
+ * (and thus which provider connection) owns the operation. The switch
+ * facades (`switch-fs.ts` / `switch-subprocess.ts` in the runtime layer)
+ * consume this router and never branch on provider identity.
+ *
+ * @module @tiphareth/dsh-hardssh/base/router
+ */
+import type { WorkspaceConnection } from './model.ts';
+import type { WorkspaceNamespaceCodec, WorkspaceRoute } from './namespace.ts';
+/** One resolved routing decision: the owning workspace connection + raw key. */
+export interface WorkspaceResolution {
+    /** Open connection to the owning workspace (ready or degraded). */
+    connection: WorkspaceConnection;
+    /** The raw (un-namespaced) target key for the connection's backend. */
+    rawKey: string;
+}
+/**
+ * Route resolver contract. Implementations combine the ledger's anchor index
+ * (cwd → workspace) with the namespace codec (explicit key → workspace).
+ */
+export interface WorkspaceRouter {
+    /** Resolve an explicit namespaced key; undefined = unrouteable (fail closed). */
+    fromNamespace(key: string): WorkspaceResolution | undefined;
+    /** Resolve a session cwd to its workspace (undefined = local / unbound). */
+    fromAnchor(cwd: string | undefined): WorkspaceConnection | undefined;
+    /** The namespace codec this router uses (for the switch facade to encode). */
+    codec: WorkspaceNamespaceCodec;
+    /** Map a route back to a resolution (used by the switch to re-encode child keys). */
+    resolveRoute(route: WorkspaceRoute): WorkspaceResolution | undefined;
+}
+/** Convenience base: default codec wiring plus helper for resolution lookup. */
+export declare abstract class BaseWorkspaceRouter implements WorkspaceRouter {
+    abstract readonly codec: WorkspaceNamespaceCodec;
+    abstract fromNamespace(key: string): WorkspaceResolution | undefined;
+    abstract fromAnchor(cwd: string | undefined): WorkspaceConnection | undefined;
+    abstract resolveRoute(route: WorkspaceRoute): WorkspaceResolution | undefined;
+}
+//# sourceMappingURL=router.d.ts.map

package/lib/types/client/api.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Browser-side API clients: the /api/dsh-hardssh route family (SSH workspace
+ * CRUD, remote dir browsing, workspace file ops) plus the two /api/dsh-ssh
+ * endpoints the config dialog needs (host create + test). Plain fetch, same
+ * origin 鈥?the only data path the panel components use.
+ */
+import { HttpApiError } from '../client-http.ts';
+import { type DirListing, type FileRead, type FileWriteResult, type RemoteDirEntry, type SearchView, type SshWorkspaceRecord } from '../protocol.ts';
+/** Error carrying the route's JSON error message and stable code/status. */
+export declare class WorkspaceApiError extends HttpApiError {
+    constructor(message: string, code?: string, status?: number);
+}
+/** The workspace route family client. */
+export declare class WorkspaceApi {
+    /** List the SSH-bound workspaces. */
+    listWorkspaces(): Promise<SshWorkspaceRecord[]>;
+    /** Create one SSH-bound workspace. */
+    createWorkspace(input: {
+        title: string;
+        alias: string;
+        remoteRoot: string;
+    }): Promise<SshWorkspaceRecord>;
+    /** Rename one SSH-bound workspace. */
+    renameWorkspace(id: string, title: string): Promise<SshWorkspaceRecord>;
+    /** Delete one SSH-bound workspace. */
+    deleteWorkspace(id: string): Promise<void>;
+    /** List the configured SSH hosts (from the shared dsh-ssh store). */
+    listHosts(): Promise<Array<{
+        alias: string;
+        host: string;
+        port: number;
+        user: string;
+    }>>;
+    /** Browse a remote directory (for the workspace picker). */
+    listRemoteDir(alias: string, path?: string): Promise<{
+        path: string;
+        entries: RemoteDirEntry[];
+    }>;
+    list(root: string, path: string): Promise<DirListing>;
+    read(root: string, path: string): Promise<FileRead>;
+    write(root: string, path: string, content: string, expectedMtime?: number): Promise<FileWriteResult>;
+    search(root: string, queryText: string): Promise<SearchView>;
+}
+/** The two /api/dsh-ssh endpoints the config dialog needs (host create/test). */
+export interface SshHostPayload {
+    alias?: string;
+    host: string;
+    port?: number;
+    user: string;
+    auth?: {
+        kind: 'key' | 'password';
+        keyPath?: string;
+        passphrase?: string;
+        password?: string;
+    };
+    description?: string;
+}
+export interface SshHostSummary {
+    alias: string;
+    host: string;
+    port: number;
+    user: string;
+    auth: 'key' | 'password';
+    keyReady: boolean;
+    description?: string;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface TestResult {
+    ok: boolean;
+    latencyMs?: number;
+    error?: string;
+}
+export declare class SshHostsApi {
+    list(): Promise<SshHostSummary[]>;
+    create(payload: SshHostPayload): Promise<SshHostSummary>;
+    /** Update an existing host (PATCH /api/dsh-ssh/hosts?alias=鈥?. The payload
+     *  may carry only the fields being changed; omitted auth keeps the stored
+     *  secret. */
+    update(alias: string, payload: SshHostPayload): Promise<SshHostSummary>;
+    /** Delete a host (DELETE /api/dsh-ssh/hosts?alias=鈥?. */
+    remove(alias: string): Promise<void>;
+    test(alias: string): Promise<TestResult>;
+}
+//# sourceMappingURL=api.d.ts.map

package/lib/types/client/directory-flow.d.ts

@@ -0,0 +1,82 @@
+/**
+ * The directory-flow occupant replacing the native-only "Add workspace…"
+ * interaction. When the operator clicks the native "Add workspace…" entry,
+ * this component opens a small chooser with two options:
+ *
+ *  - "Local workspace": delegates to the host native directory chooser
+ *    (`host.pickDirectory`) and hands the picked path back through the owner
+ *    conversation — exactly the original behavior.
+ *  - "SSH workspace": opens the SSH workspace creation dialog (pick a host,
+ *    browse a remote directory, name it). On success it calls
+ *    `onPicked(anchorPath)` so the host adopts the LOCAL ANCHOR directory as
+ *    a normal workspace (the seams route that workspace remote by its anchor
+ *    path). On cancel it calls `onCancel`.
+ *
+ * Occupancy: both directory-flow holes are `kind: 'single'`, so registering
+ * here replaces the native-only occupant. That is intended — we restore the
+ * native path ourselves via `pickDirectory`.
+ *
+ * @module dsh-hardssh/client/directory-flow
+ */
+import { type ReactElement } from 'react';
+import type { DirectoryFlowOwnerProps } from '@deepseek-ai/dsh-client-ui-workspace/client';
+import type { SshWorkspaceRecord } from '../protocol.ts';
+/** The injected face: host native picker + our workspace manager API. */
+export interface DirectoryFlowInjected {
+    /** Ask the local Host to open its native single-directory chooser. */
+    pickDirectory: () => Promise<string | null>;
+    /** Create an SSH workspace (host API). */
+    createSshWorkspace: (input: {
+        title: string;
+        alias: string;
+        remoteRoot: string;
+    }) => Promise<SshWorkspaceRecord>;
+    /** List configured SSH hosts (host API). */
+    listHosts: () => Promise<Array<{
+        alias: string;
+        host: string;
+        port: number;
+        user: string;
+    }>>;
+    /** Create a new SSH host (dsh-ssh host store; auth is required). */
+    createHost: (input: {
+        alias: string;
+        host: string;
+        port?: number;
+        user: string;
+        auth: {
+            kind: 'password';
+            password: string;
+        } | {
+            kind: 'key';
+            keyPath: string;
+            passphrase?: string;
+        };
+    }) => Promise<{
+        alias: string;
+        host: string;
+        port: number;
+        user: string;
+    }>;
+    /** Browse a remote directory (host API). */
+    listRemoteDir: (alias: string, path?: string) => Promise<{
+        path: string;
+        entries: Array<{
+            name: string;
+            type: 'dir' | 'file' | 'other';
+            size: number;
+            mtimeMs: number;
+        }>;
+    }>;
+    /** Interactive SSH connection gate: host-key TOFU + session-password
+     *  dialogs. Resolves true when the alias is connected (or the user
+     *  cancelled the prompts). Used to retry browsing. */
+    ensureConnected: (alias: string) => Promise<boolean>;
+}
+/**
+ * The flow occupant. Each rising `open` edge shows the menu; the ref arms
+ * once per open so re-renders (and an adoption keeping `open` true while
+ * `busy`) never launch a second flow.
+ */
+export declare function DirectoryFlow(props: DirectoryFlowOwnerProps & DirectoryFlowInjected): ReactElement | null;
+//# sourceMappingURL=directory-flow.d.ts.map

package/lib/types/client/icons.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Workspace icons for the SSH workspace surfaces: a cloud with a return arrow
+ * (SSH/remote workspace) and a desktop monitor (local workspace). Inlined SVG
+ * (1024 viewBox, solid fill) — no icon library dependency. Both inherit the
+ * theme text color via `currentColor` so they stay legible in light/dark
+ * themes.
+ * @module dsh-hardssh/client/icons
+ */
+import type { ReactElement } from 'react';
+interface IconProps {
+    size?: number;
+    className?: string;
+}
+/** Desktop-monitor icon: a local workstation (monitor + stand). */
+export declare function ComputerIcon({ size, className }: IconProps): ReactElement;
+/** Cloud-with-return-arrow icon: a remote/SSH workspace. */
+export declare function CloudIcon({ size, className }: IconProps): ReactElement;
+export {};
+//# sourceMappingURL=icons.d.ts.map