@tiphareth/dsh-hardssh 0.1.2 → 0.2.3

package/lib/registry-CViuzKYI.js

@@ -0,0 +1,421 @@
+import { a as normalizeAnchorPath, i as isPathUnderAnchor } from "./ledger-D2ezq1iW.js";
+//#region src/base/namespace.ts
+/**
+* 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. */
+const WFS_SCHEME = "wfs:";
+/** ASCII-encode a workspace id for safe embedding in a URL-ish key. */
+function encodeWorkspaceId(id) {
+	return encodeURIComponent(id);
+}
+/** Decode a workspace id back from its encoded form. */
+function decodeWorkspaceId(encoded) {
+	return decodeURIComponent(encoded);
+}
+/**
+* Encode a route as `wfs://<id>/<path>`. A leading slash on the path is
+* preserved after the namespace marker.
+*/
+function encodeRoute(route) {
+	const path = route.path.startsWith("/") ? route.path : `/${route.path}`;
+	return `${WFS_SCHEME}//${encodeWorkspaceId(route.workspaceId)}${path}`;
+}
+/** Decode a `wfs://<id>/<path>` key (strict). */
+function decodeWfsKey(input) {
+	if (!input.startsWith(`wfs://`)) return void 0;
+	const rest = input.slice(`${WFS_SCHEME}//`.length);
+	const separator = rest.indexOf("/");
+	if (separator < 0) return void 0;
+	const encodedId = rest.slice(0, separator);
+	if (encodedId === "") return void 0;
+	let workspaceId;
+	try {
+		workspaceId = decodeWorkspaceId(encodedId);
+	} catch {
+		return;
+	}
+	const path = rest.slice(separator);
+	return {
+		workspaceId,
+		path
+	};
+}
+/**
+* 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).
+*/
+function decodeLegacySshKey(input) {
+	if (!input.startsWith("ssh:")) return void 0;
+	const rest = input.slice(4);
+	const end = rest.indexOf(":");
+	if (end <= 0) return void 0;
+	return {
+		workspaceId: rest.slice(0, end),
+		path: rest.slice(end + 1)
+	};
+}
+/**
+* The default codec: emits `wfs://…` and accepts both `wfs://…` and legacy
+* `ssh:<id>:…`.
+*/
+const defaultNamespaceCodec = {
+	encode: encodeRoute,
+	decode(input) {
+		return decodeWfsKey(input) ?? decodeLegacySshKey(input);
+	},
+	isExplicitNamespace(input) {
+		return input.startsWith("wfs:") || input.startsWith("ssh:");
+	}
+};
+//#endregion
+//#region src/base/ledger-router.ts
+/** Ledger + provider-registry based router. */
+var LedgerWorkspaceRouter = class {
+	ledger;
+	providers;
+	options;
+	codec;
+	connections = /* @__PURE__ */ new Map();
+	connectionBindings = /* @__PURE__ */ new Map();
+	opening = /* @__PURE__ */ new Map();
+	closing = /* @__PURE__ */ new Set();
+	anchors = [];
+	lifecycleAbort = new AbortController();
+	initializePromise;
+	ready = false;
+	closed = false;
+	ledgerDisposer;
+	providerDisposer;
+	constructor(ledger, providers, options = {}) {
+		this.ledger = ledger;
+		this.providers = providers;
+		this.options = options;
+		this.codec = options.codec ?? defaultNamespaceCodec;
+	}
+	/** ensureOpen() warms one supplied record only, so initialize loads, subscribes, and preopens the complete persisted ledger before readiness. */
+	initialize() {
+		if (this.initializePromise !== void 0) return this.initializePromise;
+		if (this.closed) return Promise.reject(/* @__PURE__ */ new Error("LedgerWorkspaceRouter is closed"));
+		this.initializePromise = this.initializeInternal();
+		return this.initializePromise;
+	}
+	/** initialize() is asynchronous, so isReady provides the synchronous seam gate it cannot provide. */
+	isReady() {
+		return this.ready && !this.closed;
+	}
+	/** isReady() only reports a snapshot, so whenReady lets asynchronous consumers await the initialization outcome. */
+	async whenReady() {
+		await this.initialize();
+	}
+	/** ensureOpen() requires a record, so openById performs fail-closed ledger identity lookup before single-flight opening. */
+	async openById(id, signal) {
+		if (this.closed) return void 0;
+		if (signal?.aborted === true) throw abortError();
+		const record = await this.ledger.get(id);
+		if (record === void 0) return void 0;
+		return awaitWithSignal(this.openFor(record), signal);
+	}
+	/** openById() cannot translate a host anchor, so openByAnchor resolves ledger ownership before opening. */
+	async openByAnchor(path, signal) {
+		if (this.closed) return void 0;
+		const record = await this.ledger.findByAnchor(path);
+		if (record === void 0) return void 0;
+		return this.openById(record.id, signal);
+	}
+	/** initialize() owns promise reuse, so initializeInternal performs the one actual load/subscribe/preopen sequence. */
+	async initializeInternal() {
+		const records = await this.ledger.load();
+		if (this.closed) return;
+		this.reindex();
+		this.ledgerDisposer = this.ledger.subscribe((change) => this.handleLedgerChange(change));
+		this.providerDisposer = this.providers.subscribe((change) => this.handleProviderChange(change));
+		await Promise.all(records.map(async (record) => {
+			if (!this.providers.has(record.provider.id)) return;
+			await this.openFor(record);
+		}));
+		if (!this.closed) this.ready = true;
+	}
+	reindex() {
+		const snapshot = this.ledger.snapshotSync();
+		const recordsById = new Map(snapshot.records.map((record) => [record.id, record]));
+		const anchors = [];
+		for (const record of snapshot.records) if (record.anchor !== void 0) anchors.push({
+			anchor: normalizeAnchorPath(record.anchor.path),
+			record
+		});
+		anchors.sort((a, b) => b.anchor.length - a.anchor.length);
+		this.anchors.length = 0;
+		this.anchors.push(...anchors);
+		for (const [id] of this.connections) {
+			const record = recordsById.get(id);
+			if (record === void 0 || this.connectionBindings.get(id) !== bindingKey(record)) this.detach(id);
+		}
+	}
+	async openFor(record) {
+		const existing = this.connections.get(record.id);
+		if (existing !== void 0 && this.connectionBindings.get(record.id) === bindingKey(record)) return existing;
+		const inFlight = this.opening.get(record.id);
+		if (inFlight !== void 0) return inFlight;
+		const expectedBinding = bindingKey(record);
+		const provider = this.providers.get(record.provider.id);
+		if (provider === void 0) return void 0;
+		const opening = (async () => {
+			await provider.validate(record);
+			const opened = await provider.open(record, {
+				signal: this.lifecycleAbort.signal,
+				logger: this.options.logger
+			});
+			const current = await this.ledger.get(record.id);
+			if (this.closed || current === void 0 || bindingKey(current) !== expectedBinding || this.providers.get(record.provider.id) !== provider) {
+				await this.closeConnection(opened);
+				return;
+			}
+			const replaced = this.connections.get(record.id);
+			if (replaced !== void 0 && replaced !== opened) await this.closeConnection(replaced);
+			this.connections.set(record.id, opened);
+			this.connectionBindings.set(record.id, expectedBinding);
+			return opened;
+		})();
+		this.opening.set(record.id, opening);
+		opening.finally(() => {
+			if (this.opening.get(record.id) === opening) this.opening.delete(record.id);
+		}).catch(() => void 0);
+		return opening;
+	}
+	fromNamespace(key) {
+		if (!this.isReady()) return void 0;
+		const route = this.codec.decode(key);
+		if (route === void 0) return void 0;
+		const resolution = this.resolveRoute(route);
+		return resolution === void 0 ? void 0 : {
+			...resolution,
+			rawKey: route.path
+		};
+	}
+	fromAnchor(cwd) {
+		if (!this.isReady() || cwd === void 0 || cwd === "") return void 0;
+		for (const { anchor, record } of this.anchors) if (isPathUnderAnchor(anchor, cwd)) return this.connections.get(record.id);
+	}
+	resolveRoute(route) {
+		if (!this.isReady()) return void 0;
+		const record = this.ledger.snapshotSync().records.find((candidate) => candidate.id === route.workspaceId);
+		if (record === void 0) return void 0;
+		const connection = this.connections.get(record.id);
+		if (connection === void 0) return void 0;
+		return {
+			connection,
+			rawKey: route.path
+		};
+	}
+	/** Async compatibility entry used by older adapters that already hold a detached record. */
+	async ensureOpen(record, signal) {
+		if (this.closed) return void 0;
+		return awaitWithSignal(this.openFor(record), signal);
+	}
+	/** All currently cached connections (for lifecycle/teardown). */
+	connectionsSnapshot() {
+		return [...this.connections.values()];
+	}
+	/** Close every cached and in-flight connection and release both subscriptions. */
+	async closeAll() {
+		if (this.closed && this.opening.size === 0 && this.closing.size === 0 && this.connections.size === 0) return;
+		this.closed = true;
+		this.ready = false;
+		this.lifecycleAbort.abort();
+		this.ledgerDisposer?.();
+		this.providerDisposer?.();
+		this.ledgerDisposer = void 0;
+		this.providerDisposer = void 0;
+		const openings = [...this.opening.values()];
+		const connections = [...this.connections.values()];
+		this.connections.clear();
+		this.connectionBindings.clear();
+		await Promise.allSettled(openings);
+		await Promise.allSettled(connections.map((connection) => this.closeConnection(connection)));
+		await Promise.allSettled([...this.closing]);
+		this.opening.clear();
+	}
+	/** reindex() only updates synchronous ownership, so this handler also closes and reopens resources after ledger commits. */
+	handleLedgerChange(change) {
+		const previousBindings = new Map(this.connectionBindings);
+		this.reindex();
+		if (change.type === "removed") {
+			this.detach(change.record.id);
+			return;
+		}
+		if (change.type === "updated" || change.type === "renamed") {
+			if (previousBindings.get(change.record.id) !== bindingKey(change.record)) this.reopen(change.record.id);
+			return;
+		}
+		if (change.type === "created") {
+			if (this.ready) this.reopen(change.record.id);
+			return;
+		}
+		for (const record of change.records) if (this.ready && this.providers.has(record.provider.id) && !this.connections.has(record.id)) this.reopen(record.id);
+	}
+	/** openFor() cannot observe provider lifecycle events itself, so this handler invalidates unregisters and preopens later registrations. */
+	handleProviderChange(change) {
+		if (change.type === "unregistered") {
+			for (const record of this.ledger.snapshotSync().records) if (record.provider.id === change.provider.manifest.id) this.detach(record.id);
+			return;
+		}
+		if (!this.ready) return;
+		for (const record of this.ledger.snapshotSync().records) if (record.provider.id === change.provider.manifest.id) this.reopen(record.id);
+	}
+	/** openFor() reuses an in-flight promise, so reopen waits for stale work before retrying the current record. */
+	reopen(id) {
+		const pending = this.opening.get(id);
+		this.detach(id);
+		(async () => {
+			if (pending !== void 0) await pending.catch(() => void 0);
+			if (!this.closed) await this.openById(id).catch((error) => this.options.logger?.warn?.("workspace reopen failed", error));
+		})();
+	}
+	/** reindex() cannot await resource release, so detach removes routing synchronously and tracks close completion separately. */
+	detach(id) {
+		const connection = this.connections.get(id);
+		this.connections.delete(id);
+		this.connectionBindings.delete(id);
+		if (connection !== void 0) this.closeConnection(connection);
+	}
+	/** WorkspaceConnection.close() alone is not tracked, so closeConnection lets closeAll await invalidation work already in progress. */
+	closeConnection(connection) {
+		const closing = connection.close().catch((error) => {
+			this.options.logger?.warn?.("workspace connection close failed", error);
+		});
+		this.closing.add(closing);
+		closing.finally(() => this.closing.delete(closing));
+		return closing;
+	}
+};
+/** WorkspaceRecord.updatedAt changes on every edit, so router invalidation needs a stable binding-only key instead. */
+function bindingKey(record) {
+	return JSON.stringify({
+		provider: record.provider,
+		location: record.location
+	});
+}
+/** openFor() is shared by callers, so a caller signal must cancel only its wait rather than the shared provider open. */
+function awaitWithSignal(promise, signal) {
+	if (signal === void 0) return promise;
+	if (signal.aborted) return Promise.reject(abortError());
+	return new Promise((resolve, reject) => {
+		const onAbort = () => reject(abortError());
+		signal.addEventListener("abort", onAbort, { once: true });
+		promise.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
+	});
+}
+/** awaitWithSignal() needs a consistent AbortError, which Error() alone cannot identify by name. */
+function abortError() {
+	const error = /* @__PURE__ */ new Error("Workspace open aborted");
+	error.name = "AbortError";
+	return error;
+}
+//#endregion
+//#region src/base/registry.ts
+/** Duplicate / incompatible registration error. */
+var ProviderRegistrationError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ProviderRegistrationError";
+	}
+};
+/** In-memory provider registry (process-wide singleton by default). */
+var WorkspaceProviderRegistry = class {
+	providers = /* @__PURE__ */ new Map();
+	listeners = /* @__PURE__ */ new Set();
+	/** Register a provider and return a disposer that only removes that exact registration. */
+	register(provider) {
+		const id = provider.manifest.id;
+		const existing = this.providers.get(id);
+		if (existing !== void 0) {
+			if (!(existing.manifest.version === provider.manifest.version && existing.manifest.apiVersion === provider.manifest.apiVersion)) throw new ProviderRegistrationError(`provider '${id}' already registered (${existing.manifest.version}, api ${existing.manifest.apiVersion}); refusing incompatible duplicate`);
+			return () => {};
+		}
+		this.providers.set(id, provider);
+		this.emit({
+			type: "registered",
+			provider
+		});
+		let disposed = false;
+		return () => {
+			if (disposed) return;
+			disposed = true;
+			if (this.providers.get(id) !== provider) return;
+			this.providers.delete(id);
+			this.emit({
+				type: "unregistered",
+				provider
+			});
+		};
+	}
+	/** Look up a provider by id. */
+	get(id) {
+		return this.providers.get(id);
+	}
+	/**
+	* Remove a provider by id, whoever registered it.
+	*
+	* Ownership-unsafe by construction: callers that registered a provider must
+	* use the disposer returned by register() instead, otherwise teardown can
+	* delete a provider owned by another plugin. Kept for whole-registry
+	* operations (tests, process-level resets).
+	*/
+	unregister(id) {
+		const provider = this.providers.get(id);
+		if (provider === void 0) return;
+		this.providers.delete(id);
+		this.emit({
+			type: "unregistered",
+			provider
+		});
+	}
+	/** All registered providers. */
+	list() {
+		return [...this.providers.values()];
+	}
+	/** Subscribe must expose both registration and removal, which the old registration-only listener could not report. */
+	subscribe(listener) {
+		this.listeners.add(listener);
+		let disposed = false;
+		return () => {
+			if (disposed) return;
+			disposed = true;
+			this.listeners.delete(listener);
+		};
+	}
+	/** True when a provider id is registered. */
+	has(id) {
+		return this.providers.has(id);
+	}
+	/** Static identity of a registered provider (for manifests / UI). */
+	manifestOf(id) {
+		return this.providers.get(id)?.manifest;
+	}
+	/** register() cannot safely repeat listener isolation for both lifecycle directions, so emit centralizes it. */
+	emit(change) {
+		for (const listener of [...this.listeners]) try {
+			listener(change);
+		} catch {}
+	}
+};
+//#endregion
+export { decodeLegacySshKey as a, defaultNamespaceCodec as c, WFS_SCHEME as i, encodeRoute as l, WorkspaceProviderRegistry as n, decodeWfsKey as o, LedgerWorkspaceRouter as r, decodeWorkspaceId as s, ProviderRegistrationError as t, encodeWorkspaceId as u };