@dyyz1993/codenomad 0.15.0

package/dist/workspaces/runtime.js

@@ -0,0 +1,366 @@
+import { spawn, spawnSync } from "child_process";
+import { existsSync, statSync } from "fs";
+import path from "path";
+import { buildSpawnSpec, buildWslSignalSpec } from "./spawn";
+const SENSITIVE_ENV_KEY = /(PASSWORD|TOKEN|SECRET)/i;
+const WSL_PID_MARKER = "__CODENOMAD_WSL_PID__:";
+function redactEnvironment(env) {
+    const redacted = {};
+    for (const [key, value] of Object.entries(env)) {
+        if (value === undefined) {
+            redacted[key] = value;
+            continue;
+        }
+        redacted[key] = SENSITIVE_ENV_KEY.test(key) ? "[REDACTED]" : value;
+    }
+    return redacted;
+}
+export class WorkspaceRuntime {
+    constructor(eventBus, logger) {
+        this.eventBus = eventBus;
+        this.logger = logger;
+        this.processes = new Map();
+    }
+    async launch(options) {
+        this.validateFolder(options.folder);
+        const logLevel = typeof options.logLevel === "string" ? options.logLevel.toUpperCase() : "DEBUG";
+        const args = ["serve", "--port", "0", "--print-logs", "--log-level", logLevel];
+        const env = { ...process.env, ...(options.environment ?? {}) };
+        let exitResolve = null;
+        const exitPromise = new Promise((resolveExit) => {
+            exitResolve = resolveExit;
+        });
+        // Store recent output for debugging - keep last 50 lines from each stream
+        const MAX_OUTPUT_LINES = 50;
+        const recentStdout = [];
+        const recentStderr = [];
+        const getLastOutput = () => {
+            const combined = [];
+            if (recentStderr.length > 0) {
+                combined.push("Error Stream");
+                combined.push(...recentStderr.slice(-10));
+            }
+            if (recentStdout.length > 0) {
+                combined.push("Output Stream");
+                combined.push(...recentStdout.slice(-10));
+            }
+            return combined.join("\n");
+        };
+        return new Promise((resolve, reject) => {
+            const propagatedEnvKeys = Object.keys(options.environment ?? {});
+            const spec = buildSpawnSpec(options.binaryPath, args, {
+                cwd: options.folder,
+                env,
+                propagateEnvKeys: propagatedEnvKeys,
+                wslPidMarker: WSL_PID_MARKER,
+            });
+            const commandLine = [spec.command, ...spec.args].join(" ");
+            this.logger.info({
+                workspaceId: options.workspaceId,
+                folder: options.folder,
+                binary: options.binaryPath,
+                spawnCommand: spec.command,
+                commandLine,
+            }, "Launching OpenCode process");
+            this.logger.debug({
+                workspaceId: options.workspaceId,
+                spawnArgs: spec.args,
+            }, "OpenCode spawn args");
+            this.logger.trace({
+                workspaceId: options.workspaceId,
+                env: redactEnvironment(env),
+            }, "OpenCode spawn environment");
+            const detached = process.platform !== "win32";
+            const child = spawn(spec.command, spec.args, {
+                cwd: spec.cwd,
+                env: spec.env,
+                stdio: ["ignore", "pipe", "pipe"],
+                detached,
+                ...spec.options,
+            });
+            const managed = {
+                child,
+                requestedStop: false,
+                ...(spec.wsl ? { wsl: { distro: spec.wsl.distro, linuxPid: null } } : {}),
+            };
+            this.processes.set(options.workspaceId, managed);
+            let stdoutBuffer = "";
+            let stderrBuffer = "";
+            let portFound = false;
+            let warningTimer = null;
+            const startWarningTimer = () => {
+                warningTimer = setInterval(() => {
+                    this.logger.warn({ workspaceId: options.workspaceId }, "Workspace runtime has not reported a port yet");
+                }, 10000);
+            };
+            const stopWarningTimer = () => {
+                if (warningTimer) {
+                    clearInterval(warningTimer);
+                    warningTimer = null;
+                }
+            };
+            startWarningTimer();
+            const cleanupStreams = () => {
+                stopWarningTimer();
+                child.stdout?.removeAllListeners();
+                child.stderr?.removeAllListeners();
+            };
+            const handleExit = (code, signal) => {
+                this.logger.info({ workspaceId: options.workspaceId, code, signal }, "OpenCode process exited");
+                this.processes.delete(options.workspaceId);
+                cleanupStreams();
+                child.removeListener("error", handleError);
+                child.removeListener("exit", handleExit);
+                const exitInfo = {
+                    workspaceId: options.workspaceId,
+                    code,
+                    signal,
+                    requested: managed.requestedStop,
+                };
+                if (exitResolve) {
+                    exitResolve(exitInfo);
+                    exitResolve = null;
+                }
+                if (!portFound) {
+                    const recentOutput = getLastOutput().trim();
+                    const reason = recentOutput || stderrBuffer || `Process exited with code ${code}`;
+                    reject(new Error(reason));
+                }
+                else {
+                    options.onExit?.(exitInfo);
+                }
+            };
+            const handleError = (error) => {
+                cleanupStreams();
+                child.removeListener("exit", handleExit);
+                this.processes.delete(options.workspaceId);
+                this.logger.error({ workspaceId: options.workspaceId, err: error }, "Workspace runtime error");
+                if (exitResolve) {
+                    exitResolve({ workspaceId: options.workspaceId, code: null, signal: null, requested: managed.requestedStop });
+                    exitResolve = null;
+                }
+                reject(error);
+            };
+            child.on("error", handleError);
+            child.on("exit", handleExit);
+            child.stdout?.on("data", (data) => {
+                const text = data.toString();
+                stdoutBuffer += text;
+                const lines = stdoutBuffer.split("\n");
+                stdoutBuffer = lines.pop() ?? "";
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (!trimmed)
+                        continue;
+                    if (managed.wsl && trimmed.startsWith(WSL_PID_MARKER)) {
+                        const linuxPid = Number.parseInt(trimmed.slice(WSL_PID_MARKER.length), 10);
+                        if (Number.isFinite(linuxPid) && linuxPid > 0) {
+                            managed.wsl.linuxPid = linuxPid;
+                            this.logger.debug({ workspaceId: options.workspaceId, linuxPid }, "Captured WSL OpenCode PID");
+                        }
+                        continue;
+                    }
+                    recentStdout.push(trimmed);
+                    if (recentStdout.length > MAX_OUTPUT_LINES) {
+                        recentStdout.shift();
+                    }
+                    this.emitLog(options.workspaceId, "info", line);
+                    if (!portFound) {
+                        const portMatch = line.match(/opencode server listening on http:\/\/.+:(\d+)/i);
+                        if (portMatch) {
+                            portFound = true;
+                            stopWarningTimer();
+                            child.removeListener("error", handleError);
+                            const port = parseInt(portMatch[1], 10);
+                            this.logger.info({ workspaceId: options.workspaceId, port }, "Workspace runtime allocated port");
+                            resolve({ pid: child.pid, port, exitPromise, getLastOutput });
+                        }
+                    }
+                }
+            });
+            child.stderr?.on("data", (data) => {
+                const text = data.toString();
+                stderrBuffer += text;
+                const lines = stderrBuffer.split("\n");
+                stderrBuffer = lines.pop() ?? "";
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (!trimmed)
+                        continue;
+                    recentStderr.push(trimmed);
+                    if (recentStderr.length > MAX_OUTPUT_LINES) {
+                        recentStderr.shift();
+                    }
+                    this.emitLog(options.workspaceId, "error", line);
+                }
+            });
+        });
+    }
+    async stop(workspaceId) {
+        const managed = this.processes.get(workspaceId);
+        if (!managed)
+            return;
+        managed.requestedStop = true;
+        const child = managed.child;
+        this.logger.info({ workspaceId }, "Stopping OpenCode process");
+        const pid = child.pid;
+        if (!pid) {
+            this.logger.warn({ workspaceId }, "Workspace process missing PID; cannot stop");
+            return;
+        }
+        const isAlreadyExited = () => child.exitCode !== null || child.signalCode !== null;
+        const tryKillPosixGroup = (signal) => {
+            try {
+                // Negative PID targets the process group (POSIX).
+                process.kill(-pid, signal);
+                return true;
+            }
+            catch (error) {
+                const err = error;
+                if (err?.code === "ESRCH") {
+                    return true;
+                }
+                this.logger.debug({ workspaceId, pid, err }, "Failed to signal POSIX process group");
+                return false;
+            }
+        };
+        const tryKillSinglePid = (signal) => {
+            try {
+                process.kill(pid, signal);
+                return true;
+            }
+            catch (error) {
+                const err = error;
+                if (err?.code === "ESRCH") {
+                    return true;
+                }
+                this.logger.debug({ workspaceId, pid, err }, "Failed to signal workspace PID");
+                return false;
+            }
+        };
+        const tryTaskkill = (force) => {
+            const args = ["/PID", String(pid), "/T"];
+            if (force) {
+                args.push("/F");
+            }
+            try {
+                const result = spawnSync("taskkill", args, { encoding: "utf8" });
+                const exitCode = result.status;
+                if (exitCode === 0) {
+                    return true;
+                }
+                // If the PID is already gone, treat it as success.
+                const stderr = (result.stderr ?? "").toString().toLowerCase();
+                const stdout = (result.stdout ?? "").toString().toLowerCase();
+                const combined = `${stdout}\n${stderr}`;
+                if (combined.includes("not found") || combined.includes("no running instance") || combined.includes("process") && combined.includes("not")) {
+                    return true;
+                }
+                this.logger.debug({ workspaceId, pid, exitCode, stderr: result.stderr, stdout: result.stdout }, "taskkill failed");
+                return false;
+            }
+            catch (error) {
+                this.logger.debug({ workspaceId, pid, err: error }, "taskkill failed to execute");
+                return false;
+            }
+        };
+        const trySignalWslProcess = (signal) => {
+            if (process.platform !== "win32" || !managed.wsl?.linuxPid) {
+                return false;
+            }
+            try {
+                const spec = buildWslSignalSpec(managed.wsl.distro, managed.wsl.linuxPid, signal);
+                const result = spawnSync(spec.command, spec.args, { encoding: "utf8" });
+                const exitCode = result.status;
+                if (exitCode === 0) {
+                    return true;
+                }
+                const stderr = (result.stderr ?? "").toString().toLowerCase();
+                const stdout = (result.stdout ?? "").toString().toLowerCase();
+                const combined = `${stdout}\n${stderr}`;
+                if (combined.includes("no such process") || combined.includes("not found")) {
+                    return true;
+                }
+                this.logger.debug({ workspaceId, pid, linuxPid: managed.wsl.linuxPid, distro: managed.wsl.distro, exitCode, stderr: result.stderr, stdout: result.stdout }, "WSL kill failed");
+                return false;
+            }
+            catch (error) {
+                this.logger.debug({ workspaceId, pid, linuxPid: managed.wsl.linuxPid, distro: managed.wsl.distro, err: error }, "WSL kill failed to execute");
+                return false;
+            }
+        };
+        const sendStopSignal = (signal) => {
+            if (process.platform === "win32") {
+                // WSL-backed launches need a Linux signal first because the tracked Windows PID belongs to wsl.exe.
+                if (!trySignalWslProcess(signal)) {
+                    // Fallback to the Windows process tree rooted at pid. Use /F only for escalation.
+                    tryTaskkill(signal === "SIGKILL");
+                }
+                return;
+            }
+            // Prefer process-group signaling so wrapper launchers (bun/node) don't orphan the real server.
+            const groupOk = tryKillPosixGroup(signal);
+            if (!groupOk) {
+                // Fallback to direct PID kill.
+                tryKillSinglePid(signal);
+            }
+        };
+        await new Promise((resolve, reject) => {
+            let escalationTimer = null;
+            const cleanup = () => {
+                child.removeListener("exit", onExit);
+                child.removeListener("error", onError);
+                if (escalationTimer) {
+                    clearTimeout(escalationTimer);
+                    escalationTimer = null;
+                }
+            };
+            const onExit = () => {
+                cleanup();
+                resolve();
+            };
+            const onError = (error) => {
+                cleanup();
+                reject(error);
+            };
+            if (isAlreadyExited()) {
+                this.logger.debug({ workspaceId, exitCode: child.exitCode, signal: child.signalCode }, "Process already exited");
+                cleanup();
+                resolve();
+                return;
+            }
+            child.once("exit", onExit);
+            child.once("error", onError);
+            this.logger.debug({ workspaceId, pid, detached: process.platform !== "win32" }, "Sending SIGTERM to workspace process (tree/group)");
+            sendStopSignal("SIGTERM");
+            escalationTimer = setTimeout(() => {
+                escalationTimer = null;
+                if (isAlreadyExited()) {
+                    this.logger.debug({ workspaceId, pid }, "Workspace exited before SIGKILL escalation");
+                    return;
+                }
+                this.logger.warn({ workspaceId, pid }, "Process did not stop after SIGTERM, escalating");
+                sendStopSignal("SIGKILL");
+            }, 2000);
+        });
+    }
+    emitLog(workspaceId, level, message) {
+        const entry = {
+            workspaceId,
+            timestamp: new Date().toISOString(),
+            level,
+            message: message.trim(),
+        };
+        this.eventBus.publish({ type: "workspace.log", entry });
+    }
+    validateFolder(folder) {
+        const resolved = path.resolve(folder);
+        if (!existsSync(resolved)) {
+            throw new Error(`Folder does not exist: ${resolved}`);
+        }
+        const stats = statSync(resolved);
+        if (!stats.isDirectory()) {
+            throw new Error(`Path is not a directory: ${resolved}`);
+        }
+    }
+}

package/dist/workspaces/spawn.js

@@ -0,0 +1,219 @@
+import { spawnSync } from "child_process";
+import path from "path";
+export const WINDOWS_CMD_EXTENSIONS = new Set([".cmd", ".bat"]);
+export const WINDOWS_POWERSHELL_EXTENSIONS = new Set([".ps1"]);
+const VERSION_REGEX = /([0-9]+\.[0-9]+\.[0-9A-Za-z.-]+)/;
+const WSL_UNC_PATH_REGEX = /^\\\\wsl(?:\.localhost|\$)\\([^\\/]+)(?:[\\/](.*))?$/i;
+const WSL_PATH_ENV_KEYS = new Set(["OPENCODE_CONFIG_DIR", "NODE_EXTRA_CA_CERTS"]);
+export function parseWslUncPath(input) {
+    const normalized = input.trim().replace(/\//g, "\\");
+    const match = normalized.match(WSL_UNC_PATH_REGEX);
+    if (!match) {
+        return null;
+    }
+    const distro = match[1] ?? "";
+    const remainder = match[2] ?? "";
+    const segments = remainder.split(/\\+/).filter((segment) => segment.length > 0);
+    return {
+        distro,
+        linuxPath: segments.length > 0 ? `/${segments.join("/")}` : "/",
+    };
+}
+export function resolveWslWorkingDirectory(folder, distro) {
+    const wslFolder = parseWslUncPath(folder);
+    if (wslFolder) {
+        return wslFolder.distro.toLowerCase() === distro.toLowerCase() ? { kind: "linux", path: wslFolder.linuxPath } : null;
+    }
+    const windowsFolder = normalizeWindowsPath(folder);
+    return windowsFolder ? { kind: "windows", path: windowsFolder } : null;
+}
+export function buildWindowsSpawnSpec(binaryPath, args, options = {}) {
+    const wslPath = parseWslUncPath(binaryPath);
+    if (wslPath) {
+        return buildWslSpawnSpec(wslPath, args, options);
+    }
+    const extension = path.extname(binaryPath).toLowerCase();
+    if (WINDOWS_CMD_EXTENSIONS.has(extension)) {
+        const comspec = process.env.ComSpec || "cmd.exe";
+        // cmd.exe requires the full command as a single string.
+        // Using the ""<script> <args>"" pattern ensures paths with spaces are handled.
+        const commandLine = `""${binaryPath}" ${args.join(" ")}"`;
+        return {
+            command: comspec,
+            args: ["/d", "/s", "/c", commandLine],
+            options: { windowsVerbatimArguments: true },
+            cwd: options.cwd,
+            env: options.env,
+        };
+    }
+    if (WINDOWS_POWERSHELL_EXTENSIONS.has(extension)) {
+        // powershell.exe ships with Windows. (pwsh may not.)
+        return {
+            command: "powershell.exe",
+            args: ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", binaryPath, ...args],
+            options: {},
+            cwd: options.cwd,
+            env: options.env,
+        };
+    }
+    return {
+        command: binaryPath,
+        args,
+        options: {},
+        cwd: options.cwd,
+        env: options.env,
+    };
+}
+export function buildSpawnSpec(binaryPath, args, options = {}) {
+    if (process.platform !== "win32") {
+        return {
+            command: binaryPath,
+            args,
+            options: {},
+            cwd: options.cwd,
+            env: options.env,
+        };
+    }
+    return buildWindowsSpawnSpec(binaryPath, args, options);
+}
+export function buildWslSignalSpec(distro, linuxPid, signal) {
+    return {
+        command: "wsl.exe",
+        args: ["--distribution", distro, "--exec", "kill", signal === "SIGKILL" ? "-KILL" : "-TERM", String(linuxPid)],
+        options: {},
+        wsl: { distro },
+    };
+}
+export function probeBinaryVersion(binaryPath) {
+    if (!binaryPath) {
+        return { valid: false, error: "Missing binary path" };
+    }
+    try {
+        const spec = buildSpawnSpec(binaryPath, ["--version"]);
+        const result = spawnSync(spec.command, spec.args, {
+            encoding: "utf8",
+            cwd: spec.cwd,
+            env: spec.env,
+            windowsVerbatimArguments: Boolean(spec.options.windowsVerbatimArguments),
+        });
+        if (result.error) {
+            return { valid: false, error: result.error.message };
+        }
+        if (result.status !== 0) {
+            const stderr = result.stderr?.trim();
+            const stdout = result.stdout?.trim();
+            const combined = stderr || stdout;
+            const error = combined ? `Exited with code ${result.status}: ${combined}` : `Exited with code ${result.status}`;
+            return { valid: false, error };
+        }
+        const stdoutLines = String(result.stdout ?? "")
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0);
+        const stderrLines = String(result.stderr ?? "")
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0);
+        // Prefer stdout; fall back to stderr (some tools report version there).
+        const reported = stdoutLines[0] ?? stderrLines[0];
+        if (!reported) {
+            return { valid: true };
+        }
+        const versionMatch = reported.match(VERSION_REGEX);
+        const version = versionMatch?.[1];
+        return { valid: true, version, reported };
+    }
+    catch (error) {
+        return { valid: false, error: error instanceof Error ? error.message : String(error) };
+    }
+}
+function buildWslSpawnSpec(wslPath, args, options) {
+    const workingDirectory = options.cwd ? resolveWslWorkingDirectory(options.cwd, wslPath.distro) : undefined;
+    if (options.cwd && !workingDirectory) {
+        throw new Error(`Unable to translate workspace folder for WSL binary in distro "${wslPath.distro}": ${options.cwd}`);
+    }
+    const wslArgs = ["--distribution", wslPath.distro];
+    const shouldWrapWithShell = Boolean(options.wslPidMarker) || workingDirectory?.kind === "windows";
+    if (!shouldWrapWithShell && workingDirectory?.kind === "linux") {
+        wslArgs.push("--cd", workingDirectory.path);
+    }
+    if (shouldWrapWithShell) {
+        const launchScript = buildWslLaunchScript(workingDirectory ?? undefined, options.wslPidMarker);
+        wslArgs.push("--exec", "sh", "-lc", launchScript, "codenomad-wsl-launch");
+        if (workingDirectory) {
+            wslArgs.push(workingDirectory.path);
+        }
+        wslArgs.push(wslPath.linuxPath, ...args);
+    }
+    else {
+        wslArgs.push("--exec", wslPath.linuxPath, ...args);
+    }
+    return {
+        command: "wsl.exe",
+        args: wslArgs,
+        options: {},
+        env: buildWslEnvironment(options.env, options.propagateEnvKeys),
+        wsl: { distro: wslPath.distro, pidMarker: options.wslPidMarker },
+    };
+}
+function buildWslLaunchScript(workingDirectory, pidMarker) {
+    const steps = [];
+    if (pidMarker) {
+        steps.push(`printf '%s%s\\n' '${pidMarker}' "$$"`);
+    }
+    if (workingDirectory?.kind === "linux") {
+        steps.push('cd "$1"');
+        steps.push("shift");
+    }
+    else if (workingDirectory?.kind === "windows") {
+        steps.push('cd "$(wslpath -au "$1")"');
+        steps.push("shift");
+    }
+    steps.push('exec "$@"');
+    return steps.join(" && ");
+}
+function normalizeWindowsPath(input) {
+    const normalized = path.win32.normalize(input.trim().replace(/\//g, "\\"));
+    if (!normalized) {
+        return null;
+    }
+    if (/^[A-Za-z]:/.test(normalized) || normalized.startsWith("\\\\")) {
+        return normalized;
+    }
+    return null;
+}
+function buildWslEnvironment(env, propagateEnvKeys) {
+    if (!env) {
+        return env;
+    }
+    const keysToPropagate = Array.from(new Set([
+        ...(propagateEnvKeys ?? []).filter((key) => env[key] !== undefined),
+        ...Array.from(WSL_PATH_ENV_KEYS).filter((key) => env[key] !== undefined),
+    ]));
+    if (keysToPropagate.length === 0) {
+        return env;
+    }
+    const next = { ...env };
+    const entries = (next.WSLENV ?? "").split(":").filter((entry) => entry.length > 0);
+    const byName = new Map(entries.map((entry) => [entry.split("/")[0] ?? entry, entry]));
+    for (const key of keysToPropagate) {
+        const existingEntry = byName.get(key);
+        if (existingEntry) {
+            byName.set(key, ensureWslenvEntry(existingEntry, WSL_PATH_ENV_KEYS.has(key)));
+            continue;
+        }
+        byName.set(key, WSL_PATH_ENV_KEYS.has(key) ? `${key}/p` : key);
+    }
+    next.WSLENV = Array.from(byName.values()).join(":");
+    return next;
+}
+function ensureWslenvEntry(entry, requiresPathTranslation) {
+    if (!requiresPathTranslation) {
+        return entry;
+    }
+    const [name, rawFlags = ""] = entry.split("/");
+    if (rawFlags.includes("p")) {
+        return entry;
+    }
+    return rawFlags.length > 0 ? `${name}/${rawFlags}p` : `${name}/p`;
+}

package/dist/workspaces/worktree-directory.js

@@ -0,0 +1,74 @@
+import { realpath } from "fs/promises";
+import { listWorktrees, resolveRepoRoot } from "./git-worktrees";
+const WORKTREE_CACHE_TTL_MS = 2000;
+const worktreeCache = new Map();
+async function normalizeDirectoryPath(directory) {
+    const trimmed = (directory ?? "").trim();
+    if (!trimmed)
+        return "";
+    try {
+        return await realpath(trimmed);
+    }
+    catch {
+        return trimmed;
+    }
+}
+async function getCachedWorktrees(params) {
+    const cached = worktreeCache.get(params.workspaceId);
+    const now = Date.now();
+    if (cached && cached.expiresAt > now) {
+        return cached;
+    }
+    const { repoRoot } = await resolveRepoRoot(params.workspacePath, params.logger);
+    const worktrees = await listWorktrees({ repoRoot, workspaceFolder: params.workspacePath, logger: params.logger });
+    const entry = {
+        expiresAt: now + WORKTREE_CACHE_TTL_MS,
+        repoRoot,
+        worktrees: await Promise.all(worktrees.map(async (wt) => ({
+            slug: wt.slug,
+            directory: wt.directory,
+            normalizedDirectory: await normalizeDirectoryPath(wt.directory),
+        }))),
+    };
+    worktreeCache.set(params.workspaceId, entry);
+    return entry;
+}
+export async function resolveWorktreeDirectory(params) {
+    const cached = await getCachedWorktrees({
+        workspaceId: params.workspaceId,
+        workspacePath: params.workspacePath,
+        logger: params.logger,
+    });
+    const match = cached.worktrees.find((wt) => wt.slug === params.worktreeSlug);
+    if (match) {
+        return match.directory;
+    }
+    worktreeCache.delete(params.workspaceId);
+    const refreshed = await getCachedWorktrees({
+        workspaceId: params.workspaceId,
+        workspacePath: params.workspacePath,
+        logger: params.logger,
+    });
+    return refreshed.worktrees.find((wt) => wt.slug === params.worktreeSlug)?.directory ?? null;
+}
+export async function resolveWorktreeSlugForDirectory(params) {
+    const target = await normalizeDirectoryPath(params.directory ?? "");
+    if (!target)
+        return null;
+    const cached = await getCachedWorktrees({
+        workspaceId: params.workspaceId,
+        workspacePath: params.workspacePath,
+        logger: params.logger,
+    });
+    const match = cached.worktrees.find((wt) => wt.normalizedDirectory === target);
+    if (match) {
+        return match.slug;
+    }
+    worktreeCache.delete(params.workspaceId);
+    const refreshed = await getCachedWorktrees({
+        workspaceId: params.workspaceId,
+        workspacePath: params.workspacePath,
+        logger: params.logger,
+    });
+    return refreshed.worktrees.find((wt) => wt.normalizedDirectory === target)?.slug ?? null;
+}