@ericsanchezok/synergy-workbench 0.0.0-stage → 3.1.1

package/dist/project/directories.js

@@ -0,0 +1,363 @@
+import path from "node:path";
+import fs from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { $ } from "bun";
+import { z } from "zod";
+import { NamedError } from "@ericsanchezok/synergy-util/error";
+import { Config } from "@ericsanchezok/synergy-harness/config/config";
+import { Scope } from "@ericsanchezok/synergy-harness/scope";
+import { Storage } from "@ericsanchezok/synergy-harness/storage/storage";
+import { StoragePath } from "@ericsanchezok/synergy-harness/storage/path";
+import { WorkspaceCatalog, WorkspaceBinding, WorkspaceLocation } from "@ericsanchezok/synergy-harness/workspace";
+import { WorkspaceAccess } from "@ericsanchezok/synergy-harness/workspace/access";
+export var ProjectDirectories;
+(function (ProjectDirectories) {
+    ProjectDirectories.Record = z
+        .object({
+        version: z.literal(1),
+        scopeID: z.string(),
+        revision: z.number().int().nonnegative(),
+        mainWorkspaceID: z.string().nullable(),
+        additionalWorkspaceIDs: z.array(z.string()),
+    })
+        .meta({ ref: "ProjectDirectoryConfiguration" });
+    ProjectDirectories.Folder = z
+        .object({
+        workspaceID: z.string(),
+        generation: z.number().int(),
+        path: z.string(),
+        available: z.boolean(),
+        git: z.boolean(),
+        unavailable: WorkspaceCatalog.Unavailable.Schema.optional(),
+    })
+        .meta({ ref: "ProjectFolder" });
+    ProjectDirectories.Result = ProjectDirectories.Record.extend({ folders: z.array(ProjectDirectories.Folder) }).meta({ ref: "ProjectDirectories" });
+    const Selection = z.object({
+        directories: z.array(z.string().min(1)).min(1).max(32),
+        mainDirectory: z.string().min(1),
+    });
+    ProjectDirectories.CreateInput = Selection.extend({ name: z.string().trim().min(1).max(120) }).meta({
+        ref: "ProjectCreateInput",
+    });
+    ProjectDirectories.UpdateInput = Selection.extend({ revision: z.number().int().nonnegative() }).meta({
+        ref: "ProjectDirectoriesUpdate",
+    });
+    ProjectDirectories.Created = z
+        .object({ scope: Scope.Info, directories: ProjectDirectories.Result, existing: z.boolean() })
+        .meta({ ref: "ProjectCreated" });
+    ProjectDirectories.Conflict = NamedError.create("ProjectDirectoriesConflict", z.object({ message: z.string() }));
+    ProjectDirectories.Invalid = NamedError.create("ProjectDirectoriesInvalid", z.object({ message: z.string() }));
+    async function isGit(directory) {
+        try {
+            const result = await $ `git rev-parse --show-toplevel`.cwd(directory).quiet().nothrow();
+            return result.exitCode === 0 && path.resolve(result.text().trim()) === directory;
+        }
+        catch {
+            return false;
+        }
+    }
+    ProjectDirectories.isGit = isGit;
+    async function validate(input) {
+        const source = WorkspaceLocation.source();
+        const locations = await Promise.all(input.directories.map(async (directory) => {
+            if (!path.isAbsolute(directory))
+                throw new ProjectDirectories.Invalid({ message: "Choose an absolute folder path." });
+            try {
+                const location = await source.identify(directory);
+                if (!(await fs.stat(location.path)).isDirectory())
+                    throw new ProjectDirectories.Invalid({ message: "Choose a folder." });
+                return location;
+            }
+            catch (error) {
+                if (error instanceof ProjectDirectories.Invalid)
+                    throw error;
+                throw new ProjectDirectories.Invalid({ message: `Cannot access folder: ${directory}. Check that it exists and is readable.` });
+            }
+        }));
+        const unique = [...new Map(locations.map((item) => [item.path, item])).values()];
+        if (!path.isAbsolute(input.mainDirectory))
+            throw new ProjectDirectories.Invalid({ message: "Choose an absolute main folder path." });
+        const main = await source.identify(input.mainDirectory).catch(() => {
+            throw new ProjectDirectories.Invalid({ message: "The main folder is unavailable. Choose a project folder again." });
+        });
+        if (!unique.some((item) => item.path === main.path))
+            throw new ProjectDirectories.Invalid({ message: "The main folder must be in the project." });
+        return { locations: unique, main: main.path, hostID: await source.hostID() };
+    }
+    async function create(input) {
+        const parsed = ProjectDirectories.CreateInput.parse(input);
+        const selection = await validate(parsed);
+        const owner = await findMainOwner(selection.main);
+        if (owner)
+            return { scope: owner, directories: await get(owner.id), existing: true };
+        const discovered = (await Scope.fromDirectory(selection.main, { persist: false })).scope;
+        if (discovered.type !== "project")
+            throw new ProjectDirectories.Invalid({ message: "A project folder is required." });
+        const existing = await Scope.fromID(discovered.id);
+        if (existing?.type === "project")
+            return { scope: existing, directories: await get(existing.id), existing: true };
+        const created = await WorkspaceAccess.exclusive(selection.locations.map((item) => item.path), async () => {
+            await revalidate(selection);
+            const mainOwner = await findMainOwner(selection.main);
+            if (mainOwner)
+                throw new ProjectDirectories.Conflict({ message: "This folder was just assigned to another project. Open that project." });
+            const concurrent = await Scope.fromID(discovered.id);
+            if (concurrent?.type === "project")
+                throw new ProjectDirectories.Conflict({ message: "This project was just created. Open the existing project." });
+            await Config.domainUpdate("general", { defaultSessionWorkspace: "main" }, { root: path.join(discovered.local.directory, ".synergy") });
+            return Storage.transaction(async () => {
+                const mainOwner = await findMainOwner(selection.main);
+                if (mainOwner)
+                    throw new ProjectDirectories.Conflict({ message: "This folder was just assigned to another project. Open that project." });
+                const concurrent = await Scope.fromID(discovered.id);
+                if (concurrent?.type === "project")
+                    throw new ProjectDirectories.Conflict({ message: "This project was just created. Open the existing project." });
+                const scope = await Scope.registerProject({ ...discovered, name: parsed.name });
+                const record = await save(scope.id, selection, 0);
+                return { scope, record };
+            });
+        });
+        return { scope: created.scope, directories: await describe(created.record), existing: false };
+    }
+    ProjectDirectories.create = create;
+    async function findMainOwner(directory) {
+        const scopes = await Scope.list();
+        const configs = await Storage.readMany(scopes.map((scope) => StoragePath.projectDirectories(scope.id)));
+        for (const [index, config] of configs.entries()) {
+            if (!config?.mainWorkspaceID)
+                continue;
+            const [workspace] = await WorkspaceCatalog.readMany([config.mainWorkspaceID]);
+            if (workspace?.binding.path === directory)
+                return scopes[index];
+        }
+    }
+    async function get(scopeID) {
+        const [stored] = await Storage.readMany([StoragePath.projectDirectories(scopeID)]);
+        const record = stored ? ProjectDirectories.Record.parse(stored) : await migrateProject(await Scope.resolve({ scopeID }));
+        return describe(record);
+    }
+    ProjectDirectories.get = get;
+    async function update(scopeID, input) {
+        const parsed = ProjectDirectories.UpdateInput.parse(input);
+        const current = await get(scopeID);
+        if (current.revision !== parsed.revision)
+            throw new ProjectDirectories.Conflict({ message: "Project folders changed. Reload before saving." });
+        const selection = await validate(parsed);
+        const all = await WorkspaceCatalog.list(scopeID);
+        const currentIDs = new Set(current.folders.map((item) => item.workspaceID));
+        const roots = [
+            ...new Set([
+                ...selection.locations.map((item) => item.path),
+                ...all
+                    .filter((item) => isActiveOnHost(item, selection.hostID) && (item.type === "git_worktree" || currentIDs.has(item.id)))
+                    .flatMap((item) => (item.binding.path ? [item.binding.path] : [])),
+            ]),
+        ];
+        const saved = await WorkspaceAccess.exclusive(roots, async () => {
+            await revalidate(selection);
+            return Storage.transaction(async () => {
+                const [latest] = await Storage.readMany([StoragePath.projectDirectories(scopeID)]);
+                if (latest?.revision !== parsed.revision)
+                    throw new ProjectDirectories.Conflict({ message: "Project folders changed. Reload before saving." });
+                const record = await save(scopeID, selection, parsed.revision, current);
+                return record;
+            });
+        });
+        return describe(saved);
+    }
+    ProjectDirectories.update = update;
+    async function revalidate(selection) {
+        for (const location of selection.locations) {
+            const current = await WorkspaceLocation.source().identify(location.path);
+            if (current.path !== location.path || current.physicalID !== location.physicalID)
+                throw new ProjectDirectories.Conflict({ message: "A selected folder changed. Choose it again before saving." });
+        }
+    }
+    function isActiveOnHost(item, hostID) {
+        return item.lifecycle === "active" && item.binding.state === "bound" && item.binding.hostID === hostID;
+    }
+    async function save(scopeID, selection, revision, previous) {
+        const folders = await Promise.all(selection.locations.map((location) => WorkspaceCatalog.register({
+            scopeID,
+            type: "directory",
+            hostID: selection.hostID,
+            ...location,
+        })));
+        const main = folders.find((item) => item.binding.path === selection.main);
+        const record = {
+            version: 1,
+            scopeID,
+            revision: revision + 1,
+            mainWorkspaceID: main.id,
+            additionalWorkspaceIDs: folders.filter((item) => item.id !== main.id).map((item) => item.id),
+        };
+        const oldIDs = new Set(previous?.folders.map((item) => item.workspaceID) ?? []);
+        const all = await WorkspaceCatalog.list(scopeID);
+        const selected = new Set(folders.map((item) => item.id));
+        for (const item of all) {
+            if (!isActiveOnHost(item, selection.hostID))
+                continue;
+            const origin = typeof item.metadata.originalCheckout === "string" ? item.metadata.originalCheckout : undefined;
+            if (!selected.has(item.id) && !oldIDs.has(item.id) && !(item.type === "git_worktree" && origin))
+                continue;
+            const grants = item.type === "git_worktree"
+                ? folders
+                    .filter((folder) => folder.binding.path !== origin && folder.id !== item.id)
+                    .map((folder) => folder.id)
+                : selected.has(item.id)
+                    ? folders.filter((folder) => folder.id !== item.id).map((folder) => folder.id)
+                    : [];
+            if (JSON.stringify(item.sharedWritableWorkspaceIDs) === JSON.stringify(grants))
+                continue;
+            const changed = await WorkspaceCatalog.setSharing(item.id, {
+                scopeID,
+                expectedRevision: item.revision,
+                workspaceIDs: grants,
+            });
+            Storage.afterCommit(() => WorkspaceCatalog.publishUpdated(changed));
+        }
+        for (const folder of await WorkspaceCatalog.readMany(folders.map((item) => item.id)))
+            if (folder)
+                Storage.afterCommit(() => WorkspaceCatalog.publishUpdated(folder));
+        await Storage.write(StoragePath.projectDirectories(scopeID), record);
+        return record;
+    }
+    async function describe(record) {
+        const ids = [...(record.mainWorkspaceID ? [record.mainWorkspaceID] : []), ...record.additionalWorkspaceIDs];
+        const records = await WorkspaceCatalog.readMany(ids);
+        const folders = await Promise.all(records.map(async (item, index) => {
+            if (!item)
+                return {
+                    workspaceID: ids[index],
+                    generation: 1,
+                    path: "",
+                    available: false,
+                    git: false,
+                    unavailable: new WorkspaceCatalog.Unavailable({
+                        workspaceID: ids[index],
+                        message: "The project folder binding is unavailable",
+                        reason: "binding_unavailable",
+                    }).toObject(),
+                };
+            const directory = item.binding.path ?? "";
+            let unavailable;
+            const available = await WorkspaceBinding.validate(item.id, record.scopeID).then(() => true, (error) => {
+                const parsed = WorkspaceCatalog.Unavailable.Schema.safeParse(error);
+                if (!parsed.success)
+                    throw error;
+                unavailable = parsed.data;
+                return false;
+            });
+            return {
+                workspaceID: item.id,
+                generation: item.binding.generation,
+                path: directory,
+                available,
+                git: available && (await isGit(directory)),
+                ...(unavailable ? { unavailable } : {}),
+            };
+        }));
+        return { ...record, folders };
+    }
+    async function migrateProject(scope) {
+        const [existing] = await Storage.readMany([StoragePath.projectDirectories(scope.id)]);
+        if (existing)
+            return ProjectDirectories.Record.parse(existing);
+        const hostID = await WorkspaceLocation.source().hostID();
+        const paths = scope.local ? [...new Set([scope.local.worktree, ...scope.local.sandboxes])] : [];
+        const worktrees = new Set();
+        if (scope.local) {
+            try {
+                const git = await $ `git worktree list --porcelain -z`.cwd(scope.local.worktree).quiet().nothrow();
+                if (git.exitCode === 0)
+                    for (const line of git.text().split("\0"))
+                        if (line.startsWith("worktree "))
+                            worktrees.add(path.resolve(line.slice(9)));
+            }
+            catch { }
+        }
+        if (scope.local)
+            worktrees.delete(path.resolve(scope.local.worktree));
+        const catalog = await WorkspaceCatalog.list(scope.id);
+        const retainedTrees = new Set(catalog.flatMap((record) => (record.type === "git_worktree" && record.binding.path ? [record.binding.path] : [])));
+        for (const directory of retainedTrees)
+            worktrees.add(directory);
+        const locate = (directory) => {
+            const requested = path.resolve(directory);
+            const retained = catalog.find((record) => record.binding.path === requested && record.binding.hostID === hostID && record.binding.state === "bound") ?? catalog.find((record) => record.type === "git_worktree" && record.binding.path === requested);
+            return retained
+                ? { path: requested, hostID: retained.binding.hostID }
+                : WorkspaceBinding.locateHistory(scope.id, directory);
+        };
+        const locations = await Promise.all(paths.map(locate));
+        if (locations[0])
+            worktrees.delete(locations[0].path);
+        const candidates = [
+            ...new Map(locations.filter((location) => !worktrees.has(location.path)).map((location) => [location.path, location])).values(),
+        ];
+        const historical = await Promise.all([...worktrees].filter((directory) => !retainedTrees.has(directory)).map(locate));
+        return Storage.transaction(async () => {
+            const [concurrent] = await Storage.readMany([StoragePath.projectDirectories(scope.id)]);
+            if (concurrent)
+                return ProjectDirectories.Record.parse(concurrent);
+            const retain = async (input) => {
+                const existing = await WorkspaceCatalog.findByLocation(input);
+                if (existing)
+                    return existing;
+                const retained = catalog.find((record) => record.type === "git_worktree" && record.binding.path === input.path);
+                return retained ? WorkspaceCatalog.get(retained.id, scope.id) : WorkspaceCatalog.register(input);
+            };
+            const records = await Promise.all(candidates.map((location) => retain({ scopeID: scope.id, type: "directory", ...location })));
+            for (const location of historical) {
+                await retain({
+                    scopeID: scope.id,
+                    type: "git_worktree",
+                    ...location,
+                    metadata: {
+                        originalCheckout: scope.local?.worktree,
+                        sourceWorkspaceID: records[0]?.id,
+                        worktreeID: "wt_" + createHash("sha256").update(location.path).digest("hex").slice(0, 16),
+                        name: path.basename(location.path),
+                    },
+                });
+            }
+            const byID = new Map((await WorkspaceCatalog.list(scope.id)).map((record) => [record.id, record]));
+            const migratedTrees = [...byID.values()].filter((item) => item.type === "git_worktree");
+            const folders = new Map([...records, ...migratedTrees].map((record) => [record.id, record]));
+            for (const folder of folders.values()) {
+                if (folder.lifecycle !== "active" || folder.binding.state !== "bound")
+                    continue;
+                const canShare = (other) => other.lifecycle === "active" &&
+                    other.binding.state === "bound" &&
+                    other.binding.hostID === folder.binding.hostID;
+                const grants = records
+                    .filter((other) => other.id !== folder.id && other.binding.path !== folder.metadata.originalCheckout && canShare(other))
+                    .map((other) => other.id);
+                const retainedGrants = folder.sharedWritableWorkspaceIDs.filter((id) => {
+                    const target = byID.get(id);
+                    return !target || canShare(target);
+                });
+                const workspaceIDs = [...new Set([...retainedGrants, ...grants])];
+                if (workspaceIDs.length === folder.sharedWritableWorkspaceIDs.length &&
+                    workspaceIDs.every((id, index) => id === folder.sharedWritableWorkspaceIDs[index]))
+                    continue;
+                const updated = await WorkspaceCatalog.setSharing(folder.id, {
+                    scopeID: scope.id,
+                    expectedRevision: folder.revision,
+                    workspaceIDs,
+                });
+                Storage.afterCommit(() => WorkspaceCatalog.publishUpdated(updated));
+            }
+            const record = {
+                version: 1,
+                scopeID: scope.id,
+                revision: 1,
+                mainWorkspaceID: records[0]?.id ?? null,
+                additionalWorkspaceIDs: records.slice(1).map((item) => item.id),
+            };
+            await Storage.write(StoragePath.projectDirectories(scope.id), record);
+            return record;
+        });
+    }
+    ProjectDirectories.migrateProject = migrateProject;
+})(ProjectDirectories || (ProjectDirectories = {}));