@tiphareth/dsh-hardssh 0.1.2-alpha → 0.2.2

package/lib/switch-fs-RrZtG2gv.js

@@ -1,210 +0,0 @@
-import { FileSystem } from "@deepseek-ai/dsh-fs";
-//#region src/switch/switch-fs.ts
-/**
-* The `ctx.fs` switching facade: routes every filesystem call to the backend
-* of the SESSION's workspace — a local session operates on the local sandbox,
-* an SSH-bound workspace on the remote host the workspace is bound to.
-*
-* Routing anchor: the cwd the tool call was made under (`resolve`'s
-* `opts.cwd`, the write/edit `sandboxPolicy.workspaceRoot`). The resolver
-* ("which SSH workspace owns this cwd?") lives in the deps; a hit routes to
-* that workspace's remote backend, a miss to the local backend. Later
-* operations (stat/read/write) receive only the resolved `FsTarget`, so the
-* backend identity is encoded into the target key — `ssh:<recordId>:<remoteKey>`
-* for remote targets, bare local keys for local ones — and decoded on every
-* dispatch. This keeps two SSH workspaces on DIFFERENT hosts (or different
-* directories on the SAME host) from colliding, and never misroutes a local
-* target.
-*
-* @module dsh-hardssh/switch-fs
-*/
-/** Key namespace: 'ssh:<recordId>:' (legacy) or 'wfs://<id>/' (current)
-*  for remote/workspace-bound targets. Both decode; new keys emit wfs://. */
-const REMOTE_PREFIX = "ssh:";
-/** Strict WFS key prefix (includes the double slash + separator). */
-const WFS_NAMESPACE_MARKER = `wfs://`;
-/** The routing filesystem facade. */
-var SwitchFileSystem = class extends FileSystem {
-	deps;
-	local;
-	constructor(ctx, deps) {
-		super(ctx);
-		this.deps = deps;
-		this.local = deps.local;
-	}
-	/** Sandbox default from the local backend (remote worlds are unconfined —
-	*  the docs/doc of the tool layer reads this once at mount). */
-	get sandboxMode() {
-		return this.local.sandboxMode;
-	}
-	/** Encode a raw key into the world's namespace. */
-	encode(rawKey, namespace) {
-		return namespace === "" ? rawKey : `${namespace}${rawKey}`;
-	}
-	/** Decode a namespaced key back to (rawKey, world). Supports both the
-	*  current `wfs://<id>/…` form and the legacy `ssh:<recordId>:…` form. */
-	decode(key) {
-		if (key.startsWith(WFS_NAMESPACE_MARKER)) {
-			const rest = key.slice(WFS_NAMESPACE_MARKER.length);
-			const end = rest.indexOf("/");
-			if (end > 0) {
-				const namespace = `wfs://${rest.slice(0, end + 1)}`;
-				const world = this.deps.worldForNamespace(namespace);
-				if (world !== void 0) return {
-					rawKey: rest.slice(end + 1),
-					world
-				};
-			}
-			return;
-		}
-		if (key.startsWith("ssh:")) {
-			const end = key.indexOf(":", 4);
-			if (end > 0) {
-				const namespace = key.slice(0, end + 1);
-				const world = this.deps.worldForNamespace(namespace);
-				if (world !== void 0) return {
-					rawKey: key.slice(namespace.length),
-					world
-				};
-			}
-			return;
-		}
-		return {
-			rawKey: key,
-			world: {
-				backend: this.local,
-				namespace: ""
-			}
-		};
-	}
-	async resolve(path, opts) {
-		const world = this.deps.worldFor(opts?.cwd);
-		const effectivePath = world.anchorPath !== void 0 && world.remoteRoot !== void 0 ? this.translateAnchorPath(world.anchorPath, world.remoteRoot, path) : path;
-		const raw = await world.backend.resolve(effectivePath, opts);
-		return {
-			targetKey: this.encode(String(raw.targetKey), world.namespace),
-			displayPath: raw.displayPath
-		};
-	}
-	/** Rewrite `<anchor>/<rest>` to `<remoteRoot>/<rest>` when `path` is the
-	*  anchor or under it; otherwise return `path` unchanged (remote absolute
-	*  paths, relative paths, and foreign local paths all pass through). */
-	translateAnchorPath(anchor, remoteRoot, path) {
-		const norm = (value) => value.replace(/[\\/]+$/, "");
-		const a = norm(anchor);
-		const isWin = a.includes("\\");
-		const normPath = (value) => {
-			let out = norm(value);
-			if (isWin) out = out.replace(/\//g, "\\");
-			return out;
-		};
-		const p = normPath(path);
-		const aa = isWin ? a.toLowerCase() : a;
-		const pp = isWin ? p.toLowerCase() : p;
-		if (pp === aa) return remoteRoot;
-		if (pp.startsWith(`${aa}\\`) || pp.startsWith(`${aa}/`)) {
-			const tail = p.slice(a.length).replace(/^[\\/]+/, "").replace(/\\/g, "/");
-			return tail === "" ? remoteRoot : `${remoteRoot.replace(/\/+$/, "")}/${tail}`;
-		}
-		return path;
-	}
-	processPath(target) {
-		const key = String(target.targetKey);
-		const decoded = this.decode(key);
-		return decoded?.world.backend.processPath({
-			targetKey: decoded.rawKey,
-			displayPath: target.displayPath
-		}) ?? key;
-	}
-	fileUrl(target) {
-		const decoded = this.decode(String(target.targetKey));
-		if (decoded === void 0) return this.local.fileUrl(target);
-		return decoded.world.backend.fileUrl({
-			targetKey: decoded.rawKey,
-			displayPath: target.displayPath
-		});
-	}
-	contains(parent, child) {
-		const p = this.decode(String(parent.targetKey));
-		const c = this.decode(String(child.targetKey));
-		if (p === void 0 || c === void 0 || p.world.backend !== c.world.backend) return false;
-		return p.world.backend.contains({
-			targetKey: p.rawKey,
-			displayPath: parent.displayPath
-		}, {
-			targetKey: c.rawKey,
-			displayPath: child.displayPath
-		});
-	}
-	async stat(target, signal) {
-		const decoded = this.decode(String(target.targetKey));
-		if (decoded === void 0) return void 0;
-		return decoded.world.backend.stat({
-			targetKey: decoded.rawKey,
-			displayPath: target.displayPath
-		}, signal);
-	}
-	async lstat(path, opts, signal) {
-		const world = this.deps.worldFor(opts?.cwd);
-		const effectivePath = world.anchorPath !== void 0 && world.remoteRoot !== void 0 ? this.translateAnchorPath(world.anchorPath, world.remoteRoot, path) : path;
-		return world.backend.lstat(effectivePath, opts, signal);
-	}
-	async readText(target, signal) {
-		const decoded = this.decode(String(target.targetKey));
-		if (decoded === void 0) throw new Error("fs-ssh: cannot route target");
-		return decoded.world.backend.readText({
-			targetKey: decoded.rawKey,
-			displayPath: target.displayPath
-		}, signal);
-	}
-	async streamText(target, signal) {
-		const decoded = this.decode(String(target.targetKey));
-		if (decoded === void 0) throw new Error("fs-ssh: cannot route target");
-		return decoded.world.backend.streamText({
-			targetKey: decoded.rawKey,
-			displayPath: target.displayPath
-		}, signal);
-	}
-	async readBytes(target, signal, maxBytes) {
-		const decoded = this.decode(String(target.targetKey));
-		if (decoded === void 0) throw new Error("fs-ssh: cannot route target");
-		return decoded.world.backend.readBytes({
-			targetKey: decoded.rawKey,
-			displayPath: target.displayPath
-		}, signal, maxBytes);
-	}
-	async listDir(target, signal) {
-		const decoded = this.decode(String(target.targetKey));
-		if (decoded === void 0) throw new Error("fs-ssh: cannot route target");
-		const entries = await decoded.world.backend.listDir({
-			targetKey: decoded.rawKey,
-			displayPath: target.displayPath
-		}, signal);
-		if (decoded.world.namespace === "") return entries;
-		return entries.map((entry) => ({
-			...entry,
-			target: {
-				targetKey: this.encode(String(entry.target.targetKey), decoded.world.namespace),
-				displayPath: entry.target.displayPath
-			}
-		}));
-	}
-	async writeText(target, content, expected, signal, sandboxPolicy) {
-		const decoded = this.decode(String(target.targetKey));
-		if (decoded === void 0) throw new Error("fs-ssh: cannot route target");
-		return decoded.world.backend.writeText({
-			targetKey: decoded.rawKey,
-			displayPath: target.displayPath
-		}, content, expected, signal, sandboxPolicy);
-	}
-	async editText(target, edit, expected, signal, sandboxPolicy) {
-		const decoded = this.decode(String(target.targetKey));
-		if (decoded === void 0) throw new Error("fs-ssh: cannot route target");
-		return decoded.world.backend.editText({
-			targetKey: decoded.rawKey,
-			displayPath: target.displayPath
-		}, edit, expected, signal, sandboxPolicy);
-	}
-};
-//#endregion
-export { SwitchFileSystem as n, WFS_NAMESPACE_MARKER as r, REMOTE_PREFIX as t };

package/lib/types/client/manager-button.d.ts

@@ -1,32 +0,0 @@
-import { type ReactElement } from 'react';
-import type { WorkspaceManager } from './state.ts';
-import type { SshApi } from './ssh/api.ts';
-/** The session-header button. Slot-injected props: manager + sshApi. */
-export declare function WorkspaceManagerButton(props: {
-    manager: WorkspaceManager;
-    /** Full SSH host API (list/create/update/delete) for server management. */
-    sshApi?: SshApi;
-    sessionId?: unknown;
-    useSession?: unknown;
-    useSessions?: unknown;
-    useWorkspaces?: unknown;
-    useProjection?: unknown;
-    useInput?: unknown;
-    inputActions?: unknown;
-    renderSlot?: unknown;
-    renderSlotChain?: unknown;
-    t?: unknown;
-}): ReactElement;
-/** Open the manager dropdown, anchored under the trigger button. */
-export declare function openManager(manager: WorkspaceManager, sshApi?: SshApi, trigger?: HTMLElement): void;
-/** The manager dropdown: server + workspace rows, with server CRUD. */
-export declare function ManagerOverlay(props: {
-    manager: WorkspaceManager;
-    sshApi?: SshApi;
-    onClose: () => void;
-    anchor?: {
-        bottom: number;
-        left: number;
-    };
-}): ReactElement;
-//# sourceMappingURL=manager-button.d.ts.map

package/lib/types/client/ssh/mount.d.ts

@@ -1,13 +0,0 @@
-import type { SshApi } from './api.ts';
-import type { PanelController } from './panel/controller.ts';
-/** The injected panel container (kept in the DOM, hidden when inactive). */
-export declare const PANEL_VIEW_SELECTOR = "[data-dsh-ssh-view]";
-/**
- * Mount the panel React tree into the center column and bind its visibility
- * to the controller's panelOpen state.
- * @param controller - the panel controller driving the view.
- * @param api - the SSH API client the tabs operate through.
- * @returns disposer unmounting the tree and restoring the column.
- */
-export declare function mountPanel(controller: PanelController, api: SshApi): () => void;
-//# sourceMappingURL=mount.d.ts.map

package/lib/types/client/ssh/panel/HostsTab.d.ts

@@ -1,10 +0,0 @@
-import type { SshApi } from '../api.ts';
-/** Hosts tab props. */
-export interface HostsTabProps {
-    api: SshApi;
-    /** Connect the given alias in the terminal tab. */
-    onConnect: (alias: string) => void;
-}
-/** The hosts table plus its toolbar and dialogs. */
-export declare function HostsTab({ api, onConnect }: HostsTabProps): import("react").JSX.Element;
-//# sourceMappingURL=HostsTab.d.ts.map

package/lib/types/client/ssh/panel/controller.d.ts

@@ -1,23 +0,0 @@
-/**
- * SSH panel controller: the single owner of the panel's open/closed state.
- *
- * Framework-free (structural runtime faces, task-board core/controller.ts
- * style) so the DOM mounts and the React panel share one tiny subscription
- * surface. The state lives only for the browser session (no persistence).
- */
-/** Immutable controller snapshot for UI subscriptions. */
-export interface PanelControllerSnapshot {
-    panelOpen: boolean;
-}
-/** The panel state owner the sidebar entry toggles and the view renders from. */
-export declare class PanelController {
-    private panelOpen;
-    private listeners;
-    getSnapshot(): PanelControllerSnapshot;
-    subscribe(fn: () => void): () => void;
-    open(): void;
-    close(): void;
-    toggle(): void;
-    private notify;
-}
-//# sourceMappingURL=controller.d.ts.map

package/lib/types/client/ssh/sidebar-entry.d.ts

@@ -1,25 +0,0 @@
-/**
- * Sidebar entry injection.
- *
- * dsh's sidebar shell exposes no slot an external plugin can register into,
- * so — following the task-board precedent of DOM-level extension — the entry
- * row is injected between the shell's New Session button and the workspace
- * browser. The injection self-heals: a MutationObserver watches the sidebar
- * root and re-inserts the row whenever a React re-render displaces it
- * (re-insertion happens in the same frame, before paint, so no flicker).
- *
- * The row is plain DOM (no React tree) so it can never disturb the shell's
- * reconciliation; the panel view it toggles is a separate React root mounted
- * in the center column (see mount.tsx).
- */
-import type { PanelController } from './panel/controller.ts';
-/** Stable data attribute identifying the injected entry row. */
-export declare const ENTRY_SELECTOR = "[data-dsh-ssh-entry]";
-/**
- * Mount the sidebar entry, waiting for the shell to render and self-healing
- * on later React re-renders.
- * @param controller - the panel controller the entry toggles.
- * @returns disposer removing the entry and its observers.
- */
-export declare function mountSidebarEntry(controller: PanelController): () => void;
-//# sourceMappingURL=sidebar-entry.d.ts.map

package/lib/types/client/workspace-gate.d.ts

@@ -1,15 +0,0 @@
-import type { SshApi } from './ssh/api.ts';
-/** Silent prompt-only connection gate (no row / banner) for flows that
- *  surface their own errors (e.g. the directory browser). */
-export declare function connectHost(api: SshApi, alias: string): Promise<boolean>;
-/**
- * Mount the click gate over every sidebar workspace row whose title belongs
- * to an SSH-bound workspace. Self-heals via MutationObserver. Returns a
- * disposer that removes listeners and injected state.
- */
-export declare function mountWorkspaceGates(workspaces: Array<{
-    id: string;
-    title: string;
-    alias: string;
-}>, api: SshApi): () => void;
-//# sourceMappingURL=workspace-gate.d.ts.map

package/lib/types/remote-runner.d.ts

@@ -1,83 +0,0 @@
-/**
- * Remote-workspace runner: lets other plugins (dsh-workbench-tiphareth) run
- * git/files/terminals against an SSH-bound workspace. The workbench host asks
- * `resolveRemote(root)` for a local anchor path; a hit returns the remote
- * context + callable channels (git exec via the engine, SFTP ops, PTY).
- * Kept duck-typed so the workbench never needs a compile-time dependency.
- */
-import type { SshEngine } from './ssh/engine.ts';
-import type { SshWorkspaceLedger } from './ledger.ts';
-/** The remote context one SSH-bound workspace resolves to. */
-export interface RemoteWorkspaceContext {
-    alias: string;
-    remoteRoot: string;
-    /** Run `git [args...]` inside remoteRoot. Mirrors runGit's result shape. */
-    git(args: readonly string[], opts?: {
-        timeoutMs?: number;
-        input?: string;
-        allowNonZero?: boolean;
-    }): Promise<{
-        stdout: string;
-        stderr: string;
-        exitCode: number;
-    }>;
-    /** Run one arbitrary command (used by tools that shell out). */
-    run(command: string, opts?: {
-        timeoutMs?: number;
-    }): Promise<{
-        stdout: string;
-        stderr: string;
-        exitCode: number;
-    }>;
-    /** SFTP operations. */
-    list(path: string): Promise<Array<{
-        name: string;
-        type: 'dir' | 'file' | 'other';
-        size: number;
-        mtimeMs: number;
-    }>>;
-    stat(path: string): Promise<{
-        type: 'dir' | 'file' | 'other';
-        size: number;
-        mtimeMs: number;
-        mode: number;
-    }>;
-    readFile(path: string): Promise<{
-        content: Buffer;
-        mtime: number;
-        size: number;
-    }>;
-    writeFile(path: string, content: Buffer, expectedMtime?: number): Promise<{
-        mtime: number;
-    }>;
-    mkdir(path: string): Promise<void>;
-    rm(path: string, recursive: boolean): Promise<void>;
-    rename(from: string, to: string): Promise<void>;
-    /** Open an interactive SSH PTY in remoteRoot (columns/rows for the channel). */
-    openTerminal(cols: number, rows: number): Promise<RemotePtyHandle>;
-}
-/** Minimal PTY handle (duck-typed for consumers like dsh-workbench-tiphareth). */
-export interface RemotePtyHandle {
-    shell: string;
-    write(data: string): void;
-    resize(cols: number, rows: number): void;
-    kill(): void;
-    onData(handler: (data: string) => void): {
-        dispose(): void;
-    };
-    onExit(handler: (event: {
-        exitCode: number;
-    }) => void): {
-        dispose(): void;
-    };
-}
-/** Builds remote-workspace contexts off the shared ledger + engine. */
-export declare class RemoteWorkspaceRunner {
-    private readonly engine;
-    private readonly ledger;
-    constructor(engine: SshEngine, ledger: SshWorkspaceLedger);
-    /** Resolve a LOCAL anchor path to a remote context, or null if not SSH-bound. */
-    resolveRemote(root: string): RemoteWorkspaceContext | null;
-    private build;
-}
-//# sourceMappingURL=remote-runner.d.ts.map

package/lib/types/seam-state.d.ts

@@ -1,69 +0,0 @@
-/**
- * The shared derived seam state: ONE ledger-derived routing snapshot
- * (records + normalized anchor index) plus the per-record fs/subprocess
- * instances, owned by the hardssh core and consumed by BOTH switch rows
- * (./fs and ./subprocess). Because both seams read the SAME state, they can
- * never disagree with each other or with the ledger's own index for a given
- * session cwd — eliminating the split-brain window of the old per-seam
- * async refresh caches.
- *
- * The state re-applies SYNCHRONOUSLY on every ledger commit: ledger
- * listeners run synchronously AFTER the commit already swapped the
- * in-memory records, so a synchronous re-apply is always current — no async
- * refresh pipeline, no stale-snapshot race, no revision-guard interleaving.
- * The initial file load is awaited before the state is marked ready; until
- * then routing degrades to local with a one-time warning from the rows.
- *
- * Per-record instances are built lazily on first route and kept alive
- * across refreshes (connections survive); removing a workspace drops its
- * instances so stale target keys resolve to NOTHING (fail closed), never to
- * the local backend.
- *
- * @module dsh-hardssh/seam-state
- */
-import type { SshWorkspaceRecord } from './protocol.ts';
-import { type SshWorkspaceLedger } from './ledger.ts';
-import { type WorkspaceWorld } from './switch/switch-fs.ts';
-import type { SshSubprocessRuntime } from './remote/remote-subprocess.ts';
-/** Shared routing state for the fs/subprocess switch rows. */
-export declare class WorkspaceSeamState {
-    private readonly ledger;
-    private readonly records;
-    private readonly instances;
-    private anchors;
-    private appliedRevision;
-    private ready;
-    private readyResolvers;
-    private fsFactory;
-    private subFactory;
-    constructor(ledger: SshWorkspaceLedger);
-    /** Bind the fs-row's per-record backend builder (called once at apply). */
-    bindFs(factory: (record: SshWorkspaceRecord) => WorkspaceWorld): void;
-    /** Bind the subprocess-row's per-record runtime builder (called once at apply). */
-    bindSub(factory: (record: SshWorkspaceRecord) => SshSubprocessRuntime): void;
-    /** True once the initial ledger snapshot has been applied. */
-    isReady(): boolean;
-    /** Resolves once the initial ledger snapshot has been applied. */
-    whenReady(): Promise<void>;
-    /**
-     * Subscribe to ledger commits and kick the initial load. Returns the
-     * subscription disposer (register it through ctx.effect for HMR cleanup).
-     */
-    attach(): () => void;
-    /** Re-apply the ledger's current in-memory state (idempotent, guarded). */
-    applySync(): void;
-    /** The record owning a session cwd, or undefined when the cwd is local. */
-    private recordFor;
-    private ensureFs;
-    private ensureSubprocess;
-    /** The fs world owning a session cwd, or undefined (local). */
-    worldForFs(cwd: string | undefined): WorkspaceWorld | undefined;
-    /** The fs world for one namespaced target key (`wfs://<id>/…` or legacy
-     *  `ssh:<id>:`), or undefined when the owning workspace no longer exists
-     *  (stale key → fail closed). */
-    worldForFsNamespace(namespace: string): WorkspaceWorld | undefined;
-    /** The subprocess runtime owning a session cwd, or undefined (local). */
-    runtimeForSub(cwd: string | undefined): SshSubprocessRuntime | undefined;
-    private markReady;
-}
-//# sourceMappingURL=seam-state.d.ts.map