@rk0429/agentic-relay 19.10.1 → 19.12.0

package/dist/application/core-management-service.js

@@ -0,0 +1,687 @@
+import { cp, lstat, mkdir, mkdtemp, readdir, readFile, readlink, rename, rm, symlink, writeFile, } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { RelayError, ValidationError } from "../core/errors.js";
+import { buildManifest, computeFileHash, DEFAULT_BRANCH, DEFAULT_SOURCE, MANIFEST_FILENAME, isRequiredDistFile, readManifest, writeManifest, } from "../domain/core-manifest.js";
+export class CoreManagementService {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async setup(options) {
+        const agentsDir = this.agentsDir();
+        const source = options.source ?? DEFAULT_SOURCE;
+        const branch = options.branch ?? DEFAULT_BRANCH;
+        const state = await this.detectAgentsState();
+        let action;
+        let submoduleState = null;
+        if (state === "directory-with-manifest" && !options.force) {
+            throw new ValidationError("既にセットアップ済みです。relay core update を使用してください。", {
+                recoveryHint: "最新の dist を取り込みたい場合は relay core update を実行してください。再配置したい場合は relay core setup --force を使用してください。",
+            });
+        }
+        if (state === "submodule") {
+            submoduleState = await this.convertLegacySubmodule();
+            action = "converted-from-submodule";
+        }
+        else if (state === "directory-with-manifest") {
+            await this.prepareForceReinstall(agentsDir);
+            action = "force-reinstalled";
+        }
+        else if (state === "directory-without-manifest") {
+            action = "merged";
+        }
+        else {
+            await mkdir(agentsDir, { recursive: true });
+            action = "created";
+        }
+        let fetched = null;
+        let manifest = null;
+        try {
+            fetched = await this.fetchDist(source, branch);
+            const installResult = await this.installDistIntoAgents({
+                agentsDir,
+                conflictResolver: options.conflictResolver,
+                distDir: fetched.dir,
+            });
+            manifest = await buildManifest(fetched.dir, source, branch, fetched.commit, installResult.skippedFiles);
+            await writeManifest(agentsDir, manifest);
+            await this.ensureClaudeSymlink();
+            const backedUpFiles = [...installResult.backedUpFiles];
+            const conflicts = [...installResult.conflicts];
+            if (submoduleState) {
+                const restoreResult = await this.restoreBackedUpLocalFiles(submoduleState.backupDir);
+                backedUpFiles.push(...restoreResult.backedUpFiles);
+                conflicts.push(...restoreResult.conflicts);
+                await rm(submoduleState.backupDir, { recursive: true, force: true });
+                submoduleState = null;
+            }
+            return {
+                action,
+                agentsDir,
+                backedUpFiles,
+                conflicts,
+                manifest,
+                skippedFiles: installResult.skippedFiles,
+            };
+        }
+        catch (error) {
+            if (submoduleState) {
+                throw attachSubmoduleBackupHint(error, submoduleState.backupDir);
+            }
+            throw error;
+        }
+        finally {
+            if (fetched) {
+                await rm(fetched.dir, { recursive: true, force: true });
+            }
+        }
+    }
+    async update(options) {
+        const agentsDir = this.agentsDir();
+        const currentManifest = await readManifest(agentsDir);
+        if (!currentManifest) {
+            throw new ValidationError("マニフェストが見つかりません。relay core setup を先に実行してください。", {
+                recoveryHint: "relay core setup を実行して .agents を relay 管理下に置いてから relay core update を再実行してください。",
+            });
+        }
+        const source = options.source ?? currentManifest.source ?? DEFAULT_SOURCE;
+        const branch = options.branch ?? currentManifest.branch ?? DEFAULT_BRANCH;
+        const fetched = await this.fetchDist(source, branch);
+        try {
+            const distManifest = await buildManifest(fetched.dir, source, branch, fetched.commit);
+            const nextFiles = { ...currentManifest.files };
+            const added = [];
+            const updated = [];
+            const removedFromManifest = [];
+            const skipped = [];
+            const conflicts = [];
+            for (const [relativePath, distHash] of Object.entries(distManifest.files)) {
+                const targetPath = path.join(agentsDir, relativePath);
+                const trackedHash = currentManifest.files[relativePath];
+                const targetKind = await this.pathKind(targetPath);
+                if (trackedHash === undefined) {
+                    if (targetKind === "missing") {
+                        await this.copyEntry(path.join(fetched.dir, relativePath), targetPath);
+                        nextFiles[relativePath] = distHash;
+                        added.push(relativePath);
+                        continue;
+                    }
+                    const resolution = await this.resolveConflict(targetPath, relativePath, isRequiredDistFile(relativePath), options.conflictResolver);
+                    conflicts.push({ path: relativePath, resolution });
+                    if (resolution === "skip") {
+                        skipped.push(relativePath);
+                        continue;
+                    }
+                    if (resolution === "backup") {
+                        await this.backupExistingPath(targetPath);
+                    }
+                    await this.replaceEntryWithCopy(path.join(fetched.dir, relativePath), targetPath, {
+                        targetAlreadyMoved: resolution === "backup",
+                    });
+                    nextFiles[relativePath] = distHash;
+                    added.push(relativePath);
+                    continue;
+                }
+                if (distHash === trackedHash) {
+                    continue;
+                }
+                if (targetKind === "missing") {
+                    await this.copyEntry(path.join(fetched.dir, relativePath), targetPath);
+                    nextFiles[relativePath] = distHash;
+                    updated.push(relativePath);
+                    continue;
+                }
+                const localHash = await this.tryComputeFileHash(targetPath);
+                if (localHash === trackedHash) {
+                    await this.replaceEntryWithCopy(path.join(fetched.dir, relativePath), targetPath);
+                    nextFiles[relativePath] = distHash;
+                    updated.push(relativePath);
+                    continue;
+                }
+                const resolution = await this.resolveConflict(targetPath, relativePath, isRequiredDistFile(relativePath), options.conflictResolver);
+                conflicts.push({ path: relativePath, resolution });
+                if (resolution === "skip") {
+                    skipped.push(relativePath);
+                    continue;
+                }
+                if (resolution === "backup") {
+                    await this.backupExistingPath(targetPath);
+                }
+                await this.replaceEntryWithCopy(path.join(fetched.dir, relativePath), targetPath, {
+                    targetAlreadyMoved: resolution === "backup",
+                });
+                nextFiles[relativePath] = distHash;
+                updated.push(relativePath);
+            }
+            for (const relativePath of Object.keys(currentManifest.files)) {
+                if (distManifest.files[relativePath] !== undefined) {
+                    continue;
+                }
+                delete nextFiles[relativePath];
+                removedFromManifest.push(relativePath);
+            }
+            const nextManifest = {
+                ...currentManifest,
+                branch,
+                commit: fetched.commit,
+                files: sortRecord(nextFiles),
+                source,
+                updatedAt: new Date().toISOString(),
+            };
+            await writeManifest(agentsDir, nextManifest);
+            await this.ensureClaudeSymlink();
+            return {
+                added,
+                agentsDir,
+                conflicts,
+                manifest: nextManifest,
+                removedFromManifest,
+                skipped,
+                updated,
+            };
+        }
+        finally {
+            await rm(fetched.dir, { recursive: true, force: true });
+        }
+    }
+    async remove(options) {
+        const agentsDir = this.agentsDir();
+        const keepLocal = options.keepLocal ?? false;
+        const manifest = await readManifest(agentsDir);
+        const removedFiles = [];
+        const keptFiles = [];
+        let agentsDirRemoved = false;
+        let symlinkRemoved = false;
+        if (!manifest && keepLocal) {
+            throw new ValidationError("マニフェストがないため dist 由来ファイルとユーザーファイルを区別できません。relay core setup --force で再配置するか、--keep-local なしで全削除してください。", {
+                recoveryHint: "ローカルファイルを保持したい場合は relay core setup --force でマニフェストを再生成してください。全削除でよければ relay core remove を --keep-local なしで実行してください。",
+            });
+        }
+        if (manifest) {
+            for (const relativePath of Object.keys(manifest.files)) {
+                const targetPath = path.join(agentsDir, relativePath);
+                if ((await this.pathKind(targetPath)) === "missing") {
+                    continue;
+                }
+                await rm(targetPath, { recursive: true, force: true });
+                removedFiles.push(this.toWorkspaceRelative(targetPath));
+            }
+            const manifestPath = path.join(agentsDir, MANIFEST_FILENAME);
+            if ((await this.pathKind(manifestPath)) !== "missing") {
+                await rm(manifestPath, { force: true });
+                removedFiles.push(this.toWorkspaceRelative(manifestPath));
+            }
+        }
+        if (keepLocal) {
+            await this.collectKeptFiles(keptFiles);
+        }
+        else {
+            if ((await this.pathKind(agentsDir)) !== "missing") {
+                const existingFiles = await this.collectRelativeFiles(agentsDir);
+                for (const relativePath of existingFiles) {
+                    const workspacePath = this.toWorkspaceRelative(path.join(agentsDir, relativePath));
+                    if (!removedFiles.includes(workspacePath)) {
+                        removedFiles.push(workspacePath);
+                    }
+                }
+                await rm(agentsDir, { recursive: true, force: true });
+                agentsDirRemoved = true;
+            }
+            symlinkRemoved = await this.removeClaudeSymlink();
+            if (symlinkRemoved) {
+                removedFiles.push(".claude");
+            }
+        }
+        if (keepLocal) {
+            keptFiles.sort();
+        }
+        else {
+            removedFiles.sort();
+        }
+        return {
+            agentsDirRemoved,
+            keptFiles,
+            removedFiles,
+            symlinkRemoved,
+        };
+    }
+    agentsDir() {
+        return path.join(this.deps.cwd, ".agents");
+    }
+    claudePath() {
+        return path.join(this.deps.cwd, ".claude");
+    }
+    async detectAgentsState() {
+        const agentsDir = this.agentsDir();
+        const agentsKind = await this.pathKind(agentsDir);
+        if (agentsKind === "missing") {
+            return "not-found";
+        }
+        if (agentsKind !== "directory") {
+            throw new ValidationError(`Expected .agents to be a directory, found ${agentsKind}.`, {
+                recoveryHint: "Remove or rename the existing .agents entry, then rerun relay core setup.",
+            });
+        }
+        if (await this.isLegacySubmodule(agentsDir)) {
+            return "submodule";
+        }
+        if ((await this.pathKind(path.join(agentsDir, MANIFEST_FILENAME))) !== "missing") {
+            return "directory-with-manifest";
+        }
+        return "directory-without-manifest";
+    }
+    async isLegacySubmodule(agentsDir) {
+        const gitFilePath = path.join(agentsDir, ".git");
+        if ((await this.pathKind(gitFilePath)) !== "file") {
+            return false;
+        }
+        const gitFileContent = await readFile(gitFilePath, "utf8").catch(() => "");
+        if (!gitFileContent.startsWith("gitdir:")) {
+            return false;
+        }
+        if ((await this.pathKind(path.join(this.deps.cwd, ".git", "modules", ".agents"))) !== "missing") {
+            return true;
+        }
+        const gitmodulesPath = path.join(this.deps.cwd, ".gitmodules");
+        if ((await this.pathKind(gitmodulesPath)) === "missing") {
+            return false;
+        }
+        const gitmodules = await readFile(gitmodulesPath, "utf8");
+        return gitmodules.includes('[submodule ".agents"]') || gitmodules.includes("path = .agents");
+    }
+    async prepareForceReinstall(agentsDir) {
+        try {
+            const existingManifest = await readManifest(agentsDir);
+            if (existingManifest) {
+                await this.removeManifestTrackedFiles(existingManifest);
+            }
+        }
+        catch (error) {
+            if (!(error instanceof ValidationError)) {
+                throw error;
+            }
+        }
+        await rm(path.join(agentsDir, MANIFEST_FILENAME), { force: true });
+    }
+    async removeManifestTrackedFiles(manifest) {
+        const agentsDir = this.agentsDir();
+        for (const relativePath of Object.keys(manifest.files)) {
+            await rm(path.join(agentsDir, relativePath), { recursive: true, force: true });
+        }
+    }
+    async convertLegacySubmodule() {
+        const agentsDir = this.agentsDir();
+        const backupDir = await mkdtemp(path.join(os.tmpdir(), "agentic-relay-core-backup-"));
+        const localFiles = await this.collectSubmoduleLocalFiles();
+        for (const relativePath of localFiles) {
+            const sourcePath = path.join(agentsDir, relativePath);
+            if ((await this.pathKind(sourcePath)) === "missing") {
+                continue;
+            }
+            await this.copyEntry(sourcePath, path.join(backupDir, relativePath));
+        }
+        await this.executeGit(["submodule", "deinit", "-f", ".agents"], "deinitialize the .agents submodule");
+        await this.executeGit(["rm", "-f", ".agents"], "remove the .agents submodule");
+        await rm(path.join(this.deps.cwd, ".git", "modules", ".agents"), {
+            recursive: true,
+            force: true,
+        });
+        await this.removeAgentsSectionFromGitmodules();
+        await rm(agentsDir, { recursive: true, force: true });
+        await mkdir(agentsDir, { recursive: true });
+        return { backupDir };
+    }
+    async collectSubmoduleLocalFiles() {
+        const outputs = await Promise.all([
+            this.executeGit(["-C", ".agents", "ls-files", "--others", "--exclude-standard"], "list untracked files in .agents"),
+            this.executeGit(["-C", ".agents", "diff", "--name-only"], "list unstaged changes in .agents"),
+            this.executeGit(["-C", ".agents", "diff", "--name-only", "--cached"], "list staged changes in .agents"),
+            this.executeGit(["-C", ".agents", "ls-files", "--others", "--ignored", "--exclude-standard"], "list ignored local files in .agents"),
+        ]);
+        const files = new Set();
+        for (const output of outputs) {
+            for (const line of output.stdout.split(/\r?\n/)) {
+                const trimmed = normalizeRelativePath(line.trim());
+                if (trimmed.length > 0) {
+                    files.add(trimmed);
+                }
+            }
+        }
+        return [...files].sort();
+    }
+    async removeAgentsSectionFromGitmodules() {
+        const gitmodulesPath = path.join(this.deps.cwd, ".gitmodules");
+        if ((await this.pathKind(gitmodulesPath)) === "missing") {
+            return;
+        }
+        const content = await readFile(gitmodulesPath, "utf8");
+        const lines = content.split(/\r?\n/);
+        const kept = [];
+        for (let index = 0; index < lines.length; index += 1) {
+            const currentLine = lines[index] ?? "";
+            if (currentLine.trim() !== '[submodule ".agents"]') {
+                kept.push(currentLine);
+                continue;
+            }
+            index += 1;
+            while (index < lines.length && !lines[index].trim().startsWith("[submodule ")) {
+                index += 1;
+            }
+            index -= 1;
+        }
+        const nextContent = trimTrailingBlankLines(kept).join("\n");
+        if (nextContent.trim().length === 0) {
+            const result = await this.deps.processExecutor.execute({
+                args: ["rm", "-f", ".gitmodules"],
+                command: "git",
+                cwd: this.deps.cwd,
+                env: this.deps.env,
+            });
+            if (result.exitCode !== 0) {
+                await rm(gitmodulesPath, { force: true });
+                return;
+            }
+            await rm(gitmodulesPath, { force: true });
+            return;
+        }
+        await writeFile(gitmodulesPath, `${nextContent}\n`, "utf8");
+    }
+    async fetchDist(source, branch) {
+        const tempDir = await mkdtemp(path.join(os.tmpdir(), "agentic-relay-core-dist-"));
+        try {
+            // Try git archive first (efficient — no VCS metadata)
+            const archiveResult = await this.tryGitArchive(source, branch, tempDir);
+            if (archiveResult) {
+                return { commit: archiveResult.commit, dir: tempDir };
+            }
+            // Fallback: git clone --depth 1 (GitHub disables git archive --remote)
+            await this.executeGit(["clone", "--depth", "1", "--branch", branch, "--single-branch", source, tempDir], `clone ${source}#${branch}`);
+            const revParse = await this.executeGit(["-C", tempDir, "rev-parse", "HEAD"], `resolve the commit for ${source}#${branch}`);
+            const commit = revParse.stdout.trim();
+            if (commit.length === 0) {
+                throw new RelayError("CORE_DIST_FETCH_FAILED", `Failed to resolve a commit hash for ${source}#${branch}.`);
+            }
+            await rm(path.join(tempDir, ".git"), { recursive: true, force: true });
+            return { commit, dir: tempDir };
+        }
+        catch (error) {
+            await rm(tempDir, { recursive: true, force: true });
+            throw error;
+        }
+    }
+    async tryGitArchive(source, branch, targetDir) {
+        try {
+            // git archive --remote produces a tar stream without .git metadata
+            // Use positional parameters to avoid command injection via source/branch
+            const result = await this.deps.processExecutor.execute({
+                command: "bash",
+                args: ["-c", 'git archive --remote="$1" "$2" | tar -x -C "$3"', "--", source, branch, targetDir],
+                cwd: this.deps.cwd,
+                env: this.deps.env,
+            });
+            if (result.exitCode !== 0) {
+                return null;
+            }
+            // git archive doesn't give us the commit hash; resolve it via ls-remote
+            const lsRemote = await this.deps.processExecutor.execute({
+                command: "git",
+                args: ["ls-remote", source, `refs/heads/${branch}`],
+                cwd: this.deps.cwd,
+                env: this.deps.env,
+            });
+            if (lsRemote.exitCode !== 0 || lsRemote.stdout.trim().length === 0) {
+                return null;
+            }
+            const commit = lsRemote.stdout.trim().split(/\s/)[0] ?? "";
+            if (commit.length === 0) {
+                return null;
+            }
+            return { commit };
+        }
+        catch {
+            // git archive --remote not supported by this host — fall through to clone
+            return null;
+        }
+    }
+    async installDistIntoAgents(input) {
+        const relativePaths = await this.collectRelativeFiles(input.distDir);
+        const backedUpFiles = [];
+        const skippedFiles = [];
+        const conflicts = [];
+        for (const relativePath of relativePaths) {
+            const sourcePath = path.join(input.distDir, relativePath);
+            const targetPath = path.join(input.agentsDir, relativePath);
+            if ((await this.pathKind(targetPath)) === "missing") {
+                await this.copyEntry(sourcePath, targetPath);
+                continue;
+            }
+            const resolution = await this.resolveConflict(targetPath, relativePath, isRequiredDistFile(relativePath), input.conflictResolver);
+            conflicts.push({ path: relativePath, resolution });
+            if (resolution === "skip") {
+                skippedFiles.push(relativePath);
+                continue;
+            }
+            if (resolution === "backup") {
+                const backupPath = await this.backupExistingPath(targetPath);
+                backedUpFiles.push(this.toWorkspaceRelative(backupPath));
+            }
+            await this.replaceEntryWithCopy(sourcePath, targetPath, {
+                targetAlreadyMoved: resolution === "backup",
+            });
+        }
+        return { backedUpFiles, conflicts, skippedFiles };
+    }
+    async restoreBackedUpLocalFiles(backupDir) {
+        const relativePaths = await this.collectRelativeFiles(backupDir);
+        const backedUpFiles = [];
+        const conflicts = [];
+        for (const relativePath of relativePaths) {
+            const restoreTarget = path.join(this.agentsDir(), relativePath);
+            if ((await this.pathKind(restoreTarget)) !== "missing") {
+                const backupPath = await this.backupExistingPath(restoreTarget);
+                backedUpFiles.push(this.toWorkspaceRelative(backupPath));
+                conflicts.push({ path: relativePath, resolution: "backup" });
+            }
+            await this.copyEntry(path.join(backupDir, relativePath), restoreTarget);
+        }
+        return { backedUpFiles, conflicts };
+    }
+    async ensureClaudeSymlink() {
+        const claudePath = this.claudePath();
+        const claudeKind = await this.pathKind(claudePath);
+        if (claudeKind === "symlink") {
+            const currentTarget = await readlink(claudePath);
+            const resolvedTarget = path.resolve(path.dirname(claudePath), currentTarget);
+            if (resolvedTarget === this.agentsDir()) {
+                return;
+            }
+            await rm(claudePath, { force: true });
+        }
+        else if (claudeKind !== "missing") {
+            throw new ValidationError("既存の .claude がシムリンクではありません。", {
+                recoveryHint: ".claude を削除または移動してから relay core setup/update を再実行してください。",
+            });
+        }
+        await symlink(".agents", claudePath, process.platform === "win32" ? "junction" : "dir");
+    }
+    async removeClaudeSymlink() {
+        const claudePath = this.claudePath();
+        if ((await this.pathKind(claudePath)) !== "symlink") {
+            return false;
+        }
+        await rm(claudePath, { force: true });
+        return true;
+    }
+    async collectKeptFiles(keptFiles) {
+        const agentsDir = this.agentsDir();
+        if ((await this.pathKind(agentsDir)) === "directory") {
+            const relativePaths = await this.collectRelativeFiles(agentsDir);
+            for (const relativePath of relativePaths) {
+                keptFiles.push(this.toWorkspaceRelative(path.join(agentsDir, relativePath)));
+            }
+        }
+        if ((await this.pathKind(this.claudePath())) === "symlink") {
+            keptFiles.push(".claude");
+        }
+    }
+    async executeGit(args, action) {
+        const result = await this.deps.processExecutor.execute({
+            args,
+            command: "git",
+            cwd: this.deps.cwd,
+            env: this.deps.env,
+        });
+        if (result.exitCode === 0) {
+            return result;
+        }
+        const details = result.stderr.trim() || result.stdout.trim() || `exit code ${result.exitCode}`;
+        throw new RelayError("CORE_GIT_COMMAND_FAILED", `Failed to ${action}: ${details}`, {
+            causeData: { args, cwd: this.deps.cwd },
+            recoveryHint: "Ensure git is installed and the working tree is accessible.",
+        });
+    }
+    async resolveConflict(targetPath, relativePath, isRequired, conflictResolver) {
+        if (isRequired) {
+            return "backup";
+        }
+        if (!conflictResolver) {
+            return "overwrite";
+        }
+        const requested = await conflictResolver(targetPath, isRequired);
+        if (requested === "skip" && isRequired) {
+            return "backup";
+        }
+        if (requested === "skip" || requested === "overwrite" || requested === "backup") {
+            return requested;
+        }
+        throw new ValidationError(`Unsupported conflict resolution for ${relativePath}: ${String(requested)}`, {
+            recoveryHint: "Conflict resolvers must return overwrite, skip, or backup.",
+        });
+    }
+    async backupExistingPath(targetPath) {
+        const backupPath = await this.nextBackupPath(targetPath);
+        await rename(targetPath, backupPath);
+        return backupPath;
+    }
+    async nextBackupPath(targetPath) {
+        for (let index = 0;; index += 1) {
+            const candidate = `${targetPath}.bak${index === 0 ? "" : `.${index}`}`;
+            if ((await this.pathKind(candidate)) === "missing") {
+                return candidate;
+            }
+        }
+    }
+    async replaceEntryWithCopy(sourcePath, targetPath, options) {
+        if (!options?.targetAlreadyMoved) {
+            await rm(targetPath, { recursive: true, force: true });
+        }
+        await this.copyEntry(sourcePath, targetPath);
+    }
+    async copyEntry(sourcePath, targetPath) {
+        await mkdir(path.dirname(targetPath), { recursive: true });
+        await cp(sourcePath, targetPath, {
+            force: true,
+            recursive: true,
+            verbatimSymlinks: true,
+        });
+    }
+    async collectRelativeFiles(rootDir) {
+        if ((await this.pathKind(rootDir)) !== "directory") {
+            return [];
+        }
+        const files = [];
+        await this.collectRelativeFilesRecursive(rootDir, rootDir, files);
+        files.sort();
+        return files;
+    }
+    async collectRelativeFilesRecursive(rootDir, currentDir, files) {
+        const entries = await readdir(currentDir, { withFileTypes: true });
+        entries.sort((left, right) => left.name.localeCompare(right.name));
+        for (const entry of entries) {
+            const absolutePath = path.join(currentDir, entry.name);
+            const relativePath = normalizeRelativePath(path.relative(rootDir, absolutePath));
+            if (entry.isDirectory()) {
+                await this.collectRelativeFilesRecursive(rootDir, absolutePath, files);
+                continue;
+            }
+            if (relativePath.length > 0) {
+                files.push(relativePath);
+            }
+        }
+    }
+    async tryComputeFileHash(filePath) {
+        try {
+            return await computeFileHash(filePath);
+        }
+        catch {
+            return null;
+        }
+    }
+    async pathKind(targetPath) {
+        try {
+            const stats = await lstat(targetPath);
+            if (stats.isDirectory()) {
+                return "directory";
+            }
+            if (stats.isFile()) {
+                return "file";
+            }
+            if (stats.isSymbolicLink()) {
+                return "symlink";
+            }
+            return "other";
+        }
+        catch (error) {
+            if (isErrnoException(error) && error.code === "ENOENT") {
+                return "missing";
+            }
+            throw error;
+        }
+    }
+    toWorkspaceRelative(targetPath) {
+        const relativePath = normalizeRelativePath(path.relative(this.deps.cwd, targetPath));
+        return relativePath.length === 0 ? "." : relativePath;
+    }
+}
+function sortRecord(input) {
+    return Object.fromEntries(Object.entries(input).sort(([left], [right]) => left.localeCompare(right)));
+}
+function normalizeRelativePath(value) {
+    return value.split(path.sep).join("/").replace(/^\.\//, "");
+}
+function trimTrailingBlankLines(lines) {
+    let lastNonBlank = lines.length - 1;
+    while (lastNonBlank >= 0 && lines[lastNonBlank].trim().length === 0) {
+        lastNonBlank -= 1;
+    }
+    return lines.slice(0, lastNonBlank + 1);
+}
+function isErrnoException(error) {
+    return typeof error === "object" && error !== null && "code" in error;
+}
+function attachSubmoduleBackupHint(error, backupDir) {
+    const suffix = ` Legacy submodule backup was preserved at "${backupDir}".`;
+    const recoveryHint = `Recover local files from "${backupDir}" after resolving the setup failure.`;
+    if (error instanceof ValidationError) {
+        return new ValidationError(`${error.message}${suffix}`, {
+            causeData: error.causeData,
+            recoveryHint: error.recoveryHint
+                ? `${error.recoveryHint} ${recoveryHint}`
+                : recoveryHint,
+        });
+    }
+    if (error instanceof RelayError) {
+        return new RelayError(error.code, `${error.message}${suffix}`, {
+            causeData: error.causeData,
+            recoveryHint: error.recoveryHint
+                ? `${error.recoveryHint} ${recoveryHint}`
+                : recoveryHint,
+        });
+    }
+    return new RelayError("CORE_SETUP_FAILED", `relay core setup failed.${suffix}`, {
+        causeData: error,
+        recoveryHint,
+    });
+}
+//# sourceMappingURL=core-management-service.js.map