@tiphareth/dsh-hardssh 0.1.2 → 0.2.2

package/lib/ledger-B-LXlftp.js

@@ -0,0 +1,43 @@
+import { join, posix } from "node:path";
+import { homedir } from "node:os";
+//#region src/ledger.ts
+/**
+* SSH-bound workspace path helpers.
+*
+* This module is the last remaining piece of the retired SSH ledger module:
+* the `SshWorkspaceLedger` class was removed with the generic cutover, so what
+* survives here are the anchor/path helpers the generic runtime still shares —
+* the managed SSH anchor layout (`~/.dsh/ssh-workspaces/<id>`), the legacy
+* ledger file location (the one-time import source), the client DTO title
+* default, and the lexical anchor-containment helpers used by fs/subprocess
+* fail-closed gating. Record persistence itself is owned by the generic
+* `WorkspaceLedger` (`./base/ledger.ts`).
+*
+* @module dsh-hardssh/ledger
+*/
+/** The frozen legacy SSH ledger location: ~/.dsh/dsh-hardssh-workspaces.json.
+*  Only read once by the startup import when no cutover marker exists. */
+function ledgerPath() {
+	return join(homedir(), ".dsh", "dsh-hardssh-workspaces.json");
+}
+/**
+* Normalize a remote POSIX root: keep '/' as '/', collapse repeated
+* separators and dot segments, reject relative paths and NUL.
+*/
+function normalizeRemoteRoot(raw) {
+	if (raw.includes("\0")) throw new Error(`remoteRoot must not contain NUL (got '${raw}')`);
+	const normalized = posix.normalize(raw.trim());
+	if (!normalized.startsWith("/")) throw new Error(`remoteRoot must be an absolute POSIX path (got '${raw}')`);
+	return normalized === "/" ? "/" : normalized.replace(/\/+$/, "");
+}
+/** Anchor roots: ~/.dsh/ssh-workspaces/<id>/ — visible in the sidebar as
+*  ordinary host workspaces (and thus selectable for sessions). */
+function anchorRoot() {
+	return join(homedir(), ".dsh", "ssh-workspaces");
+}
+/** Default record title when the user gives none. */
+function defaultTitle(remoteRoot, alias) {
+	return `${alias}:${remoteRoot.split("/").filter(Boolean).pop() ?? remoteRoot}`;
+}
+//#endregion
+export { normalizeRemoteRoot as i, defaultTitle as n, ledgerPath as r, anchorRoot as t };

package/lib/ledger-D2ezq1iW.js

@@ -0,0 +1,376 @@
+import { realpathSync } from "node:fs";
+import { dirname } from "node:path";
+import { randomUUID } from "node:crypto";
+import { copyFile, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+//#region src/base/ledger.ts
+/**
+* Provider-neutral workspace ledger with strict loading, atomic persistence,
+* detached snapshots, and one serialized mutation queue.
+*/
+/** Normalize an anchor for comparison (Windows case-insensitive; POSIX not). */
+function normalizeAnchorPath(path) {
+	if (/^[a-zA-Z]:[\\/]/.test(path) || path.includes("\\")) {
+		const normalized = path.replace(/\//g, "\\");
+		return trimTrailing(normalized, /^[a-zA-Z]:\\/.test(normalized) ? 3 : 0).toLowerCase();
+	}
+	return trimTrailing(path, path.startsWith("/") ? 1 : 0);
+}
+/** True when `candidate` equals `anchor` or is one of its descendants (lexical). */
+function isPathUnderAnchor(anchor, candidate) {
+	const normAnchor = normalizeAnchorPath(anchor);
+	const normCandidate = normalizeAnchorPath(candidate);
+	if (normCandidate === normAnchor) return true;
+	const sep = normAnchor.includes("\\") ? "\\" : "/";
+	const prefix = normAnchor.endsWith(sep) ? normAnchor : `${normAnchor}${sep}`;
+	return normCandidate.startsWith(prefix);
+}
+function trimTrailing(path, minimumLength) {
+	let end = path.length;
+	while (end > minimumLength && (path[end - 1] === "/" || path[end - 1] === "\\")) end -= 1;
+	return path.slice(0, end);
+}
+/** Generic ledger schema currently accepted by strict loading. */
+const WORKSPACE_LEDGER_SCHEMA_VERSION = 1;
+/**
+* The generic ledger. The in-memory state changes only after an atomic save,
+* and every public observation is detached from that state.
+*/
+var WorkspaceLedger = class {
+	fileOverride;
+	anchorOverride;
+	records;
+	loadPromise;
+	anchorIndex = [];
+	mutationTail = Promise.resolve();
+	currentRevision = 0;
+	listeners = /* @__PURE__ */ new Set();
+	constructor(fileOverride, anchorOverride) {
+		this.fileOverride = fileOverride;
+		this.anchorOverride = anchorOverride;
+	}
+	file() {
+		return this.fileOverride ?? "";
+	}
+	anchors() {
+		return this.anchorOverride ?? "";
+	}
+	async ensureLoaded() {
+		if (this.records !== void 0) return;
+		if (this.loadPromise === void 0) this.loadPromise = this.readRecords();
+		await this.loadPromise;
+	}
+	async readRecords() {
+		let parsed;
+		try {
+			const text = await readFile(this.file(), "utf8");
+			parsed = JSON.parse(text);
+		} catch (error) {
+			if (isNodeErrorCode(error, "ENOENT")) {
+				this.records = [];
+				this.reindex();
+				return;
+			}
+			throw error;
+		}
+		if (!Array.isArray(parsed)) throw new Error("WorkspaceLedger: expected a JSON array");
+		assertValidRecords(parsed);
+		this.records = cloneRecords(parsed);
+		this.reindex();
+	}
+	reindex() {
+		this.anchorIndex = (this.records ?? []).filter((record) => record.anchor !== void 0).map((record) => ({
+			anchor: normalizeAnchorPath(record.anchor.path),
+			record
+		})).sort((a, b) => b.anchor.length - a.anchor.length);
+	}
+	async save(nextRecords) {
+		assertValidRecords(nextRecords);
+		const target = this.file();
+		if (target === "") throw new Error("WorkspaceLedger: no persistence file configured");
+		await mkdir(dirname(target), { recursive: true });
+		const temporary = `${target}.tmp-${process.pid}-${Date.now()}-${randomUUID()}`;
+		const lastGood = `${target}.last-good`;
+		try {
+			await writeFile(temporary, JSON.stringify(nextRecords, null, 2), "utf8");
+			const hadPrevious = await copyFile(target, lastGood).then(() => true, (error) => {
+				if (!isNodeErrorCode(error, "ENOENT")) console.warn(`[dsh-hardssh] could not refresh the ledger recovery copy: ${error instanceof Error ? error.message : String(error)}`);
+				return false;
+			});
+			await rename(temporary, target);
+			if (!hadPrevious) await copyFile(target, lastGood).catch(() => void 0);
+		} catch (error) {
+			await rm(temporary, { force: true }).catch(() => void 0);
+			throw error;
+		}
+	}
+	enqueueMutation(operation) {
+		const result = this.mutationTail.then(operation);
+		this.mutationTail = result.then(() => void 0, () => void 0);
+		return result;
+	}
+	commit(nextRecords, change) {
+		this.records = cloneRecords(nextRecords);
+		this.reindex();
+		this.currentRevision += 1;
+		this.emit({
+			...change,
+			revision: this.currentRevision
+		});
+	}
+	emit(change) {
+		for (const listener of [...this.listeners]) try {
+			listener(cloneChange(change));
+		} catch (error) {
+			console.warn("[dsh-workspace] ledger subscriber failed:", error instanceof Error ? error.message : String(error));
+		}
+	}
+	async load() {
+		await this.ensureLoaded();
+		return cloneRecords(this.records ?? []);
+	}
+	async list() {
+		await this.ensureLoaded();
+		return cloneRecords(this.records ?? []);
+	}
+	async snapshot() {
+		await this.ensureLoaded();
+		return {
+			revision: this.currentRevision,
+			records: cloneRecords(this.records ?? [])
+		};
+	}
+	snapshotSync() {
+		return {
+			revision: this.currentRevision,
+			records: cloneRecords(this.records ?? [])
+		};
+	}
+	revision() {
+		return this.currentRevision;
+	}
+	subscribe(listener) {
+		this.listeners.add(listener);
+		let disposed = false;
+		return () => {
+			if (disposed) return;
+			disposed = true;
+			this.listeners.delete(listener);
+		};
+	}
+	async get(id) {
+		await this.ensureLoaded();
+		const record = this.records?.find((candidate) => candidate.id === id);
+		return record === void 0 ? void 0 : cloneRecord(record);
+	}
+	async findByAnchor(path) {
+		await this.ensureLoaded();
+		return this.findByAnchorSync(path);
+	}
+	findByAnchorSync(path) {
+		const canonical = safeRealpathSync(path);
+		if (canonical === void 0) return void 0;
+		for (const { anchor, record } of this.anchorIndex) if (isPathUnderAnchor(anchor, canonical)) return cloneRecord(record);
+	}
+	/** Create cannot preserve caller timestamps, so migration uses replaceAll instead. */
+	async create(input) {
+		return this.enqueueMutation(async () => {
+			await this.ensureLoaded();
+			const now = (/* @__PURE__ */ new Date()).toISOString();
+			const record = cloneRecord({
+				schemaVersion: input.schemaVersion,
+				id: input.id ?? randomUUID(),
+				title: input.title,
+				provider: input.provider,
+				location: input.location,
+				anchor: input.anchor,
+				createdAt: now,
+				updatedAt: now,
+				labels: input.labels,
+				extensions: input.extensions
+			});
+			const nextRecords = [...this.records ?? [], record];
+			assertValidRecords(nextRecords);
+			if (record.anchor !== void 0 && record.anchor.mode === "managed") await mkdir(record.anchor.path, { recursive: true });
+			await this.save(nextRecords);
+			this.commit(nextRecords, {
+				type: "created",
+				record
+			});
+			return cloneRecord(record);
+		});
+	}
+	async rename(id, title) {
+		const before = await this.get(id);
+		const record = await this.update(id, { title: title.trim() });
+		if (before === void 0 || record === void 0) return void 0;
+		return record;
+	}
+	/** WorkspaceLedger.rename cannot change provider bindings or extension data, so update applies a generic patch. */
+	async update(id, patch) {
+		return this.enqueueMutation(async () => {
+			await this.ensureLoaded();
+			const records = this.records ?? [];
+			const index = records.findIndex((record) => record.id === id);
+			if (index < 0) return void 0;
+			const before = cloneRecord(records[index]);
+			const record = cloneRecord({
+				...before,
+				...structuredClone(patch),
+				id: before.id,
+				schemaVersion: before.schemaVersion,
+				createdAt: before.createdAt,
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+			});
+			const nextRecords = [...records];
+			nextRecords[index] = record;
+			assertValidRecords(nextRecords);
+			await this.save(nextRecords);
+			this.commit(nextRecords, {
+				type: "updated",
+				before,
+				record
+			});
+			return cloneRecord(record);
+		});
+	}
+	/** WorkspaceLedger.create persists one generated record, so it cannot atomically import a complete authoritative snapshot. */
+	async replaceAll(records, options = {}) {
+		return this.enqueueMutation(async () => {
+			await this.ensureLoaded();
+			const nextRecords = cloneRecords(records);
+			assertValidRecords(nextRecords);
+			const before = cloneRecords(this.records ?? []);
+			if (options.backupPath !== void 0) {
+				await mkdir(dirname(options.backupPath), { recursive: true });
+				try {
+					await copyFile(this.file(), options.backupPath);
+				} catch (error) {
+					if (!isNodeErrorCode(error, "ENOENT")) throw error;
+				}
+			}
+			await this.save(nextRecords);
+			this.commit(nextRecords, {
+				type: "replaced",
+				before,
+				records: nextRecords
+			});
+		});
+	}
+	/** Remove a record. The anchor directory is left in place (caller decides). */
+	async remove(id) {
+		return this.enqueueMutation(async () => {
+			await this.ensureLoaded();
+			const records = this.records ?? [];
+			const index = records.findIndex((record) => record.id === id);
+			if (index < 0) return false;
+			const record = records[index];
+			const nextRecords = [...records.slice(0, index), ...records.slice(index + 1)];
+			await this.save(nextRecords);
+			this.commit(nextRecords, {
+				type: "removed",
+				record
+			});
+			return true;
+		});
+	}
+	anchorsRoot() {
+		return this.anchors();
+	}
+};
+/** isRecord validates one shape only, so this validator also rejects duplicate ids and ambiguous anchors across records. */
+function assertValidRecords(values) {
+	const ids = /* @__PURE__ */ new Set();
+	const anchors = [];
+	for (const value of values) {
+		if (!isRecord(value)) throw new Error("WorkspaceLedger: invalid workspace record");
+		if (ids.has(value.id)) throw new Error(`WorkspaceLedger: duplicate workspace id '${value.id}'`);
+		ids.add(value.id);
+		if (value.anchor !== void 0) anchors.push({
+			id: value.id,
+			path: normalizeAnchorPath(value.anchor.path)
+		});
+	}
+	for (let left = 0; left < anchors.length; left += 1) for (let right = left + 1; right < anchors.length; right += 1) {
+		const a = anchors[left];
+		const b = anchors[right];
+		if (isPathUnderAnchor(a.path, b.path) || isPathUnderAnchor(b.path, a.path)) throw new Error(`WorkspaceLedger: duplicate or overlapping anchors for '${a.id}' and '${b.id}'`);
+	}
+}
+function isRecord(value) {
+	if (!isPlainObject(value)) return false;
+	const provider = value.provider;
+	const location = value.location;
+	const anchor = value.anchor;
+	const labels = value.labels;
+	const extensions = value.extensions;
+	if (value.schemaVersion !== 1 || typeof value.id !== "string" || value.id === "" || typeof value.title !== "string" || !isPlainObject(provider) || typeof provider.id !== "string" || provider.id === "" || provider.instanceId !== void 0 && typeof provider.instanceId !== "string" || !isConnectionRef(provider.connectionRef) || !isPlainObject(location) || typeof location.kind !== "string" || location.kind === "" || typeof location.root !== "string" || location.root === "" || location.options !== void 0 && (!isPlainObject(location.options) || !isJsonValue(location.options)) || !isAnchor(anchor) || typeof value.createdAt !== "string" || typeof value.updatedAt !== "string" || labels !== void 0 && (!isPlainObject(labels) || Object.values(labels).some((label) => typeof label !== "string")) || extensions !== void 0 && (!isPlainObject(extensions) || !isJsonValue(extensions))) return false;
+	return true;
+}
+/** isRecord cannot distinguish an absent connectionRef from a malformed present one without this focused guard. */
+function isConnectionRef(value) {
+	return value === void 0 || isPlainObject(value) && typeof value.id === "string" && value.id !== "" && (value.alias === void 0 || typeof value.alias === "string");
+}
+/** isRecord delegates optional anchor validation here because anchor has a discriminated mode shape. */
+function isAnchor(value) {
+	return value === void 0 || isPlainObject(value) && typeof value.path === "string" && value.path !== "" && (value.mode === "managed" || value.mode === "existing");
+}
+/** typeof object also accepts arrays and prototypes, so isRecord needs this stricter object check. */
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+/** isRecord cannot validate arbitrarily nested options/extensions inline, so this recursive JSON-value guard closes that gap. */
+function isJsonValue(value) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+	if (typeof value === "number") return Number.isFinite(value);
+	if (Array.isArray(value)) return value.every(isJsonValue);
+	if (!isPlainObject(value)) return false;
+	return Object.values(value).every(isJsonValue);
+}
+function safeRealpathSync(path) {
+	try {
+		return realpathSync(path);
+	} catch {
+		return;
+	}
+}
+function cloneRecord(record) {
+	return structuredClone(record);
+}
+function cloneRecords(records) {
+	return records.map(cloneRecord);
+}
+function cloneChange(change) {
+	switch (change.type) {
+		case "created": return {
+			...change,
+			record: cloneRecord(change.record)
+		};
+		case "renamed": return {
+			...change,
+			before: cloneRecord(change.before),
+			record: cloneRecord(change.record)
+		};
+		case "updated": return {
+			...change,
+			before: cloneRecord(change.before),
+			record: cloneRecord(change.record)
+		};
+		case "removed": return {
+			...change,
+			record: cloneRecord(change.record)
+		};
+		case "replaced": return {
+			...change,
+			before: cloneRecords(change.before),
+			records: cloneRecords(change.records)
+		};
+	}
+}
+/** Error.message cannot reliably identify ENOENT, so strict loading checks Node's machine-readable code. */
+function isNodeErrorCode(error, code) {
+	return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}
+//#endregion
+export { normalizeAnchorPath as a, isPathUnderAnchor as i, WorkspaceLedger as n, assertValidRecords as r, WORKSPACE_LEDGER_SCHEMA_VERSION as t };

package/lib/model-Cp7f70Mb.js

@@ -0,0 +1,5 @@
+//#region src/base/model.ts
+/** Provider API major implemented by the generic workspace foundations. */
+const WORKSPACE_PROVIDER_API_VERSION = 2;
+//#endregion
+export { WORKSPACE_PROVIDER_API_VERSION as t };