@hyperdrive.bot/fleet-server 0.3.99

package/dist/server/server/workspace-directory.js

@@ -0,0 +1,440 @@
+import { resolve } from "node:path";
+import { deriveAgentStateBucket, getWorkspaceStateBucketPriority, } from "@hyperdrive.bot/fleet-protocol/agent-state-bucket";
+import { getParentAgentIdFromLabels, isDelegatedAgent, } from "@hyperdrive.bot/fleet-protocol/agent-labels";
+import { SortablePager } from "./pagination/sortable-pager.js";
+import { resolveProjectDisplayName } from "./workspace-registry.js";
+import { deriveTerminalActivityStatusBucket, } from "@hyperdrive.bot/fleet-protocol/terminal-activity";
+const FETCH_WORKSPACES_SORT_KEYS = [
+    "status_priority",
+    "activity_at",
+    "name",
+    "project_id",
+];
+export function summarizeFetchWorkspacesEntries(entries) {
+    const workspaces = Array.from(entries, (entry) => ({
+        id: entry.id,
+        projectId: entry.projectId,
+        projectDisplayName: entry.projectDisplayName,
+        name: entry.name,
+        status: entry.status,
+        workspaceKind: entry.workspaceKind,
+        activityAt: entry.activityAt,
+    }));
+    const statusCounts = new Map();
+    for (const workspace of workspaces) {
+        statusCounts.set(workspace.status, (statusCounts.get(workspace.status) ?? 0) + 1);
+    }
+    return {
+        count: workspaces.length,
+        projectIds: [...new Set(workspaces.map((workspace) => workspace.projectId))],
+        statusCounts: Object.fromEntries(statusCounts),
+        workspaces,
+    };
+}
+/**
+ * Git facts (branch, diff, dirty, PR) belong to a checkout on disk, not to a
+ * workspace identity. Every workspace whose own cwd is that checkout re-derives
+ * its git facts from the same folder. This returns the ids of those workspaces
+ * so a git change can fan out to all of them. This is git-fact display, NOT
+ * ownership: do not use it to decide which workspace owns an arbitrary path.
+ */
+export function workspaceIdsOnCheckout(workspaces, cwd) {
+    const resolvedCwd = resolve(cwd);
+    return Array.from(workspaces)
+        .filter((workspace) => !workspace.archivedAt && resolve(workspace.cwd) === resolvedCwd)
+        .map((workspace) => workspace.workspaceId);
+}
+/**
+ * Build the bucket-derivation input for one agent snapshot.
+ *
+ * Exists so every call site in this file feeds `deriveAgentStateBucket` the
+ * SAME shape. It previously did not: two call sites hand-built the object and
+ * both omitted `activeChildCount`, so server-derived workspace buckets could
+ * never see armed background work while the app-side derivation could. The same
+ * agent then bucketed as "done" in the workspace list and "running" on its
+ * kanban card. One helper, one shape, no drift.
+ */
+function toBucketInput(agent) {
+    return {
+        status: agent.status,
+        pendingPermissionCount: agent.pendingPermissions?.length ?? 0,
+        requiresAttention: agent.requiresAttention,
+        attentionReason: agent.attentionReason ?? null,
+        // Monitors, crons and backgrounded shells still alive on this agent. Live
+        // SUBAGENTS are not counted here — they arrive as their own snapshots and
+        // are attributed to the delegation root in applyAgentBucketContributions.
+        activeChildCount: agent.activeBackgroundTaskCount ?? 0,
+    };
+}
+export class WorkspaceDirectory {
+    constructor(deps) {
+        this.deps = deps;
+        this.archivingByWorkspaceId = new Map();
+        /**
+         * Per-workspace last-seen winning bucket + entered-at. Persists across
+         * `buildDescriptorMap` calls inside the daemon process; reset on cold start.
+         * Server-internal; never crosses the wire.
+         */
+        this.bucketHistoryByWorkspaceId = new Map();
+        this.pager = new SortablePager({
+            validKeys: FETCH_WORKSPACES_SORT_KEYS,
+            defaultSort: [{ key: "activity_at", direction: "desc" }],
+            label: "fetch_workspaces",
+            getId: (workspace) => workspace.id,
+            getSortValue: (workspace, key) => {
+                switch (key) {
+                    case "status_priority":
+                        return getWorkspaceStateBucketPriority(workspace.status);
+                    case "activity_at":
+                        return workspace.activityAt ? Date.parse(workspace.activityAt) : null;
+                    case "name":
+                        return workspace.name.toLocaleLowerCase();
+                    case "project_id":
+                        return workspace.projectId.toLocaleLowerCase();
+                    default:
+                        throw new Error("unreachable");
+                }
+            },
+        });
+    }
+    markArchiving(workspaceIds, archivingAt) {
+        for (const workspaceId of workspaceIds) {
+            this.archivingByWorkspaceId.set(workspaceId, archivingAt);
+        }
+    }
+    clearArchiving(workspaceIds) {
+        for (const workspaceId of workspaceIds) {
+            this.archivingByWorkspaceId.delete(workspaceId);
+        }
+    }
+    async buildDescriptorMap(options) {
+        const [agents, persistedWorkspaces, persistedProjects, terminalContributions] = await Promise.all([
+            this.deps.listAgentPayloads(),
+            this.deps.workspaceRegistry.list(),
+            this.deps.projectRegistry.list(),
+            this.deps.listTerminalActivityContributions(),
+        ]);
+        const activeProjects = new Map(persistedProjects
+            .filter((project) => !project.archivedAt)
+            .map((project) => [project.projectId, project]));
+        const archivedProjectIds = new Set(persistedProjects.filter((project) => project.archivedAt).map((project) => project.projectId));
+        const activeRecords = persistedWorkspaces.filter((workspace) => !workspace.archivedAt && !archivedProjectIds.has(workspace.projectId));
+        const descriptorsByWorkspaceId = new Map();
+        const workspaceIds = options.workspaceIds ? new Set(options.workspaceIds) : null;
+        const activeWorkspaceIds = new Set(activeRecords.map((workspace) => workspace.workspaceId));
+        const includedWorkspaces = activeRecords.filter((workspace) => !workspaceIds || workspaceIds.has(workspace.workspaceId));
+        const activeRecordsByWorkspaceId = new Map(activeRecords.map((workspace) => [workspace.workspaceId, workspace]));
+        const workspaceDescriptors = await Promise.all(includedWorkspaces.map((workspace) => this.deps.buildWorkspaceDescriptor({
+            workspace,
+            projectRecord: activeProjects.get(workspace.projectId) ?? null,
+            includeGitData: options.includeGitData,
+        })));
+        for (let i = 0; i < includedWorkspaces.length; i += 1) {
+            const workspaceId = includedWorkspaces[i].workspaceId;
+            descriptorsByWorkspaceId.set(workspaceId, {
+                ...workspaceDescriptors[i],
+                archivingAt: this.archivingByWorkspaceId.get(workspaceId) ?? null,
+            });
+        }
+        const activeAgents = agents.filter((agent) => !agent.archivedAt && this.deps.isProviderVisibleToClient(agent.provider));
+        this.applyAgentBucketContributions({
+            activeAgents,
+            descriptorsByWorkspaceId,
+        });
+        // Terminal activity contributions: working terminal → running bucket.
+        const terminalEntriesByWorkspaceId = this.applyTerminalContributions(terminalContributions, descriptorsByWorkspaceId);
+        const contributingAgentsByWorkspaceId = groupAgentsByWorkspaceId(activeAgents, activeWorkspaceIds);
+        // Resolve the workspace-level `statusEnteredAt` (see aggregate semantics
+        // on `resolveStatusEnteredAt`).
+        const nowIso = new Date().toISOString();
+        for (const [workspaceId, descriptor] of descriptorsByWorkspaceId) {
+            const contributingAgents = contributingAgentsByWorkspaceId.get(workspaceId) ?? [];
+            const terminalEntries = terminalEntriesByWorkspaceId.get(workspaceId) ?? [];
+            const result = this.resolveStatusEnteredAt({
+                workspaceId,
+                winningBucket: descriptor.status,
+                contributingAgents,
+                terminalEntries,
+                previous: this.bucketHistoryByWorkspaceId.get(workspaceId) ?? null,
+                workspaceCreatedAt: activeRecordsByWorkspaceId.get(workspaceId)?.createdAt ?? null,
+                nowIso,
+            });
+            descriptor.statusEnteredAt = result.statusEnteredAt;
+            if (result.recordUpdate) {
+                this.bucketHistoryByWorkspaceId.set(workspaceId, result.recordUpdate);
+            }
+            else if (result.recordDelete) {
+                this.bucketHistoryByWorkspaceId.delete(workspaceId);
+            }
+        }
+        return descriptorsByWorkspaceId;
+    }
+    // Aggregate each agent's state bucket into its owning workspace descriptor,
+    // keeping the highest-priority bucket. A record's owner IS its `workspaceId`;
+    // status never fans out to same-cwd siblings. Delegated agents contribute to
+    // their delegation root's workspace; their own status is ignored unless running.
+    applyAgentBucketContributions(params) {
+        const { activeAgents, descriptorsByWorkspaceId } = params;
+        const activeAgentsById = new Map(activeAgents.map((agent) => [agent.id, agent]));
+        for (const agent of activeAgents) {
+            let workspaceAgent = agent;
+            let bucket;
+            if (isDelegatedAgent(agent)) {
+                if (agent.status !== "running") {
+                    continue;
+                }
+                const parentAgent = resolveDelegationRootAgent(agent, activeAgentsById);
+                if (!parentAgent) {
+                    continue;
+                }
+                workspaceAgent = parentAgent;
+                // A live subagent means the ROOT's own turn is not in flight — it is
+                // waiting on delegated work that will hand control back by itself.
+                // That is "pending", not "running"; see agent-state-bucket.ts.
+                bucket = "pending";
+            }
+            else {
+                bucket = deriveAgentStateBucket(toBucketInput(agent));
+            }
+            const workspaceId = workspaceAgent.workspaceId;
+            if (!workspaceId) {
+                continue;
+            }
+            const existing = descriptorsByWorkspaceId.get(workspaceId);
+            if (!existing) {
+                continue;
+            }
+            if (getWorkspaceStateBucketPriority(bucket) < getWorkspaceStateBucketPriority(existing.status)) {
+                existing.status = bucket;
+            }
+        }
+    }
+    // Apply working terminal contributions to descriptor statuses and build a map
+    // of terminal timestamp entries per workspace for use in `resolveStatusEnteredAt`.
+    // A terminal contributes only to the workspace it carries; same-cwd siblings
+    // are untouched.
+    applyTerminalContributions(terminalContributions, descriptorsByWorkspaceId) {
+        const terminalEntriesByWorkspaceId = new Map();
+        for (const { workspaceId, activity } of terminalContributions) {
+            if (!activity || !workspaceId) {
+                continue;
+            }
+            const bucket = deriveTerminalActivityStatusBucket(activity);
+            if (!bucket)
+                continue;
+            const existing = descriptorsByWorkspaceId.get(workspaceId);
+            if (!existing) {
+                continue;
+            }
+            if (getWorkspaceStateBucketPriority(bucket) < getWorkspaceStateBucketPriority(existing.status)) {
+                existing.status = bucket;
+            }
+            const entries = terminalEntriesByWorkspaceId.get(workspaceId) ?? [];
+            entries.push({
+                bucket,
+                changedAtIso: new Date(activity.changedAt).toISOString(),
+            });
+            terminalEntriesByWorkspaceId.set(workspaceId, entries);
+        }
+        return terminalEntriesByWorkspaceId;
+    }
+    // Aggregate the workspace-level `statusEnteredAt` from its contributing
+    // agents and terminals. Aggregate semantics:
+    //   - winning bucket = highest-priority across contributing agents and terminals;
+    //   - entry time = best-effort timestamp from agents/terminals in the winning bucket;
+    //   - priority unmasking: when the winning bucket transitions (e.g. a
+    //     higher-priority bucket cleared), the new entry time is "now";
+    //   - same-bucket emits reuse the previous entered-at;
+    //   - empty workspaces that never had contributing agents or terminals use
+    //     their workspace creation time as their initial `done` entry time.
+    //   - when archived agents leave a previously active workspace empty, keep
+    //     the previous done timestamp or stamp the transition to done now.
+    resolveStatusEnteredAt(params) {
+        const { winningBucket, contributingAgents, terminalEntries, previous, workspaceCreatedAt, nowIso, } = params;
+        if (contributingAgents.length === 0 && terminalEntries.length === 0) {
+            if (!previous) {
+                if (!workspaceCreatedAt) {
+                    return { statusEnteredAt: null };
+                }
+                return {
+                    statusEnteredAt: workspaceCreatedAt,
+                    recordUpdate: { bucket: "done", enteredAt: workspaceCreatedAt },
+                };
+            }
+            const enteredAt = previous.bucket === "done" ? previous.enteredAt : nowIso;
+            return {
+                statusEnteredAt: enteredAt,
+                recordUpdate: { bucket: "done", enteredAt },
+            };
+        }
+        if (!previous) {
+            const newestInWinningBucket = this.findNewestTimestampInBucket(contributingAgents, terminalEntries, winningBucket);
+            const enteredAt = newestInWinningBucket ?? nowIso;
+            return {
+                statusEnteredAt: enteredAt,
+                recordUpdate: { bucket: winningBucket, enteredAt },
+            };
+        }
+        if (previous.bucket !== winningBucket) {
+            return {
+                statusEnteredAt: nowIso,
+                recordUpdate: { bucket: winningBucket, enteredAt: nowIso },
+            };
+        }
+        return {
+            statusEnteredAt: previous.enteredAt,
+            recordUpdate: previous,
+        };
+    }
+    // Best-effort newest timestamp across contributing agents and terminal entries
+    // whose bucket matches `winningBucket`. For agents, uses:
+    //   - `attentionTimestamp` when attention is set (covers attention/failed)
+    //   - `updatedAt` as a general fallback for any bucket
+    // Returns `null` if no matching contributor has a parseable timestamp.
+    findNewestTimestampInBucket(contributingAgents, terminalEntries, winningBucket) {
+        const agentTimestamps = contributingAgents
+            .filter((agent) => {
+            const derived = deriveAgentStateBucket(toBucketInput(agent));
+            return derived === winningBucket;
+        })
+            .map((agent) => {
+            // Prefer attentionTimestamp when the agent has attention set — this is
+            // the most accurate "entered current status" signal.
+            if (agent.attentionTimestamp) {
+                return agent.attentionTimestamp;
+            }
+            // Fall back to updatedAt as a general proxy for recent activity.
+            return agent.updatedAt;
+        })
+            .filter((value) => typeof value === "string" && value.length > 0);
+        const terminalTimestamps = terminalEntries
+            .filter((entry) => entry.bucket === winningBucket)
+            .map((entry) => entry.changedAtIso);
+        const candidates = [...agentTimestamps, ...terminalTimestamps].sort();
+        return candidates.at(-1) ?? null;
+    }
+    // Project parents that have no active workspaces. The wire field is the
+    // sidebar projection bucket for projects whose workspace list is currently
+    // empty; it is not a separate domain record.
+    async listEmptyProjects() {
+        const [persistedWorkspaces, persistedProjects] = await Promise.all([
+            this.deps.workspaceRegistry.list(),
+            this.deps.projectRegistry.list(),
+        ]);
+        const projectIdsWithActiveWorkspaces = new Set(persistedWorkspaces
+            .filter((workspace) => !workspace.archivedAt)
+            .map((workspace) => workspace.projectId));
+        return persistedProjects
+            .filter((project) => !project.archivedAt && !projectIdsWithActiveWorkspaces.has(project.projectId))
+            .map((project) => ({
+            projectId: project.projectId,
+            projectDisplayName: resolveProjectDisplayName(project),
+            projectCustomName: project.customName ?? null,
+            projectRootPath: project.rootPath,
+            projectKind: project.kind,
+        }));
+    }
+    async listDescriptors() {
+        return Array.from((await this.buildDescriptorMap({
+            includeGitData: true,
+        })).values());
+    }
+    matchesFilter(input) {
+        const { workspace, filter } = input;
+        if (!filter) {
+            return true;
+        }
+        if (filter.projectId && filter.projectId.trim().length > 0) {
+            if (workspace.projectId !== filter.projectId.trim()) {
+                return false;
+            }
+        }
+        if (filter.query && filter.query.trim().length > 0) {
+            const query = filter.query.trim().toLocaleLowerCase();
+            const haystacks = [workspace.name, workspace.projectId, workspace.id];
+            if (!haystacks.some((value) => value.toLocaleLowerCase().includes(query))) {
+                return false;
+            }
+        }
+        return true;
+    }
+    async listFetchEntries(request) {
+        const filter = request.filter;
+        const sort = this.pager.normalizeSort(request.sort);
+        let entries = await this.listDescriptors();
+        const listedCount = entries.length;
+        entries = entries.filter((workspace) => this.matchesFilter({ workspace, filter }));
+        const filteredCount = entries.length;
+        entries.sort((left, right) => this.pager.compare(left, right, sort));
+        const cursorToken = request.page?.cursor;
+        if (cursorToken) {
+            const cursor = this.pager.decode(cursorToken, sort);
+            entries = entries.filter((workspace) => this.pager.compareWithCursor(workspace, cursor, sort) > 0);
+        }
+        const limit = request.page?.limit ?? 200;
+        const pagedEntries = entries.slice(0, limit);
+        const hasMore = entries.length > limit;
+        const nextCursor = hasMore && pagedEntries.length > 0
+            ? this.pager.encode(pagedEntries[pagedEntries.length - 1], sort)
+            : null;
+        // Project parents with no active workspaces ride only on the first page so
+        // the sidebar can render them without duplicating them across pagination.
+        const projectIdFilter = filter?.projectId?.trim();
+        const emptyProjects = cursorToken
+            ? []
+            : (await this.listEmptyProjects()).filter((project) => !projectIdFilter || project.projectId === projectIdFilter);
+        this.deps.logger.debug({
+            requestId: request.requestId,
+            filter: request.filter ?? null,
+            sort,
+            page: request.page ?? null,
+            listedCount,
+            filteredCount,
+            returnedCount: pagedEntries.length,
+            hasMore,
+            nextCursor,
+        }, "fetch_workspaces_entries_listed");
+        return {
+            entries: pagedEntries,
+            emptyProjects,
+            pageInfo: {
+                nextCursor,
+                prevCursor: request.page?.cursor ?? null,
+                hasMore,
+            },
+        };
+    }
+}
+function groupAgentsByWorkspaceId(agents, activeWorkspaceIds) {
+    const byWorkspaceId = new Map();
+    for (const agent of agents) {
+        const workspaceId = agent.workspaceId;
+        if (!workspaceId || !activeWorkspaceIds.has(workspaceId)) {
+            continue;
+        }
+        const entries = byWorkspaceId.get(workspaceId) ?? [];
+        entries.push(agent);
+        byWorkspaceId.set(workspaceId, entries);
+    }
+    return byWorkspaceId;
+}
+function resolveDelegationRootAgent(agent, activeAgentsById) {
+    const seen = new Set([agent.id]);
+    let current = agent;
+    while (true) {
+        const parentAgentId = getParentAgentIdFromLabels(current.labels);
+        if (!parentAgentId) {
+            return current;
+        }
+        if (seen.has(parentAgentId)) {
+            return null;
+        }
+        const parent = activeAgentsById.get(parentAgentId);
+        if (!parent) {
+            return null;
+        }
+        seen.add(parentAgentId);
+        current = parent;
+    }
+}
+//# sourceMappingURL=workspace-directory.js.map

package/dist/server/server/workspace-git-metadata.d.ts

@@ -0,0 +1,24 @@
+export interface WorkspaceGitMetadata {
+    projectKind: "git" | "directory";
+    projectDisplayName: string;
+    workspaceDisplayName: string;
+    gitRemote: string | null;
+    isWorktree: boolean;
+    projectSlug: string;
+    repoRoot: string | null;
+    currentBranch: string | null;
+    remoteUrl: string | null;
+}
+export declare function parseGitHubRepoFromRemote(remoteUrl: string): string | null;
+export declare function parseGitHubRepoNameFromRemote(remoteUrl: string): string | null;
+export declare function deriveProjectSlug(cwd: string, remoteUrl?: string | null): string;
+export declare function buildWorkspaceGitMetadataFromSnapshot(input: {
+    cwd: string;
+    directoryName: string;
+    isGit: boolean;
+    repoRoot: string | null;
+    mainRepoRoot: string | null;
+    currentBranch: string | null;
+    remoteUrl: string | null;
+}): WorkspaceGitMetadata;
+//# sourceMappingURL=workspace-git-metadata.d.ts.map

package/dist/server/server/workspace-git-metadata.js

@@ -0,0 +1,55 @@
+import { basename } from "path";
+import { parseGitHubRemoteUrl } from "../utils/github-remote.js";
+import { slugify } from "../utils/worktree.js";
+import { deriveProjectGroupingKey, deriveProjectGroupingName } from "./workspace-registry-model.js";
+export function parseGitHubRepoFromRemote(remoteUrl) {
+    return parseGitHubRemoteUrl(remoteUrl)?.repo ?? null;
+}
+export function parseGitHubRepoNameFromRemote(remoteUrl) {
+    const githubRepo = parseGitHubRepoFromRemote(remoteUrl);
+    if (!githubRepo) {
+        return null;
+    }
+    return githubRepo.split("/").pop() || null;
+}
+export function deriveProjectSlug(cwd, remoteUrl = null) {
+    const githubRepoName = remoteUrl ? parseGitHubRepoNameFromRemote(remoteUrl) : null;
+    const sourceName = githubRepoName ?? basename(cwd);
+    return slugify(sourceName) || "untitled";
+}
+export function buildWorkspaceGitMetadataFromSnapshot(input) {
+    if (!input.isGit) {
+        return {
+            projectKind: "directory",
+            projectDisplayName: input.directoryName,
+            workspaceDisplayName: input.directoryName,
+            gitRemote: null,
+            isWorktree: false,
+            projectSlug: deriveProjectSlug(input.cwd),
+            repoRoot: null,
+            currentBranch: null,
+            remoteUrl: null,
+        };
+    }
+    const isWorktree = input.mainRepoRoot !== null && input.repoRoot !== null && input.mainRepoRoot !== input.repoRoot;
+    const projectKey = deriveProjectGroupingKey({
+        cwd: input.repoRoot ?? input.cwd,
+        remoteUrl: input.remoteUrl,
+        mainRepoRoot: input.mainRepoRoot,
+    });
+    const projectDisplayName = projectKey.startsWith("remote:")
+        ? deriveProjectGroupingName(projectKey)
+        : input.directoryName;
+    return {
+        projectKind: "git",
+        projectDisplayName,
+        workspaceDisplayName: input.currentBranch ?? input.directoryName,
+        gitRemote: input.remoteUrl,
+        isWorktree,
+        projectSlug: deriveProjectSlug(input.cwd, input.remoteUrl),
+        repoRoot: input.repoRoot,
+        currentBranch: input.currentBranch,
+        remoteUrl: input.remoteUrl,
+    };
+}
+//# sourceMappingURL=workspace-git-metadata.js.map