@hyperdrive.bot/fleet-server 0.3.99

package/dist/server/server/workspace-reconciliation-service.d.ts

@@ -0,0 +1,57 @@
+import type pino from "pino";
+import type { ProjectRegistry, WorkspaceRegistry, PersistedProjectRecord, PersistedWorkspaceRecord } from "./workspace-registry.js";
+import type { WorkspaceGitService } from "./workspace-git-service.js";
+export type ReconciliationChange = {
+    kind: "workspace_archived";
+    workspaceId: string;
+    directory: string;
+    reason: string;
+} | {
+    kind: "project_archived";
+    projectId: string;
+    directory: string;
+    reason: string;
+} | {
+    kind: "project_updated";
+    projectId: string;
+    directory: string;
+    fields: Partial<Pick<PersistedProjectRecord, "kind" | "displayName" | "rootPath" | "customName">>;
+} | {
+    kind: "workspace_updated";
+    workspaceId: string;
+    directory: string;
+    fields: Partial<Pick<PersistedWorkspaceRecord, "projectId" | "branch" | "kind">>;
+};
+export interface ReconciliationResult {
+    changesApplied: ReconciliationChange[];
+    durationMs: number;
+}
+export interface WorkspaceReconciliationServiceOptions {
+    projectRegistry: ProjectRegistry;
+    workspaceRegistry: WorkspaceRegistry;
+    logger: pino.Logger;
+    intervalMs?: number;
+    onChanges?: (changes: ReconciliationChange[]) => void;
+    workspaceGitService?: Pick<WorkspaceGitService, "getWorkspaceGitMetadata">;
+}
+export declare class WorkspaceReconciliationService {
+    private readonly projectRegistry;
+    private readonly workspaceRegistry;
+    private readonly logger;
+    private readonly intervalMs;
+    private readonly onChanges;
+    private readonly workspaceGitService;
+    private timer;
+    private running;
+    constructor(options: WorkspaceReconciliationServiceOptions);
+    start(): void;
+    stop(): void;
+    runOnce(): Promise<ReconciliationResult>;
+    private runSafe;
+    private reconcile;
+    private mergeDuplicateProjectsByRoot;
+    private mergeDuplicateProjectCustomName;
+    private reconcileProject;
+    private readWorkspaceGitMetadata;
+}
+//# sourceMappingURL=workspace-reconciliation-service.d.ts.map

package/dist/server/server/workspace-reconciliation-service.js

@@ -0,0 +1,278 @@
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+const DEFAULT_RECONCILE_INTERVAL_MS = 60000;
+function deriveWorkspaceKindFromMetadata(metadata) {
+    if (metadata.projectKind !== "git")
+        return "directory";
+    if (metadata.isWorktree)
+        return "worktree";
+    return "local_checkout";
+}
+function chooseCanonicalProject(projects) {
+    return [...projects].sort((left, right) => {
+        const leftRemote = left.projectId.startsWith("remote:");
+        const rightRemote = right.projectId.startsWith("remote:");
+        if (leftRemote !== rightRemote) {
+            return leftRemote ? -1 : 1;
+        }
+        const createdAt = Date.parse(left.createdAt) - Date.parse(right.createdAt);
+        if (createdAt !== 0) {
+            return createdAt;
+        }
+        return left.projectId.localeCompare(right.projectId);
+    })[0];
+}
+export class WorkspaceReconciliationService {
+    constructor(options) {
+        this.timer = null;
+        this.running = false;
+        this.projectRegistry = options.projectRegistry;
+        this.workspaceRegistry = options.workspaceRegistry;
+        this.logger = options.logger.child({ module: "workspace-reconciliation" });
+        this.intervalMs = options.intervalMs ?? DEFAULT_RECONCILE_INTERVAL_MS;
+        this.onChanges = options.onChanges ?? null;
+        this.workspaceGitService = options.workspaceGitService ?? null;
+    }
+    start() {
+        if (this.timer)
+            return;
+        this.logger.info({ intervalMs: this.intervalMs }, "Starting workspace reconciliation service");
+        this.timer = setInterval(() => void this.runSafe(), this.intervalMs);
+        // Run once immediately on start
+        void this.runSafe();
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+    async runOnce() {
+        return this.reconcile();
+    }
+    async runSafe() {
+        if (this.running)
+            return;
+        this.running = true;
+        try {
+            await this.reconcile();
+        }
+        catch (error) {
+            this.logger.error({ err: error }, "Reconciliation pass failed");
+        }
+        finally {
+            this.running = false;
+        }
+    }
+    async reconcile() {
+        const start = Date.now();
+        const changes = [];
+        const allProjects = await this.projectRegistry.list();
+        const allWorkspaces = await this.workspaceRegistry.list();
+        const activeProjects = allProjects.filter((p) => !p.archivedAt);
+        const activeWorkspaces = allWorkspaces.filter((w) => !w.archivedAt);
+        const workspacesByProject = new Map();
+        for (const workspace of activeWorkspaces) {
+            const list = workspacesByProject.get(workspace.projectId) ?? [];
+            list.push(workspace);
+            workspacesByProject.set(workspace.projectId, list);
+        }
+        // 1. Archive workspaces whose directories no longer exist
+        const missingWorkspaces = activeWorkspaces.filter((workspace) => !existsSync(workspace.cwd));
+        await Promise.all(missingWorkspaces.map(async (workspace) => {
+            const timestamp = new Date().toISOString();
+            await this.workspaceRegistry.archive(workspace.workspaceId, timestamp);
+            changes.push({
+                kind: "workspace_archived",
+                workspaceId: workspace.workspaceId,
+                directory: workspace.cwd,
+                reason: "directory_missing",
+            });
+            // Update the in-memory list for the project orphan check below
+            const siblings = workspacesByProject.get(workspace.projectId);
+            if (siblings) {
+                const updated = siblings.filter((w) => w.workspaceId !== workspace.workspaceId);
+                workspacesByProject.set(workspace.projectId, updated);
+            }
+        }));
+        // 2. Merge duplicate active project records that point at the same repo root.
+        await this.mergeDuplicateProjectsByRoot(activeProjects, workspacesByProject, changes);
+        // 3. Reconcile git metadata for active projects whose directories still exist.
+        //    Projects persist until explicitly removed, even when they currently have
+        //    zero active workspaces, so they still reconcile their own metadata.
+        //    Skip projects archived earlier in this pass (e.g. merged duplicates) so we
+        //    don't resurrect them by upserting a stale, non-archived copy.
+        const archivedProjectIds = new Set(changes
+            .filter((change) => change.kind === "project_archived")
+            .map((change) => change.projectId));
+        const projectsToReconcile = activeProjects.filter((project) => {
+            if (project.archivedAt)
+                return false;
+            if (archivedProjectIds.has(project.projectId))
+                return false;
+            if (!existsSync(project.rootPath))
+                return false;
+            return true;
+        });
+        await Promise.all(projectsToReconcile.map((project) => this.reconcileProject(project, workspacesByProject.get(project.projectId) ?? [], changes)));
+        if (changes.length > 0 && this.onChanges) {
+            this.onChanges(changes);
+        }
+        const result = { changesApplied: changes, durationMs: Date.now() - start };
+        if (changes.length > 0) {
+            this.logger.info({
+                changeCount: changes.length,
+                durationMs: result.durationMs,
+                changes,
+            }, "Workspace reconciliation applied changes");
+        }
+        return result;
+    }
+    async mergeDuplicateProjectsByRoot(activeProjects, workspacesByProject, changes) {
+        const projectsByRoot = new Map();
+        for (const project of activeProjects) {
+            if (project.kind !== "git") {
+                continue;
+            }
+            const rootKey = resolve(project.rootPath);
+            const group = projectsByRoot.get(rootKey) ?? [];
+            group.push(project);
+            projectsByRoot.set(rootKey, group);
+        }
+        for (const duplicates of projectsByRoot.values()) {
+            if (duplicates.length < 2) {
+                continue;
+            }
+            const canonical = chooseCanonicalProject(duplicates);
+            const duplicateProjects = duplicates.filter((project) => project.projectId !== canonical.projectId);
+            await this.mergeDuplicateProjectCustomName(canonical, duplicateProjects, changes);
+            await Promise.all(duplicateProjects.flatMap((project) => (workspacesByProject.get(project.projectId) ?? []).map(async (workspace) => {
+                const timestamp = new Date().toISOString();
+                const updatedWorkspace = {
+                    ...workspace,
+                    projectId: canonical.projectId,
+                    updatedAt: timestamp,
+                };
+                await this.workspaceRegistry.upsert(updatedWorkspace);
+                changes.push({
+                    kind: "workspace_updated",
+                    workspaceId: workspace.workspaceId,
+                    directory: workspace.cwd,
+                    fields: {
+                        projectId: canonical.projectId,
+                    },
+                });
+                const canonicalSiblings = workspacesByProject.get(canonical.projectId) ?? [];
+                canonicalSiblings.push(updatedWorkspace);
+                workspacesByProject.set(canonical.projectId, canonicalSiblings);
+            })));
+            for (const project of duplicateProjects) {
+                workspacesByProject.set(project.projectId, []);
+                const timestamp = new Date().toISOString();
+                await this.projectRegistry.archive(project.projectId, timestamp);
+                changes.push({
+                    kind: "project_archived",
+                    projectId: project.projectId,
+                    directory: project.rootPath,
+                    reason: "merged_duplicate",
+                });
+            }
+        }
+    }
+    async mergeDuplicateProjectCustomName(canonical, duplicateProjects, changes) {
+        if (canonical.customName) {
+            return;
+        }
+        const customName = duplicateProjects.find((project) => project.customName)?.customName ?? null;
+        if (!customName) {
+            return;
+        }
+        const timestamp = new Date().toISOString();
+        await this.projectRegistry.upsert({
+            ...canonical,
+            customName,
+            updatedAt: timestamp,
+        });
+        canonical.customName = customName;
+        changes.push({
+            kind: "project_updated",
+            projectId: canonical.projectId,
+            directory: canonical.rootPath,
+            fields: { customName },
+        });
+    }
+    async reconcileProject(project, siblings, changes) {
+        const directoryName = project.rootPath.split(/[\\/]/).findLast(Boolean) ?? project.rootPath;
+        const currentGit = await this.readWorkspaceGitMetadata(project.rootPath, directoryName);
+        const projectUpdates = {};
+        const mappedKind = currentGit.projectKind === "git" ? "git" : "non_git";
+        if (project.kind !== mappedKind) {
+            projectUpdates.kind = mappedKind;
+            projectUpdates.displayName = currentGit.projectDisplayName;
+        }
+        if (project.kind === "git" &&
+            currentGit.projectKind === "git" &&
+            project.displayName !== currentGit.projectDisplayName) {
+            projectUpdates.displayName = currentGit.projectDisplayName;
+        }
+        if (Object.keys(projectUpdates).length > 0) {
+            const timestamp = new Date().toISOString();
+            await this.projectRegistry.upsert({
+                ...project,
+                ...projectUpdates,
+                updatedAt: timestamp,
+            });
+            changes.push({
+                kind: "project_updated",
+                projectId: project.projectId,
+                directory: project.rootPath,
+                fields: projectUpdates,
+            });
+        }
+        const existingSiblings = siblings.filter((workspace) => existsSync(workspace.cwd));
+        await Promise.all(existingSiblings.map(async (workspace) => {
+            const wsDirName = workspace.cwd.split(/[\\/]/).findLast(Boolean) ?? workspace.cwd;
+            const wsGit = await this.readWorkspaceGitMetadata(workspace.cwd, wsDirName);
+            const expectedKind = deriveWorkspaceKindFromMetadata(wsGit);
+            const workspaceUpdates = {};
+            if (wsGit.projectKind === "git" && workspace.branch !== wsGit.currentBranch) {
+                workspaceUpdates.branch = wsGit.currentBranch;
+            }
+            if (workspace.kind !== expectedKind) {
+                workspaceUpdates.kind = expectedKind;
+            }
+            if (Object.keys(workspaceUpdates).length === 0) {
+                return;
+            }
+            const timestamp = new Date().toISOString();
+            await this.workspaceRegistry.upsert({
+                ...workspace,
+                ...workspaceUpdates,
+                updatedAt: timestamp,
+            });
+            changes.push({
+                kind: "workspace_updated",
+                workspaceId: workspace.workspaceId,
+                directory: workspace.cwd,
+                fields: workspaceUpdates,
+            });
+        }));
+    }
+    async readWorkspaceGitMetadata(cwd, directoryName) {
+        if (!this.workspaceGitService) {
+            return {
+                projectKind: "directory",
+                projectDisplayName: directoryName,
+                workspaceDisplayName: directoryName,
+                gitRemote: null,
+                isWorktree: false,
+                projectSlug: "untitled",
+                repoRoot: null,
+                currentBranch: null,
+                remoteUrl: null,
+            };
+        }
+        return this.workspaceGitService.getWorkspaceGitMetadata(cwd, { directoryName });
+    }
+}
+//# sourceMappingURL=workspace-reconciliation-service.js.map

package/dist/server/server/workspace-registry-bootstrap.d.ts

@@ -0,0 +1,13 @@
+import type { Logger } from "pino";
+import type { AgentStorage } from "./agent/agent-storage.js";
+import type { WorkspaceGitService } from "./workspace-git-service.js";
+import { type ProjectRegistry, type WorkspaceRegistry } from "./workspace-registry.js";
+export declare function bootstrapWorkspaceRegistries(options: {
+    paseoHome: string;
+    agentStorage: AgentStorage;
+    projectRegistry: ProjectRegistry;
+    workspaceRegistry: WorkspaceRegistry;
+    workspaceGitService: WorkspaceGitService;
+    logger: Logger;
+}): Promise<void>;
+//# sourceMappingURL=workspace-registry-bootstrap.d.ts.map

package/dist/server/server/workspace-registry-bootstrap.js

@@ -0,0 +1,121 @@
+import path from "node:path";
+import { classifyDirectoryForProjectMembership, generateWorkspaceId, } from "./workspace-registry-model.js";
+import { backfillWorkspaceIdForLegacyAgents } from "./migrations/backfill-workspace-id.migration.js";
+import { createPersistedProjectRecord, createPersistedWorkspaceRecord, } from "./workspace-registry.js";
+function minIsoDate(left, right) {
+    if (!left) {
+        return right;
+    }
+    if (!right) {
+        return left;
+    }
+    return Date.parse(left) <= Date.parse(right) ? left : right;
+}
+function maxIsoDate(left, right) {
+    if (!left) {
+        return right;
+    }
+    if (!right) {
+        return left;
+    }
+    return Date.parse(left) >= Date.parse(right) ? left : right;
+}
+function resolveAgentCreatedAt(record) {
+    return record.createdAt || record.updatedAt || new Date(0).toISOString();
+}
+function resolveAgentUpdatedAt(record) {
+    return record.lastActivityAt || record.updatedAt || record.createdAt || new Date(0).toISOString();
+}
+export async function bootstrapWorkspaceRegistries(options) {
+    const [projectsExists, workspacesExists] = await Promise.all([
+        options.projectRegistry.existsOnDisk(),
+        options.workspaceRegistry.existsOnDisk(),
+    ]);
+    await Promise.all([options.projectRegistry.initialize(), options.workspaceRegistry.initialize()]);
+    if (projectsExists && workspacesExists) {
+        await backfillWorkspaceIdForLegacyAgents(options);
+        return;
+    }
+    const existingWorkspaceIdsByCwd = new Map((await options.workspaceRegistry.list()).map((workspace) => [
+        path.resolve(workspace.cwd),
+        workspace.workspaceId,
+    ]));
+    const records = await options.agentStorage.list();
+    const activeRecords = records.filter((record) => !record.archivedAt);
+    const recordsByDirectoryKey = new Map();
+    const placements = await Promise.all(activeRecords.map(async (record) => {
+        const normalizedCwd = path.resolve(record.cwd);
+        const checkout = await options.workspaceGitService.getCheckout(normalizedCwd);
+        const membership = classifyDirectoryForProjectMembership({
+            cwd: normalizedCwd,
+            checkout,
+        });
+        return { record, membership, directoryKey: membership.workspaceDirectoryKey };
+    }));
+    for (const { record, membership, directoryKey } of placements) {
+        const existing = recordsByDirectoryKey.get(directoryKey) ?? { membership, records: [] };
+        existing.records.push(record);
+        recordsByDirectoryKey.set(directoryKey, existing);
+    }
+    const projectRanges = new Map();
+    const workspaceUpsertInputs = [];
+    for (const entry of recordsByDirectoryKey.values()) {
+        const { membership, records: workspaceRecords } = entry;
+        const workspaceCwd = membership.checkout.cwd;
+        let workspaceCreatedAt = null;
+        let workspaceUpdatedAt = null;
+        for (const record of workspaceRecords) {
+            workspaceCreatedAt = minIsoDate(workspaceCreatedAt, resolveAgentCreatedAt(record));
+            workspaceUpdatedAt = maxIsoDate(workspaceUpdatedAt, resolveAgentUpdatedAt(record));
+        }
+        const createdAt = workspaceCreatedAt ?? new Date().toISOString();
+        const updatedAt = workspaceUpdatedAt ?? createdAt;
+        const existingProjectRange = projectRanges.get(membership.projectKey) ?? {
+            createdAt: null,
+            updatedAt: null,
+        };
+        existingProjectRange.createdAt = minIsoDate(existingProjectRange.createdAt, createdAt);
+        existingProjectRange.updatedAt = maxIsoDate(existingProjectRange.updatedAt, updatedAt);
+        projectRanges.set(membership.projectKey, existingProjectRange);
+        workspaceUpsertInputs.push({
+            workspaceId: existingWorkspaceIdsByCwd.get(workspaceCwd) ?? generateWorkspaceId(),
+            membership,
+            workspaceCwd,
+            createdAt,
+            updatedAt,
+        });
+    }
+    await Promise.all(workspaceUpsertInputs.flatMap(({ workspaceId, membership, workspaceCwd, createdAt, updatedAt }) => {
+        const projectRange = projectRanges.get(membership.projectKey) ?? {
+            createdAt: null,
+            updatedAt: null,
+        };
+        return [
+            options.workspaceRegistry.upsert(createPersistedWorkspaceRecord({
+                workspaceId,
+                projectId: membership.projectKey,
+                cwd: workspaceCwd,
+                kind: membership.workspaceKind,
+                displayName: membership.workspaceDisplayName,
+                createdAt,
+                updatedAt,
+            })),
+            options.projectRegistry.upsert(createPersistedProjectRecord({
+                projectId: membership.projectKey,
+                rootPath: membership.projectRootPath,
+                kind: membership.projectKind,
+                displayName: membership.projectName,
+                createdAt: projectRange.createdAt ?? createdAt,
+                updatedAt: projectRange.updatedAt ?? updatedAt,
+            })),
+        ];
+    }));
+    await backfillWorkspaceIdForLegacyAgents(options);
+    options.logger.info({
+        projectsFile: path.join(options.paseoHome, "projects", "projects.json"),
+        workspacesFile: path.join(options.paseoHome, "projects", "workspaces.json"),
+        materializedProjects: projectRanges.size,
+        materializedWorkspaces: recordsByDirectoryKey.size,
+    }, "Workspace registries bootstrapped from existing agent storage");
+}
+//# sourceMappingURL=workspace-registry-bootstrap.js.map

package/dist/server/server/workspace-registry-model.d.ts

@@ -0,0 +1,55 @@
+import type { ProjectCheckoutLitePayload, ProjectPlacementPayload } from "@hyperdrive.bot/fleet-protocol/messages";
+import type { PersistedWorkspaceRecord } from "./workspace-registry.js";
+export type PersistedProjectKind = "git" | "non_git";
+export type PersistedWorkspaceKind = "local_checkout" | "worktree" | "directory";
+export interface DirectoryProjectMembership {
+    cwd: string;
+    checkout: ProjectCheckoutLitePayload;
+    workspaceDirectoryKey: string;
+    workspaceKind: PersistedWorkspaceKind;
+    workspaceDisplayName: string;
+    projectKey: string;
+    projectName: string;
+    projectRootPath: string;
+    projectKind: PersistedProjectKind;
+}
+export interface DetectStaleWorkspacesInput {
+    activeWorkspaces: PersistedWorkspaceRecord[];
+    checkDirectoryExists: (cwd: string) => Promise<boolean>;
+}
+export declare function generateWorkspaceId(): string;
+export declare function deriveWorkspaceDirectoryKey(cwd: string, checkout: ProjectCheckoutLitePayload): string;
+export declare function deriveProjectGroupingKey(options: {
+    cwd: string;
+    remoteUrl: string | null;
+    mainRepoRoot: string | null;
+}): string;
+export declare function deriveProjectGroupingName(projectKey: string): string;
+export declare function deriveWorkspaceDisplayName(input: {
+    cwd: string;
+    checkout: ProjectCheckoutLitePayload;
+}): string;
+export declare function deriveProjectRootPath(input: {
+    cwd: string;
+    checkout: ProjectCheckoutLitePayload;
+}): string;
+export declare function deriveProjectKind(checkout: ProjectCheckoutLitePayload): PersistedProjectKind;
+export declare function deriveWorkspaceKind(checkout: ProjectCheckoutLitePayload): PersistedWorkspaceKind;
+export declare function checkoutLiteFromGitSnapshot(cwd: string, git: {
+    isGit: boolean;
+    currentBranch: string | null;
+    remoteUrl: string | null;
+    repoRoot: string | null;
+    isPaseoOwnedWorktree: boolean;
+    mainRepoRoot: string | null;
+}): ProjectCheckoutLitePayload;
+export declare function detectStaleWorkspaces(input: DetectStaleWorkspacesInput): Promise<Set<string>>;
+export declare function buildProjectPlacementForCwd(input: {
+    cwd: string;
+    checkout: ProjectCheckoutLitePayload;
+}): ProjectPlacementPayload;
+export declare function classifyDirectoryForProjectMembership(input: {
+    cwd: string;
+    checkout: ProjectCheckoutLitePayload;
+}): DirectoryProjectMembership;
+//# sourceMappingURL=workspace-registry-model.d.ts.map