@bbigbang/core 0.1.0

package/dist/services/workbenchGitBroker.js

@@ -0,0 +1,161 @@
+import { randomUUID } from 'node:crypto';
+export class WorkbenchGitBroker {
+    statusPending = new Map();
+    diffPending = new Map();
+    actionPending = new Map();
+    nodeRegistry;
+    statusTimeoutMs;
+    diffTimeoutMs;
+    actionTimeoutMs;
+    constructor(params) {
+        this.nodeRegistry = params.nodeRegistry;
+        const fallbackTimeoutMs = params.timeoutMs;
+        this.statusTimeoutMs = params.statusTimeoutMs ?? fallbackTimeoutMs ?? 5_000;
+        this.diffTimeoutMs = params.diffTimeoutMs ?? fallbackTimeoutMs ?? 15_000;
+        this.actionTimeoutMs = params.actionTimeoutMs ?? fallbackTimeoutMs ?? 60_000;
+    }
+    runGitAction(nodeId, workspaceRoot, action, commitMessage) {
+        const requestId = randomUUID();
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.actionPending.delete(requestId);
+                reject(new Error('Workspace git action request timed out.'));
+            }, this.actionTimeoutMs);
+            this.actionPending.set(requestId, {
+                nodeId,
+                resolve,
+                reject,
+                timer,
+            });
+            const sent = this.nodeRegistry.send(nodeId, {
+                type: 'workspace.git_action.request',
+                requestId,
+                workspaceRoot,
+                action,
+                commitMessage,
+            });
+            if (!sent) {
+                clearTimeout(timer);
+                this.actionPending.delete(requestId);
+                reject(new Error('Agent node is offline.'));
+            }
+        });
+    }
+    getGitStatus(nodeId, workspaceRoot) {
+        const requestId = randomUUID();
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.statusPending.delete(requestId);
+                reject(new Error('Workspace git status request timed out.'));
+            }, this.statusTimeoutMs);
+            this.statusPending.set(requestId, {
+                nodeId,
+                resolve,
+                reject,
+                timer,
+            });
+            const sent = this.nodeRegistry.send(nodeId, {
+                type: 'workspace.git_status.request',
+                requestId,
+                workspaceRoot,
+            });
+            if (!sent) {
+                clearTimeout(timer);
+                this.statusPending.delete(requestId);
+                reject(new Error('Agent node is offline.'));
+            }
+        });
+    }
+    getGitDiff(nodeId, workspaceRoot, mode) {
+        const requestId = randomUUID();
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.diffPending.delete(requestId);
+                reject(new Error('Workspace git diff request timed out.'));
+            }, this.diffTimeoutMs);
+            this.diffPending.set(requestId, {
+                nodeId,
+                resolve,
+                reject,
+                timer,
+            });
+            const sent = this.nodeRegistry.send(nodeId, {
+                type: 'workspace.git_diff.request',
+                requestId,
+                workspaceRoot,
+                mode,
+            });
+            if (!sent) {
+                clearTimeout(timer);
+                this.diffPending.delete(requestId);
+                reject(new Error('Agent node is offline.'));
+            }
+        });
+    }
+    handleGitStatusResponse(msg) {
+        const pending = this.statusPending.get(msg.requestId);
+        if (!pending)
+            return;
+        this.statusPending.delete(msg.requestId);
+        clearTimeout(pending.timer);
+        if (msg.error || !msg.status) {
+            pending.reject(new Error(this.formatErrorMessage(msg.errorCode, msg.error, 'Workspace git status failed.')));
+            return;
+        }
+        pending.resolve(msg.status);
+    }
+    handleGitDiffResponse(msg) {
+        const pending = this.diffPending.get(msg.requestId);
+        if (!pending)
+            return;
+        this.diffPending.delete(msg.requestId);
+        clearTimeout(pending.timer);
+        if (msg.error || !msg.diff) {
+            pending.reject(new Error(this.formatErrorMessage(msg.errorCode, msg.error, 'Workspace git diff failed.')));
+            return;
+        }
+        pending.resolve(msg.diff);
+    }
+    handleGitActionResponse(msg) {
+        const pending = this.actionPending.get(msg.requestId);
+        if (!pending)
+            return;
+        this.actionPending.delete(msg.requestId);
+        clearTimeout(pending.timer);
+        if (msg.error || !msg.result) {
+            pending.reject(new Error(this.formatErrorMessage(msg.errorCode, msg.error, 'Workspace git action failed.')));
+            return;
+        }
+        pending.resolve(msg.result);
+    }
+    rejectPendingForNode(nodeId) {
+        for (const [requestId, pending] of this.statusPending.entries()) {
+            if (pending.nodeId !== nodeId)
+                continue;
+            clearTimeout(pending.timer);
+            pending.reject(new Error(`Agent node disconnected: ${nodeId}`));
+            this.statusPending.delete(requestId);
+        }
+        for (const [requestId, pending] of this.diffPending.entries()) {
+            if (pending.nodeId !== nodeId)
+                continue;
+            clearTimeout(pending.timer);
+            pending.reject(new Error(`Agent node disconnected: ${nodeId}`));
+            this.diffPending.delete(requestId);
+        }
+        for (const [requestId, pending] of this.actionPending.entries()) {
+            if (pending.nodeId !== nodeId)
+                continue;
+            clearTimeout(pending.timer);
+            pending.reject(new Error(`Agent node disconnected: ${nodeId}`));
+            this.actionPending.delete(requestId);
+        }
+    }
+    formatErrorMessage(errorCode, error, fallback) {
+        if (error)
+            return errorCode ? `${errorCode}:${error}` : error;
+        if (errorCode)
+            return `${errorCode}:${fallback}`;
+        return fallback;
+    }
+}

package/dist/services/workbenchGitService.js

@@ -0,0 +1,69 @@
+export class WorkbenchGitServiceError extends Error {
+    statusCode;
+    constructor(statusCode, message) {
+        super(message);
+        this.statusCode = statusCode;
+    }
+}
+export class WorkbenchGitService {
+    broker;
+    projectAccessResolver;
+    constructor(params) {
+        this.broker = params.broker;
+        this.projectAccessResolver = params.projectAccessResolver;
+    }
+    async getStatus(root) {
+        ensureProjectRoot(root);
+        try {
+            return await this.projectAccessResolver.withResolvedNode(root.projectId, async (nodeId) => this.broker.getGitStatus(nodeId, root.rootPath));
+        }
+        catch (error) {
+            throw mapWorkbenchGitError(error);
+        }
+    }
+    async getDiff(root, mode) {
+        ensureProjectRoot(root);
+        try {
+            return await this.projectAccessResolver.withResolvedNode(root.projectId, async (nodeId) => this.broker.getGitDiff(nodeId, root.rootPath, mode));
+        }
+        catch (error) {
+            throw mapWorkbenchGitError(error);
+        }
+    }
+    async runAction(root, action, commitMessage) {
+        ensureProjectRoot(root);
+        try {
+            return await this.projectAccessResolver.withResolvedNode(root.projectId, async (nodeId) => this.broker.runGitAction(nodeId, root.rootPath, action, commitMessage));
+        }
+        catch (error) {
+            throw mapWorkbenchGitError(error);
+        }
+    }
+}
+function ensureProjectRoot(root) {
+    if (root.kind !== 'project_space') {
+        throw new WorkbenchGitServiceError(409, 'Git changes are only available for project roots.');
+    }
+    if (!root.projectId) {
+        throw new WorkbenchGitServiceError(409, 'Project root is missing its project identity.');
+    }
+}
+function mapWorkbenchGitError(error) {
+    const message = String(error?.message ?? error);
+    if (message === 'Agent node is offline.' || message.startsWith('Agent node disconnected:')) {
+        return new WorkbenchGitServiceError(409, message);
+    }
+    if (message.includes('request timed out.')) {
+        return new WorkbenchGitServiceError(504, message);
+    }
+    if (message.startsWith('not_found:')) {
+        return new WorkbenchGitServiceError(404, message.slice('not_found:'.length));
+    }
+    if (message.startsWith('not_directory:')) {
+        return new WorkbenchGitServiceError(400, message.slice('not_directory:'.length));
+    }
+    if (message.startsWith('io_error:')) {
+        return new WorkbenchGitServiceError(500, message.slice('io_error:'.length));
+    }
+    return new WorkbenchGitServiceError(500, message);
+}

package/dist/services/workbenchInspectBroker.js

@@ -0,0 +1,65 @@
+import { randomUUID } from 'node:crypto';
+export class WorkbenchInspectBroker {
+    pending = new Map();
+    nodeRegistry;
+    timeoutMs;
+    constructor(params) {
+        this.nodeRegistry = params.nodeRegistry;
+        this.timeoutMs = params.timeoutMs ?? 1_500;
+    }
+    inspectWorkspace(nodeId, workspaceRoot) {
+        const requestId = randomUUID();
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(requestId);
+                reject(new Error('Workspace inspect request timed out.'));
+            }, this.timeoutMs);
+            this.pending.set(requestId, {
+                nodeId,
+                resolve,
+                reject,
+                timer,
+            });
+            const sent = this.nodeRegistry.send(nodeId, {
+                type: 'workspace.inspect.request',
+                requestId,
+                workspaceRoot,
+            });
+            if (!sent) {
+                clearTimeout(timer);
+                this.pending.delete(requestId);
+                reject(new Error('Agent node is offline.'));
+            }
+        });
+    }
+    handleInspectResponse(msg) {
+        const pending = this.pending.get(msg.requestId);
+        if (!pending)
+            return;
+        this.pending.delete(msg.requestId);
+        clearTimeout(pending.timer);
+        if (msg.error || !msg.inspect) {
+            pending.reject(new Error(this.formatErrorMessage(msg.errorCode, msg.error)));
+            return;
+        }
+        pending.resolve(msg.inspect);
+    }
+    rejectPendingForNode(nodeId) {
+        for (const [requestId, pending] of this.pending.entries()) {
+            if (pending.nodeId !== nodeId)
+                continue;
+            clearTimeout(pending.timer);
+            pending.reject(new Error(`Agent node disconnected: ${nodeId}`));
+            this.pending.delete(requestId);
+        }
+    }
+    formatErrorMessage(errorCode, error) {
+        if (error)
+            return error;
+        if (errorCode === 'not_found')
+            return 'Workspace root not found.';
+        if (errorCode === 'not_directory')
+            return 'Workspace root is not a directory.';
+        return 'Workspace inspect failed.';
+    }
+}

package/dist/services/workbenchNodePathService.js

@@ -0,0 +1,79 @@
+export class WorkbenchNodePathServiceError extends Error {
+    statusCode;
+    constructor(statusCode, message) {
+        super(message);
+        this.statusCode = statusCode;
+    }
+}
+export class WorkbenchNodePathService {
+    broker;
+    projectAccessResolver;
+    constructor(params) {
+        this.broker = params.broker;
+        this.projectAccessResolver = params.projectAccessResolver;
+    }
+    async listTree(nodeId, rootPath, relativePath, options = {}) {
+        if (!nodeId)
+            throw new WorkbenchNodePathServiceError(409, 'Project root is not bound to a remote node.');
+        try {
+            return await this.broker.listDirectory(nodeId, rootPath, relativePath, { scaffold: false, ...options });
+        }
+        catch (error) {
+            throw mapWorkspaceError(error);
+        }
+    }
+    async readFile(nodeId, rootPath, relativePath, options = {}) {
+        if (!nodeId)
+            throw new WorkbenchNodePathServiceError(409, 'Project root is not bound to a remote node.');
+        try {
+            return await this.broker.readFile(nodeId, rootPath, relativePath, { scaffold: false, ...options });
+        }
+        catch (error) {
+            throw mapWorkspaceError(error);
+        }
+    }
+    async listProjectTree(projectId, rootPath, relativePath, options = {}) {
+        try {
+            return await this.projectAccessResolver.withResolvedNode(projectId, async (nodeId) => this.broker.listDirectory(nodeId, rootPath, relativePath, { scaffold: false, ...options }));
+        }
+        catch (error) {
+            throw mapWorkspaceError(error);
+        }
+    }
+    async readProjectFile(projectId, rootPath, relativePath, options = {}) {
+        try {
+            return await this.projectAccessResolver.withResolvedNode(projectId, async (nodeId) => this.broker.readFile(nodeId, rootPath, relativePath, { scaffold: false, ...options }));
+        }
+        catch (error) {
+            throw mapWorkspaceError(error);
+        }
+    }
+}
+function mapWorkspaceError(error) {
+    const message = String(error?.message ?? error);
+    if (message === 'Agent node is offline.') {
+        return new WorkbenchNodePathServiceError(409, message);
+    }
+    if (message === 'Workspace request timed out.') {
+        return new WorkbenchNodePathServiceError(504, message);
+    }
+    if (message.startsWith('not_found:')) {
+        return new WorkbenchNodePathServiceError(404, message.slice('not_found:'.length));
+    }
+    if (message.startsWith('path_outside_workspace:')) {
+        return new WorkbenchNodePathServiceError(400, message.slice('path_outside_workspace:'.length));
+    }
+    if (message.startsWith('invalid_request:')) {
+        return new WorkbenchNodePathServiceError(400, message.slice('invalid_request:'.length));
+    }
+    if (message.startsWith('binary_file:')) {
+        return new WorkbenchNodePathServiceError(415, message.slice('binary_file:'.length));
+    }
+    if (message.startsWith('file_too_large:')) {
+        return new WorkbenchNodePathServiceError(413, message.slice('file_too_large:'.length));
+    }
+    if (message.startsWith('not_directory:') || message.startsWith('not_file:')) {
+        return new WorkbenchNodePathServiceError(400, message.slice(message.indexOf(':') + 1));
+    }
+    return new WorkbenchNodePathServiceError(500, message);
+}

package/dist/services/workbenchRegistryService.js

@@ -0,0 +1,240 @@
+import { log } from '@bbigbang/runtime-acp';
+import { canonicalizeWorkbenchRootPath, getWorkbenchPathBasename, } from './workbenchRootService.js';
+export class WorkbenchRegistryService {
+    db;
+    workbenchRootService;
+    inspectBroker;
+    constructor(params) {
+        this.db = params.db;
+        this.workbenchRootService = params.workbenchRootService;
+        this.inspectBroker = params.inspectBroker;
+    }
+    async listProjects() {
+        const persisted = this.loadPersistedWorkspaceRecords();
+        const projectRoots = this.workbenchRootService
+            .listRoots()
+            .filter((root) => (root.kind === 'project_space'
+            && !!root.projectId));
+        const snapshots = await Promise.all(projectRoots.map((root) => this.buildProjectSnapshot(root, persisted.get(root.projectId) ?? null)));
+        const projectsById = new Map();
+        for (const snapshot of snapshots) {
+            const projectId = snapshot.workspace.projectId ?? snapshot.workspace.workspaceId;
+            const existing = projectsById.get(projectId);
+            if (existing) {
+                existing.workspaces.push(snapshot.workspace);
+                existing.workspaces.sort((left, right) => left.rootPath.localeCompare(right.rootPath));
+                if (!existing.remoteUrl && snapshot.remoteUrl) {
+                    existing.remoteUrl = snapshot.remoteUrl;
+                }
+                if (snapshot.workspace.workspaceKind === 'local_checkout'
+                    && existing.primaryRootPath !== snapshot.primaryRootPath) {
+                    existing.primaryRootPath = snapshot.primaryRootPath;
+                }
+                continue;
+            }
+            projectsById.set(projectId, {
+                projectId,
+                displayName: snapshot.displayName,
+                projectKind: snapshot.projectKind,
+                primaryRootPath: snapshot.primaryRootPath,
+                remoteUrl: snapshot.remoteUrl,
+                workspaces: [snapshot.workspace],
+            });
+        }
+        const projects = [...projectsById.values()]
+            .sort((left, right) => left.displayName.localeCompare(right.displayName));
+        this.persistProjects(projects);
+        return projects;
+    }
+    async buildProjectSnapshot(root, persisted) {
+        const inspect = await this.inspectProjectRoot(root);
+        const canonicalRootPath = canonicalizeWorkbenchRootPath(root.rootPath);
+        const displayName = inspect
+            ? resolveProjectDisplayName(canonicalRootPath, inspect)
+            : (persisted?.workspaceDisplayName ?? (getWorkbenchPathBasename(canonicalRootPath) || canonicalRootPath));
+        return {
+            displayName: inspect ? displayName : (persisted?.projectDisplayName ?? displayName),
+            projectKind: inspect?.isGit ? 'git' : (persisted?.projectKind ?? 'directory'),
+            primaryRootPath: persisted?.primaryRootPath ? canonicalizeWorkbenchRootPath(persisted.primaryRootPath) : canonicalRootPath,
+            remoteUrl: inspect?.remoteUrl ?? persisted?.projectRemoteUrl ?? null,
+            workspace: {
+                workspaceId: root.workbenchRootId,
+                workbenchRootId: root.workbenchRootId,
+                displayName,
+                rootPath: canonicalRootPath,
+                workspaceKind: inspect?.workspaceKind ?? persisted?.workspaceKind ?? 'directory',
+                branchName: inspect?.branchName ?? persisted?.branchName ?? null,
+                remoteUrl: inspect?.remoteUrl ?? persisted?.workspaceRemoteUrl ?? null,
+                nodeId: root.nodeId,
+                projectId: root.projectId,
+                projectBackendType: root.projectBackendType,
+                agentIds: [...(root.agentIds ?? [])].sort((left, right) => left.localeCompare(right)),
+                writable: root.writable,
+                terminalSupported: root.terminalSupported,
+                terminalDisabledReason: root.terminalDisabledReason ?? null,
+            },
+        };
+    }
+    async inspectProjectRoot(root) {
+        if (!root.nodeId)
+            return null;
+        try {
+            return await this.inspectBroker.inspectWorkspace(root.nodeId, root.rootPath);
+        }
+        catch (error) {
+            log.debug('[workbench-registry] project inspect unavailable', {
+                rootId: root.workbenchRootId,
+                nodeId: root.nodeId,
+                rootPath: root.rootPath,
+                error: String(error?.message ?? error),
+            });
+            return null;
+        }
+    }
+    loadPersistedWorkspaceRecords() {
+        const rows = this.db.prepare(`SELECT ww.workbench_root_id as workbenchRootId,
+              ww.display_name as workspaceDisplayName,
+              ww.root_path as workspaceRootPath,
+              ww.workspace_kind as workspaceKind,
+              ww.branch_name as branchName,
+              ww.remote_url as workspaceRemoteUrl,
+              wp.project_id as projectId,
+              wp.display_name as projectDisplayName,
+              wp.project_kind as projectKind,
+              wp.primary_root_path as primaryRootPath,
+              wp.remote_url as projectRemoteUrl
+         FROM workbench_workspaces ww
+         JOIN workbench_projects wp ON wp.project_id = ww.project_id
+        WHERE ww.archived_at IS NULL
+          AND wp.archived_at IS NULL`).all();
+        return new Map(rows.map((row) => [row.projectId, row]));
+    }
+    persistProjects(projects) {
+        const now = Date.now();
+        const upsertProject = this.db.prepare(`INSERT INTO workbench_projects(
+         project_id,
+         project_kind,
+         display_name,
+         primary_root_path,
+         remote_url,
+         created_at,
+         updated_at,
+         archived_at
+       ) VALUES(?, ?, ?, ?, ?, ?, ?, NULL)
+       ON CONFLICT(project_id) DO UPDATE SET
+         project_kind = excluded.project_kind,
+         display_name = excluded.display_name,
+         primary_root_path = excluded.primary_root_path,
+         remote_url = excluded.remote_url,
+         updated_at = excluded.updated_at,
+         archived_at = NULL`);
+        const upsertWorkspace = this.db.prepare(`INSERT INTO workbench_workspaces(
+         workspace_id,
+         workbench_root_id,
+         project_id,
+         agent_id,
+         root_path,
+         display_name,
+         workspace_kind,
+         branch_name,
+         remote_url,
+         created_at,
+         updated_at,
+         archived_at
+       ) VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL)
+       ON CONFLICT(workspace_id) DO UPDATE SET
+         workbench_root_id = excluded.workbench_root_id,
+         project_id = excluded.project_id,
+         agent_id = excluded.agent_id,
+         root_path = excluded.root_path,
+         display_name = excluded.display_name,
+         workspace_kind = excluded.workspace_kind,
+         branch_name = excluded.branch_name,
+         remote_url = excluded.remote_url,
+         updated_at = excluded.updated_at,
+         archived_at = NULL`);
+        const clearWorkspaceAgents = this.db.prepare(`DELETE FROM workbench_workspace_agents WHERE workspace_id = ?`);
+        const insertWorkspaceAgent = this.db.prepare(`INSERT OR REPLACE INTO workbench_workspace_agents(
+         workspace_id,
+         agent_id,
+         created_at,
+         updated_at
+       ) VALUES(?, ?, ?, ?)`);
+        const archiveStaleProjects = this.db.prepare(`UPDATE workbench_projects
+          SET archived_at = ?, updated_at = ?
+        WHERE archived_at IS NULL`);
+        const archiveStaleWorkspaces = this.db.prepare(`UPDATE workbench_workspaces
+          SET archived_at = ?, updated_at = ?
+        WHERE archived_at IS NULL`);
+        const unarchiveProject = this.db.prepare(`UPDATE workbench_projects
+          SET archived_at = NULL, updated_at = ?
+        WHERE project_id = ?`);
+        const unarchiveWorkspace = this.db.prepare(`UPDATE workbench_workspaces
+          SET archived_at = NULL, updated_at = ?
+        WHERE workspace_id = ?`);
+        const deleteArchivedWorkspaceAgents = this.db.prepare(`DELETE FROM workbench_workspace_agents
+        WHERE workspace_id IN (
+          SELECT workspace_id
+            FROM workbench_workspaces
+           WHERE archived_at IS NOT NULL
+        )`);
+        this.db.transaction(() => {
+            archiveStaleProjects.run(now, now);
+            archiveStaleWorkspaces.run(now, now);
+            for (const project of projects) {
+                upsertProject.run(project.projectId, project.projectKind, project.displayName, project.primaryRootPath, project.remoteUrl, now, now);
+                unarchiveProject.run(now, project.projectId);
+                for (const workspace of project.workspaces) {
+                    const primaryAgentId = workspace.agentIds?.[0] ?? workspace.agentId ?? '';
+                    upsertWorkspace.run(workspace.workspaceId, workspace.workbenchRootId, project.projectId, primaryAgentId, workspace.rootPath, workspace.displayName, workspace.workspaceKind, workspace.branchName, workspace.remoteUrl, now, now);
+                    unarchiveWorkspace.run(now, workspace.workspaceId);
+                    clearWorkspaceAgents.run(workspace.workspaceId);
+                    for (const agentId of workspace.agentIds ?? (workspace.agentId ? [workspace.agentId] : [])) {
+                        insertWorkspaceAgent.run(workspace.workspaceId, agentId, now, now);
+                    }
+                }
+            }
+            deleteArchivedWorkspaceAgents.run();
+        })();
+    }
+}
+function resolveProjectDisplayName(rootPath, inspect) {
+    const remoteDisplayName = inspect.remoteUrl ? normalizeRemoteDisplayName(inspect.remoteUrl) : null;
+    if (remoteDisplayName)
+        return remoteDisplayName;
+    if (inspect.isGit && inspect.repoRoot) {
+        const repoRoot = canonicalizeWorkbenchRootPath(inspect.repoRoot);
+        return getWorkbenchPathBasename(repoRoot) || repoRoot;
+    }
+    return getWorkbenchPathBasename(rootPath) || rootPath;
+}
+function normalizeRemoteDisplayName(remoteUrl) {
+    const trimmed = remoteUrl.trim();
+    if (!trimmed)
+        return null;
+    const scpMatch = trimmed.match(/^[^@]+@([^:]+):(.+)$/);
+    if (scpMatch) {
+        return buildRemoteDisplayName(normalizeRemotePath(scpMatch[2]));
+    }
+    try {
+        const parsed = new URL(trimmed);
+        return buildRemoteDisplayName(normalizeRemotePath(parsed.pathname));
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeRemotePath(value) {
+    return value
+        .trim()
+        .replace(/^\/+/, '')
+        .replace(/\.git$/i, '')
+        .replace(/\/+$/, '');
+}
+function buildRemoteDisplayName(remotePath) {
+    const segments = remotePath.split('/').filter(Boolean);
+    if (segments.length >= 2) {
+        return `${segments[segments.length - 2]}/${segments[segments.length - 1]}`;
+    }
+    return segments[0] ?? null;
+}