dsh-worktree-switch 0.0.0-stage → 0.2.1

package/lib/index.js

@@ -0,0 +1,717 @@
+import Schema from "@deepseek-ai/schemastery";
+import { lstat, realpath, stat } from "node:fs/promises";
+import { basename, isAbsolute, relative, resolve } from "node:path";
+/** Per-stream capture cap; worktree listings and status lines are small. */
+const MAX_OUTPUT_BYTES = 1048576;
+/**
+* Clear inherited repository selectors and config so the command reads the
+* checkout named by `cwd`, never one inherited from the Host's environment.
+* One entry per key: `undefined` removes the variable for the child.
+*/
+const GIT_ENV = Object.fromEntries([
+	"GIT_DIR",
+	"GIT_WORK_TREE",
+	"GIT_COMMON_DIR",
+	"GIT_INDEX_FILE",
+	"GIT_OBJECT_DIRECTORY",
+	"GIT_ALTERNATE_OBJECT_DIRECTORIES",
+	"GIT_CONFIG",
+	"GIT_CONFIG_PARAMETERS",
+	"GIT_CONFIG_COUNT",
+	"GIT_CEILING_DIRECTORIES",
+	"GIT_PREFIX",
+	"GIT_SHALLOW_FILE",
+	"GIT_GRAFT_FILE",
+	"GIT_REPLACE_REF_BASE",
+	"GIT_ATTR_SOURCE"
+].map((key) => [key, void 0]));
+/** A Git invocation that exited with a status the caller did not allow. */
+var GitFailure = class extends Error {
+	args;
+	result;
+	/**
+	* @param args - arguments after the executable, for diagnostics.
+	* @param result - the captured outcome.
+	*/
+	constructor(args, result) {
+		const detail = result.stderr.trim() === "" ? result.stdout.trim() : result.stderr.trim();
+		super(`git ${args.join(" ")} failed (exit ${result.exitCode})${detail === "" ? "" : `: ${detail}`}`);
+		this.args = args;
+		this.result = result;
+		this.name = "GitFailure";
+	}
+};
+/**
+* Run one Git command without a shell and await its termination.
+* @param ctx - Host context carrying the subprocess provider.
+* @param cwd - absolute directory the command runs in.
+* @param args - arguments after the executable.
+* @param options - cancellation, accepted exit statuses, and deadline.
+* @returns captured stdout, stderr, and exit status.
+* @throws {GitFailure} when the exit status is not allowed or the command was killed.
+*/
+async function runGit(ctx, cwd, args, options = {}) {
+	const deadline = AbortSignal.timeout(options.timeoutMs ?? 2e4);
+	const signal = options.signal === void 0 ? deadline : AbortSignal.any([options.signal, deadline]);
+	const allowed = options.allowedExitCodes ?? [0];
+	const argv = [
+		await ctx.subprocess.resolveExecutable("git", void 0, signal),
+		"-c",
+		"core.hooksPath=/dev/null",
+		"-c",
+		"core.fsmonitor=false",
+		...args
+	];
+	const child = ctx.subprocess.spawn({
+		argv,
+		cwd,
+		env: {
+			...GIT_ENV,
+			GIT_TERMINAL_PROMPT: "0",
+			GIT_LFS_SKIP_SMUDGE: "1",
+			GIT_NO_LAZY_FETCH: "1"
+		},
+		signal,
+		graceMs: 1500,
+		stdio: {
+			stdin: "ignore",
+			stdout: { maxBytes: MAX_OUTPUT_BYTES },
+			stderr: { maxBytes: MAX_OUTPUT_BYTES }
+		}
+	});
+	try {
+		const outcome = await child.done;
+		const result = {
+			stdout: child.collected.stdout?.readFrom(0).text ?? "",
+			stderr: child.collected.stderr?.readFrom(0).text ?? "",
+			exitCode: outcome.exitCode ?? -1
+		};
+		if (outcome.exitCode === null || !allowed.includes(outcome.exitCode)) throw new GitFailure(args, result);
+		return result;
+	} finally {
+		child.terminate();
+		await child.waitForExit();
+	}
+}
+/**
+* Resolve the repository root that contains `directory`.
+* @param ctx - Host context carrying the subprocess provider.
+* @param directory - absolute directory inside (or at) the checkout.
+* @param signal - caller cancellation.
+* @returns the canonical top-level directory Git reports.
+* @throws {GitFailure} when the directory is not inside a Git working tree.
+*/
+async function repositoryRoot(ctx, directory, signal) {
+	const result = await runGit(ctx, directory, ["rev-parse", "--show-toplevel"], {
+		signal,
+		allowedExitCodes: [0, 128]
+	});
+	if (result.exitCode !== 0) throw new GitFailure(["rev-parse", "--show-toplevel"], result);
+	return result.stdout.replace(/\r?\n$/, "");
+}
+/**
+* Resolve symlinks in a path that exists, falling back to the path as given.
+* @param path - absolute path.
+* @returns the canonical spelling when the path exists.
+*/
+async function canonicalPath(path) {
+	try {
+		return await realpath(path);
+	} catch {
+		return path;
+	}
+}
+/**
+* Parse `git worktree list --porcelain` output into its records.
+* @param stdout - the command's stdout.
+* @returns one record per reported checkout, in Git's order.
+*/
+function parseWorktreeList(stdout) {
+	const records = [];
+	let path;
+	let branch;
+	const flush = () => {
+		if (path === void 0) return;
+		records.push(branch === void 0 ? { path } : {
+			path,
+			branch
+		});
+		path = void 0;
+		branch = void 0;
+	};
+	for (const line of stdout.split("\n")) {
+		if (line === "") {
+			flush();
+			continue;
+		}
+		if (line.startsWith("worktree ")) path = line.slice(9);
+		else if (line.startsWith("branch refs/heads/")) branch = line.slice(18);
+	}
+	flush();
+	return records;
+}
+/**
+* List the worktree checkouts of one repository.
+* @param ctx - Host context carrying the subprocess provider.
+* @param root - repository root the command runs in.
+* @param signal - caller cancellation.
+* @returns every checkout Git reports for the repository.
+*/
+async function listWorktreeRecords(ctx, root, signal) {
+	return parseWorktreeList((await runGit(ctx, root, [
+		"worktree",
+		"list",
+		"--porcelain"
+	], { signal })).stdout);
+}
+/**
+* Count the changed and untracked files of one checkout.
+* @param ctx - Host context carrying the subprocess provider.
+* @param directory - checkout directory to inspect.
+* @param signal - caller cancellation.
+* @returns the number of `git status --porcelain` entries.
+*/
+async function changedFileCount(ctx, directory, signal) {
+	return (await runGit(ctx, directory, [
+		"status",
+		"--porcelain",
+		"--untracked-files=normal"
+	], { signal })).stdout.split("\n").filter((line) => line.trim() !== "").length;
+}
+// src/host/naming.ts
+/**
+* Names for the copy a session gets: lowercase words and a short suffix, so a
+* branch, a directory, a `git branch` row and this plugin's UI all read the
+* same. No prefix: the pool path already says where it lives.
+* @module dsh-worktree-switch/host/naming
+*/
+/** First word of a generated name. */
+const ADJECTIVES = [
+	"amber",
+	"brisk",
+	"calm",
+	"clever",
+	"crisp",
+	"eager",
+	"faint",
+	"fresh",
+	"gentle",
+	"happy",
+	"hollow",
+	"kind",
+	"lively",
+	"mellow",
+	"nimble",
+	"polite",
+	"quiet",
+	"rapid",
+	"ready",
+	"silent",
+	"soft",
+	"solid",
+	"steady",
+	"sunny",
+	"swift",
+	"tidy",
+	"vivid",
+	"warm",
+	"wise",
+	"young"
+];
+/** Second word of a generated name. */
+const NOUNS = [
+	"anchor",
+	"atlas",
+	"badger",
+	"birch",
+	"brook",
+	"cedar",
+	"comet",
+	"coral",
+	"delta",
+	"ember",
+	"fern",
+	"field",
+	"finch",
+	"glade",
+	"harbor",
+	"heron",
+	"island",
+	"lark",
+	"ledge",
+	"maple",
+	"meadow",
+	"otter",
+	"pebble",
+	"pine",
+	"quartz",
+	"river",
+	"shore",
+	"stone",
+	"trail",
+	"willow"
+];
+/**
+* Generate one candidate worktree name.
+* @param random - uniform source in `[0, 1)`; injectable for deterministic tests.
+* @returns a lowercase, hyphen-joined branch-safe name such as `quiet-harbor-3fa9`.
+*/
+function worktreeName(random = Math.random) {
+	const pick = (values) => {
+		return values[Math.min(values.length - 1, Math.floor(random() * values.length))] ?? values[0] ?? "copy";
+	};
+	const suffix = Math.min(65535, Math.floor(random() * 65536)).toString(16).padStart(4, "0");
+	return `${pick(ADJECTIVES)}-${pick(NOUNS)}-${suffix}`;
+}
+/** A pool entry name is exactly one path segment, as `git worktree` names it. */
+const NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+/**
+* Validate a worktree name received from the browser before it reaches Git.
+* @param value - candidate name.
+* @returns true for one plain path segment that Git also accepts as a branch.
+*/
+function isWorktreeName(value) {
+	return NAME_PATTERN.test(value) && !value.endsWith(".lock");
+}
+// src/host/handlers.ts
+/**
+* The plugin's host Remote face: the four verbs the browser half can call,
+* expressed against a live session and the checkouts on disk.
+*
+* This module is the seam the host tests drive directly. Everything below it —
+* Git, the worktree service, the sandbox policy it applies, and session
+* working-directory publication — belongs to the harness and is exercised by
+* its own tests.
+* @module dsh-worktree-switch/host/handlers
+*/
+/** Attempts at a fresh name before a creation failure becomes an error. */
+const CREATE_ATTEMPTS = 3;
+/** A failed verb, carrying the stable code the browser half switches on. */
+var WorktreeToggleError = class extends Error {
+	code;
+	details;
+	/**
+	* @param code - stable failure code.
+	* @param message - human-readable explanation.
+	* @param details - extra machine-readable facts.
+	*/
+	constructor(code, message, details = {}) {
+		super(message);
+		this.code = code;
+		this.details = details;
+		this.name = "WorktreeToggleError";
+	}
+};
+/** Normalize a browser-supplied path before any filesystem work. */
+function absolutePath(value) {
+	const trimmed = value.trim();
+	if (trimmed === "") throw new WorktreeToggleError("bad-request", "a project path is required");
+	return resolve(trimmed);
+}
+/**
+* The copy a session already runs in.
+*
+* A linked worktree is recognised from the checkout itself — its `.git` is a
+* file pointing back at the source repository, not a directory — rather than
+* from any configured pool path. The pool belongs to the harness worktree
+* service, so this plugin never needs a second copy of that setting: moving the
+* pool in the service's row config keeps every verb working.
+* @param current - the session's committed working directory.
+* @param repositoryRoot - canonical root of the project's repository.
+* @returns the copy's identity, or null when the directory is not one.
+*/
+async function worktreeAt(current, repositoryRoot) {
+	const path = await canonicalPath(current);
+	if (path === repositoryRoot) return null;
+	const inside = relative(repositoryRoot, path);
+	if (inside === "" || inside.startsWith("..") || isAbsolute(inside)) return null;
+	const name = basename(path);
+	if (!isWorktreeName(name)) return null;
+	try {
+		if (!(await lstat(`${path}/.git`)).isFile()) return null;
+	} catch {
+		return null;
+	}
+	return {
+		name,
+		path,
+		branch: name
+	};
+}
+/**
+* Build the host face.
+* @param ctx - Host context with `agents`, `worktrees`, `workingDirectory`, and `subprocess`.
+* @param options - resolved row config.
+* @returns the four verbs.
+*/
+function createWorktreeToggle(ctx, options) {
+	/** One in-flight preparation per session, so a double mount cannot create twice. */
+	const pending = /* @__PURE__ */ new Map();
+	const sessionOf = async (sessionId, signal) => {
+		signal?.throwIfAborted();
+		if (sessionId === "") throw new WorktreeToggleError("bad-request", "a session id is required");
+		const controller = ctx.get("sessionController");
+		if (controller !== void 0) {
+			const resolved = await controller.resolveAgent(sessionId);
+			if ("error" in resolved) throw new WorktreeToggleError(resolved.error.code, resolved.error.message, { sessionId });
+			return resolved.agent;
+		}
+		const agent = ctx.agents.get(sessionId);
+		if (agent === void 0) throw new WorktreeToggleError("session-not-found", `no live agent for session ${sessionId}`, { sessionId });
+		return agent;
+	};
+	/**
+	* Resolve the canonical root of the repository that contains a directory.
+	* Git reports the spelling of the path it was given; the worktree service
+	* publishes canonical paths, so both halves must agree on one spelling.
+	* @param directory - absolute directory inside the project.
+	* @param signal - caller cancellation.
+	* @returns the canonical repository root.
+	*/
+	const repositoryOf = async (directory, signal) => canonicalPath(await repositoryRoot(ctx, directory, signal));
+	const status = async (request, signal) => {
+		const agent = await sessionOf(request.sessionId, signal);
+		const startDirectory = agent.session.header.cwd ?? ctx.workingDirectory.get(agent.session);
+		let root;
+		try {
+			root = await repositoryOf(startDirectory, signal);
+		} catch (error) {
+			if (error instanceof GitFailure) return {
+				supported: false,
+				reason: "not-a-git-repository",
+				defaultEnabled: options.defaultEnabled
+			};
+			throw error;
+		}
+		const current = ctx.workingDirectory.get(agent.session);
+		signal?.throwIfAborted();
+		const sourceDirty = await changedFileCount(ctx, root, signal);
+		return {
+			supported: true,
+			repositoryRoot: root,
+			sessionWorktree: await worktreeAt(current, root),
+			sourceDirty,
+			defaultEnabled: options.defaultEnabled
+		};
+	};
+	const prepareOnce = async (request, signal) => {
+		const agent = await sessionOf(request.sessionId, signal);
+		const current = await status(request, signal);
+		if (!current.supported) throw new WorktreeToggleError("not-a-git-repository", "the session project is not inside a Git working tree");
+		if (current.sessionWorktree !== null) return {
+			state: "existing",
+			worktree: current.sessionWorktree,
+			repositoryRoot: current.repositoryRoot,
+			sourceDirty: current.sourceDirty
+		};
+		const working = ctx.workingDirectory.get(agent.session);
+		const workingProject = await repositoryOf(working, signal);
+		if (workingProject !== current.repositoryRoot) throw new WorktreeToggleError("session-moved", `this session now works in ${workingProject}, not in its project ${current.repositoryRoot}`, {
+			repositoryRoot: current.repositoryRoot,
+			workingProject
+		});
+		let lastFailure;
+		for (let attempt = 0; attempt < CREATE_ATTEMPTS; attempt += 1) {
+			signal?.throwIfAborted();
+			const name = worktreeName();
+			try {
+				const created = await ctx.worktrees.create(agent, {
+					name,
+					from: "HEAD"
+				}, signal);
+				return {
+					state: "created",
+					worktree: {
+						name: created.branch,
+						path: created.path,
+						branch: created.branch
+					},
+					repositoryRoot: created.repositoryRoot,
+					sourceDirty: current.sourceDirty
+				};
+			} catch (error) {
+				lastFailure = error;
+				const message = error instanceof Error ? error.message : String(error);
+				if (!/already exists|worktree branch already exists|worktree path already exists/i.test(message)) throw new WorktreeToggleError("worktree-create-failed", message, { name });
+			}
+		}
+		throw new WorktreeToggleError("worktree-create-failed", `could not allocate a free worktree name after ${CREATE_ATTEMPTS} attempts`, { cause: lastFailure instanceof Error ? lastFailure.message : String(lastFailure) });
+	};
+	const prepare = async (request, signal) => {
+		const running = pending.get(request.sessionId);
+		if (running !== void 0) return running;
+		const operation = prepareOnce(request, signal);
+		pending.set(request.sessionId, operation);
+		try {
+			return await operation;
+		} finally {
+			if (pending.get(request.sessionId) === operation) pending.delete(request.sessionId);
+		}
+	};
+	const list = async (request, signal) => {
+		const directory = absolutePath(request.path);
+		let root;
+		try {
+			root = await repositoryOf(directory, signal);
+		} catch (error) {
+			if (error instanceof GitFailure) return {
+				supported: false,
+				reason: "not-a-git-repository"
+			};
+			throw error;
+		}
+		const records = await listWorktreeRecords(ctx, root, signal);
+		const items = [];
+		for (const record of records) {
+			signal?.throwIfAborted();
+			const path = await canonicalPath(record.path);
+			if (path === root) continue;
+			const name = basename(path);
+			if (!isWorktreeName(name)) continue;
+			const branch = record.branch ?? name;
+			let createdAt = 0;
+			let prunable = true;
+			try {
+				const info = await stat(path);
+				createdAt = Math.trunc(info.birthtimeMs > 0 ? info.birthtimeMs : info.mtimeMs);
+				prunable = false;
+			} catch {}
+			const changedFiles = prunable ? 0 : await changedFileCount(ctx, path, signal);
+			items.push({
+				name,
+				path,
+				branch,
+				createdAt,
+				changedFiles,
+				prunable
+			});
+		}
+		items.sort((left, right) => right.createdAt - left.createdAt || left.name.localeCompare(right.name));
+		return {
+			supported: true,
+			repositoryRoot: root,
+			items
+		};
+	};
+	const discard = async (request, signal) => {
+		const directory = absolutePath(request.path);
+		if (!isWorktreeName(request.name)) throw new WorktreeToggleError("worktree-name-invalid", `not a worktree name: ${request.name}`);
+		const root = await repositoryOf(directory, signal);
+		const listed = await list({ path: directory }, signal);
+		if (!listed.supported) throw new WorktreeToggleError("not-a-git-repository", "the project is not inside a Git working tree");
+		const item = listed.items.find((entry) => entry.name === request.name);
+		if (item === void 0) throw new WorktreeToggleError("worktree-not-found", `no worktree named ${request.name} in ${root}`, {
+			name: request.name,
+			repositoryRoot: root
+		});
+		if (item.changedFiles > 0) throw new WorktreeToggleError("worktree-dirty", `${item.name} has ${item.changedFiles} uncommitted change(s); commit or discard them first`, {
+			name: item.name,
+			changedFiles: item.changedFiles
+		});
+		if (item.prunable) await runGit(ctx, root, ["worktree", "prune"], { signal });
+		else {
+			const removed = await runGit(ctx, root, [
+				"worktree",
+				"remove",
+				item.path
+			], {
+				signal,
+				allowedExitCodes: [0, 128]
+			});
+			if (removed.exitCode !== 0) throw new WorktreeToggleError("worktree-remove-failed", new GitFailure([
+				"worktree",
+				"remove",
+				item.path
+			], removed).message, {
+				name: item.name,
+				path: item.path
+			});
+		}
+		const deleted = await runGit(ctx, root, [
+			"branch",
+			"-D",
+			"--",
+			item.branch
+		], {
+			signal,
+			allowedExitCodes: [0, 1]
+		});
+		const branchGone = deleted.exitCode === 1 && /not found/i.test(deleted.stderr);
+		if (deleted.exitCode !== 0 && !branchGone) throw new WorktreeToggleError("worktree-remove-failed", new GitFailure([
+			"branch",
+			"-D",
+			item.branch
+		], deleted).message, {
+			name: item.name,
+			branch: item.branch
+		});
+		return {
+			removed: true,
+			name: item.name,
+			branch: item.branch,
+			path: item.path
+		};
+	};
+	return {
+		status,
+		prepare,
+		list,
+		discard
+	};
+}
+// src/host/routes.ts
+/** Absolute prefix every route below lives under. */
+const API_PREFIX = "/api/dsh-worktree-switch";
+/** Plugin id; the wire method prefix and the package name are the same string. */
+const PLUGIN_ID = "dsh-worktree-switch";
+/** One route per verb. */
+const ENDPOINTS = [
+	"status",
+	"prepare",
+	"list",
+	"discard"
+];
+/** A payload object with the named string field, or the failure to send back. */
+function requiredString(payload, field) {
+	const value = payload[field];
+	if (typeof value !== "string" || value.trim() === "") return { failure: new WorktreeToggleError("bad-request", `payload.${field} must be a non-empty string`) };
+	return { value };
+}
+/**
+* Decode the browser's `client-request` envelope.
+* @param body - parsed JSON body.
+* @returns the request, or null when the envelope is malformed.
+*/
+function readClientRequest(body) {
+	if (body === null || typeof body !== "object" || Array.isArray(body)) return null;
+	const record = body;
+	if (record.type !== "client-request") return null;
+	const { rpcId, method } = record;
+	if (typeof rpcId !== "string" || rpcId === "") return null;
+	if (typeof method !== "string" || method === "") return null;
+	const payload = record.payload;
+	return {
+		rpcId,
+		method,
+		payload: payload !== null && typeof payload === "object" && !Array.isArray(payload) ? payload : {}
+	};
+}
+/** A successful result. */
+function ok(value) {
+	return {
+		ok: true,
+		value
+	};
+}
+/** A failed result carrying the stable code. */
+function fail(code, message, details = {}) {
+	return {
+		ok: false,
+		error: {
+			code,
+			message,
+			details
+		}
+	};
+}
+/**
+* Dispatch one decoded verb.
+* @param toggle - the host face.
+* @param endpoint - the verb.
+* @param payload - its decoded payload.
+* @param signal - request cancellation.
+* @returns the wire result.
+*/
+async function dispatch(toggle, endpoint, payload, signal) {
+	try {
+		if (endpoint === "status") {
+			const sessionId = requiredString(payload, "sessionId");
+			if ("failure" in sessionId) throw sessionId.failure;
+			return ok(await toggle.status({ sessionId: sessionId.value }, signal));
+		}
+		if (endpoint === "prepare") {
+			const sessionId = requiredString(payload, "sessionId");
+			if ("failure" in sessionId) throw sessionId.failure;
+			return ok(await toggle.prepare({ sessionId: sessionId.value }, signal));
+		}
+		if (endpoint === "list") {
+			const path = requiredString(payload, "path");
+			if ("failure" in path) throw path.failure;
+			return ok(await toggle.list({ path: path.value }, signal));
+		}
+		const path = requiredString(payload, "path");
+		if ("failure" in path) throw path.failure;
+		const name = requiredString(payload, "name");
+		if ("failure" in name) throw name.failure;
+		return ok(await toggle.discard({
+			path: path.value,
+			name: name.value
+		}, signal));
+	} catch (error) {
+		if (error instanceof WorktreeToggleError) return fail(error.code, error.message, { ...error.details });
+		return fail("internal", error instanceof Error ? error.message : String(error));
+	}
+}
+/**
+* Register one exact route per verb on the shared `/api` channel.
+* @param ctx - Host context carrying `connection`.
+* @param toggle - the host face the routes call.
+*/
+function registerWorktreeRoutes(ctx, toggle) {
+	for (const endpoint of ENDPOINTS) ctx.effect(() => ctx.connection.fetch.register({
+		path: `${API_PREFIX}/${endpoint}`,
+		methods: ["POST"],
+		requestBody: "buffered",
+		async fetch(request) {
+			if (request.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase() !== "application/json") return new Response("content type must be application/json", { status: 415 });
+			let body;
+			try {
+				body = await request.json();
+			} catch {
+				return new Response("body is not JSON", { status: 400 });
+			}
+			const message = readClientRequest(body);
+			if (message === null) return new Response("invalid client-request message", { status: 400 });
+			if (message.method !== `dsh-worktree-switch/${endpoint}`) return Response.json({
+				type: "server-response",
+				rpcId: message.rpcId,
+				result: fail("bad-request", "RPC method does not match endpoint")
+			});
+			const result = await dispatch(toggle, endpoint, message.payload, request.signal);
+			return Response.json({
+				type: "server-response",
+				rpcId: message.rpcId,
+				result
+			});
+		}
+	}), `${PLUGIN_ID} ${endpoint} route`);
+}
+// src/index.ts
+/** Plugin id: package name, bundle row id, browser module id. */
+const name = "dsh-worktree-switch";
+/**
+* Services this plugin cannot work without.
+*
+* `worktrees` is provided by the row this bundle's patch inserts next to its
+* own, so Cordis holds this plugin until that row has mounted.
+*/
+const inject = [
+	"agents",
+	"connection",
+	"subprocess",
+	"worktrees",
+	"workingDirectory"
+];
+/** Schemastery schema for {@link Config}. */
+const Config = Schema.object({ defaultEnabled: Schema.boolean().default(true).description("Start a new session in a worktree copy until the user turns the switch off for that project.") });
+/**
+* Mount the host half.
+* @param ctx - Host context.
+* @param config - validated row config.
+*/
+function apply(ctx, config) {
+	registerWorktreeRoutes(ctx, createWorktreeToggle(ctx, { defaultEnabled: config.defaultEnabled }));
+}
+export { Config, apply, inject, name };
+
+//# sourceMappingURL=index.js.map