gitlab-radiator 5.0.0 → 5.1.0

package/bin/gitlab-radiator.js

@@ -2,4 +2,4 @@
 
 process.env.NODE_ENV = 'production'
 
-await import('../src/app.ts')
+await import('../src/app.js')

package/package.json

@@ -6,7 +6,7 @@
   },
   "type": "module",
   "description": "The missing GitLab build radiator view",
-  "version": "5.0.0",
+  "version": "5.1.0",
   "license": "MIT",
   "bin": {
     "gitlab-radiator": "bin/gitlab-radiator.js"

package/src/app.js

@@ -0,0 +1,74 @@
+import { basicAuth } from "./auth.js";
+import compression from 'compression';
+import { config } from "./config.js";
+import express from 'express';
+import fs from 'fs';
+import { fetchOfflineRunners } from "./gitlab/runners.js";
+import http from 'http';
+import { serveLessAsCss } from "./less.js";
+import { Server } from 'socket.io';
+import { update } from "./gitlab/index.js";
+const app = express();
+const httpServer = new http.Server(app);
+const socketIoServer = new Server(httpServer);
+if (process.env.NODE_ENV !== 'production' && fs.existsSync('./src/dev-assets.ts')) {
+    const { bindDevAssets } = await import("./dev-assets.js");
+    bindDevAssets(app);
+}
+app.disable('x-powered-by');
+app.get('/client.css', serveLessAsCss);
+app.use(express.static('public'));
+app.use(compression());
+app.use(basicAuth(config.auth));
+httpServer.listen(config.port, () => {
+    console.log(`Listening on port *:${config.port}`);
+});
+const globalState = {
+    projects: null,
+    error: null,
+    zoom: config.zoom,
+    projectsOrder: config.projectsOrder,
+    columns: config.columns,
+    horizontal: config.horizontal,
+    rotateRunningPipelines: config.rotateRunningPipelines,
+    groupSuccessfulProjects: config.groupSuccessfulProjects
+};
+socketIoServer.on('connection', (socket) => {
+    socket.emit('state', withDate(globalState));
+});
+async function runUpdate() {
+    try {
+        globalState.projects = await update(config.gitlabs, config.rotateRunningPipelines > 0);
+        globalState.error = await errorIfRunnerOffline();
+        socketIoServer.emit('state', withDate(globalState));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(message);
+        globalState.error = `Failed to communicate with GitLab API: ${message}`;
+        socketIoServer.emit('state', withDate(globalState));
+    }
+    setTimeout(runUpdate, config.interval);
+}
+async function errorIfRunnerOffline() {
+    const offlineRunnersPerGitlab = await Promise.all(config.gitlabs.map(fetchOfflineRunners));
+    const { offline, totalCount } = offlineRunnersPerGitlab.reduce((acc, runner) => {
+        return {
+            offline: acc.offline.concat(runner.offline),
+            totalCount: acc.totalCount + runner.totalCount
+        };
+    }, { offline: [], totalCount: 0 });
+    if (offline.length > 0) {
+        const names = offline.map(r => r.name).sort().join(', ');
+        const counts = offline.length === totalCount ? 'All' : `${offline.length}/${totalCount}`;
+        return `${counts} runners offline: ${names}`;
+    }
+    return null;
+}
+await runUpdate();
+function withDate(state) {
+    return {
+        ...state,
+        now: Date.now()
+    };
+}

package/src/auth.js

@@ -0,0 +1,18 @@
+import authenticate from 'basic-auth';
+export function basicAuth(auth) {
+    if (!auth) {
+        console.log('No authentication configured');
+        return (req, res, next) => next();
+    }
+    console.log('HTTP basic auth enabled');
+    return (req, res, next) => {
+        const { name, pass } = authenticate(req) || {};
+        if (auth.username === name && auth.password === pass) {
+            next();
+        }
+        else {
+            res.setHeader('WWW-Authenticate', 'Basic realm="gitlab-radiator"');
+            res.status(401).end();
+        }
+    };
+}

package/src/config.js

@@ -0,0 +1,80 @@
+import fs from 'fs';
+import os from 'os';
+import yaml from 'js-yaml';
+import { z } from 'zod';
+function expandTilde(path) {
+    return path.replace(/^~($|\/|\\)/, `${os.homedir()}$1`);
+}
+const JobStatusSchema = z.literal(['canceled', 'created', 'failed', 'manual', 'pending', 'running', 'skipped', 'success']);
+const GitlabSchema = z.strictObject({
+    url: z.string().min(1, 'Mandatory gitlab url missing from configuration file'),
+    'access-token': z.string().min(1).optional(),
+    ignoreArchived: z.boolean().default(true),
+    maxNonFailedJobsVisible: z.coerce.number().int().default(999999),
+    branch: z.string().min(1).optional(),
+    caFile: z.string().optional(),
+    offlineRunners: z.literal(['all', 'default', 'none']).default('default'),
+    projects: z.strictObject({
+        excludePipelineStatus: z.array(JobStatusSchema).optional(),
+        include: z.string().min(1).optional(),
+        exclude: z.string().min(1).optional()
+    }).optional()
+}).transform(gitlab => {
+    const accessToken = gitlab['access-token'] || process.env.GITLAB_ACCESS_TOKEN;
+    if (!accessToken) {
+        throw new Error('Mandatory gitlab access token missing from configuration (and none present at GITLAB_ACCESS_TOKEN env variable)');
+    }
+    const { url, ignoreArchived, maxNonFailedJobsVisible, caFile, branch, offlineRunners, projects } = gitlab;
+    const ca = caFile && fs.existsSync(caFile) ? fs.readFileSync(caFile, 'utf-8') : undefined;
+    return {
+        url,
+        ignoreArchived,
+        maxNonFailedJobsVisible,
+        branch,
+        ca,
+        offlineRunners,
+        'access-token': accessToken,
+        projects
+    };
+});
+const OrderSchema = z.literal(['status', 'name', 'id', 'nameWithoutNamespace', 'group']);
+const ConfigSchema = z.strictObject({
+    interval: z.coerce.number().default(10).transform(sec => sec * 1000),
+    port: z.coerce.number().int().default(3000),
+    zoom: z.coerce.number().default(1.0),
+    columns: z.coerce.number().int().default(1),
+    horizontal: z.boolean().default(false),
+    rotateRunningPipelines: z.coerce.number().min(0).default(0).transform(sec => sec * 1000),
+    groupSuccessfulProjects: z.boolean().default(false),
+    projectsOrder: z.array(OrderSchema).default(['name']),
+    gitlabs: z.array(GitlabSchema).min(1, { message: 'Mandatory gitlab properties missing from configuration file' }),
+    colors: z.strictObject({
+        background: z.string(),
+        'created-background': z.string(),
+        'created-text': z.string(),
+        'dark-text': z.string(),
+        'error-message-background': z.string(),
+        'error-message-text': z.string(),
+        'failed-background': z.string(),
+        'failed-text': z.string(),
+        'group-background': z.string(),
+        'light-text': z.string(),
+        'pending-background': z.string(),
+        'pending-text': z.string(),
+        'project-background': z.string(),
+        'running-background': z.string(),
+        'running-text': z.string(),
+        'skipped-background': z.string(),
+        'skipped-text': z.string(),
+        'success-background': z.string(),
+        'success-text': z.string()
+    }).partial().optional(),
+    auth: z.strictObject({
+        username: z.string(),
+        password: z.string()
+    }).optional()
+});
+const configFile = expandTilde(process.env.GITLAB_RADIATOR_CONFIG || '~/.gitlab-radiator.yml');
+const yamlContent = fs.readFileSync(configFile, 'utf8');
+const rawConfig = yaml.load(yamlContent);
+export const config = ConfigSchema.parse(rawConfig);

package/src/dev-assets.js

@@ -0,0 +1,11 @@
+import { createRequire } from 'module';
+import webpack from 'webpack';
+import webpackDevMiddleware from 'webpack-dev-middleware';
+import webpackHotMiddleware from 'webpack-hot-middleware';
+const require = createRequire(import.meta.url);
+export function bindDevAssets(app) {
+    const config = require('../webpack.dev.cjs');
+    const compiler = webpack(config);
+    app.use(webpackDevMiddleware(compiler));
+    app.use(webpackHotMiddleware(compiler));
+}

package/src/gitlab/client.js

@@ -0,0 +1,20 @@
+import axios from 'axios';
+import https from 'https';
+import url from 'url';
+export function gitlabRequest(pathStr, params, gitlab) {
+    return lazyClient(gitlab).get(pathStr, { params: params || {} });
+}
+const clients = new Map();
+function lazyClient(gitlab) {
+    let client = clients.get(gitlab.url);
+    if (!client) {
+        client = axios.create({
+            baseURL: url.resolve(gitlab.url, '/api/v4/'),
+            headers: { 'PRIVATE-TOKEN': gitlab['access-token'] },
+            httpsAgent: new https.Agent({ keepAlive: true, ca: gitlab.ca }),
+            timeout: 30 * 1000
+        });
+        clients.set(gitlab.url, client);
+    }
+    return client;
+}

package/src/gitlab/index.js

@@ -0,0 +1,49 @@
+import { fetchLatestPipelines } from "./pipelines.js";
+import { fetchProjects } from "./projects.js";
+export async function update(gitlabs, prioritizeRunningPipelines) {
+    const projectsWithPipelines = await loadProjectsWithPipelines(gitlabs, prioritizeRunningPipelines);
+    return projectsWithPipelines
+        .filter((project) => project.pipelines.length > 0);
+}
+async function loadProjectsWithPipelines(gitlabs, prioritizeRunningPipelines) {
+    const allProjectsWithPipelines = [];
+    await Promise.all(gitlabs.map(async (gitlab) => {
+        const projects = (await fetchProjects(gitlab))
+            .map(project => ({
+            ...project,
+            maxNonFailedJobsVisible: gitlab.maxNonFailedJobsVisible
+        }));
+        for (const project of projects) {
+            allProjectsWithPipelines.push(await projectWithPipelines(project, gitlab, prioritizeRunningPipelines));
+        }
+    }));
+    return allProjectsWithPipelines;
+}
+async function projectWithPipelines(project, gitlab, prioritizeRunningPipelines) {
+    const pipelines = filterOutEmpty(await fetchLatestPipelines(project.id, gitlab, prioritizeRunningPipelines))
+        .filter(excludePipelineStatusFilter(gitlab));
+    const status = defaultBranchStatus(project, pipelines);
+    return {
+        ...project,
+        maxNonFailedJobsVisible: gitlab.maxNonFailedJobsVisible,
+        pipelines,
+        status
+    };
+}
+function defaultBranchStatus(project, pipelines) {
+    const [head] = pipelines
+        .filter(({ ref }) => ref === project.default_branch)
+        .map(({ status }) => status);
+    return head;
+}
+function filterOutEmpty(pipelines) {
+    return pipelines.filter(pipeline => pipeline.stages);
+}
+function excludePipelineStatusFilter(gitlab) {
+    return (pipeline) => {
+        if (gitlab.projects?.excludePipelineStatus) {
+            return !gitlab.projects.excludePipelineStatus.includes(pipeline.status);
+        }
+        return true;
+    };
+}

package/src/gitlab/pipelines.js

@@ -0,0 +1,125 @@
+import { gitlabRequest } from "./client.js";
+export async function fetchLatestPipelines(projectId, gitlab, prioritizeRunningPipelines) {
+    const pipelines = await fetchLatestAndMasterPipeline(projectId, gitlab, prioritizeRunningPipelines);
+    const pipelinesWithStages = [];
+    for (const { id, ref, status } of pipelines) {
+        const { commit, stages } = await fetchJobs(projectId, id, gitlab);
+        const downstreamStages = await fetchDownstreamJobs(projectId, id, gitlab);
+        pipelinesWithStages.push({
+            id,
+            ref,
+            status,
+            commit,
+            stages: stages.concat(downstreamStages)
+        });
+    }
+    return pipelinesWithStages;
+}
+async function fetchLatestAndMasterPipeline(projectId, gitlab, prioritizeRunningPipelines) {
+    const options = {
+        per_page: 100,
+        ...(gitlab.branch ? { ref: gitlab.branch } : {})
+    };
+    const pipelines = await fetchPipelines(projectId, gitlab, options);
+    if (pipelines.length === 0) {
+        return [];
+    }
+    const runningPipelines = pipelines.filter(pipeline => pipeline.status === 'running');
+    if (runningPipelines.length > 1 && prioritizeRunningPipelines) {
+        return runningPipelines;
+    }
+    const latestPipeline = pipelines.slice(0, 1);
+    if (latestPipeline[0].ref === 'master') {
+        return latestPipeline;
+    }
+    const latestMasterPipeline = pipelines.filter(p => p.ref === 'master').slice(0, 1);
+    if (latestMasterPipeline.length > 0) {
+        return latestPipeline.concat(latestMasterPipeline);
+    }
+    const masterPipelines = await fetchPipelines(projectId, gitlab, { per_page: 50, ref: 'master' });
+    return latestPipeline.concat(masterPipelines.slice(0, 1));
+}
+async function fetchPipelines(projectId, gitlab, params) {
+    const { data: pipelines } = await gitlabRequest(`/projects/${projectId}/pipelines`, params, gitlab);
+    return pipelines.filter(pipeline => pipeline.status !== 'skipped');
+}
+async function fetchDownstreamJobs(projectId, pipelineId, gitlab) {
+    const { data: gitlabBridgeJobs } = await gitlabRequest(`/projects/${projectId}/pipelines/${pipelineId}/bridges`, { per_page: 100 }, gitlab);
+    const childPipelines = gitlabBridgeJobs.filter((bridge) => bridge.downstream_pipeline !== null && bridge.downstream_pipeline.status !== 'skipped');
+    const downstreamStages = [];
+    for (const childPipeline of childPipelines) {
+        const { stages } = await fetchJobs(childPipeline.downstream_pipeline.project_id, childPipeline.downstream_pipeline.id, gitlab);
+        downstreamStages.push(stages.map((stage) => ({
+            ...stage,
+            name: `${childPipeline.stage}:${stage.name}`
+        })));
+    }
+    return downstreamStages.flat();
+}
+async function fetchJobs(projectId, pipelineId, gitlab) {
+    const { data: gitlabJobs } = await gitlabRequest(`/projects/${projectId}/pipelines/${pipelineId}/jobs?include_retried=true`, { per_page: 100 }, gitlab);
+    if (gitlabJobs.length === 0) {
+        return { commit: null, stages: [] };
+    }
+    const commit = findCommit(gitlabJobs);
+    // Map jobs and sort by id
+    const mappedJobs = gitlabJobs
+        .map(job => ({
+        id: job.id,
+        status: job.status,
+        stage: job.stage,
+        name: job.name,
+        startedAt: job.started_at,
+        finishedAt: job.finished_at,
+        url: job.web_url
+    }))
+        .sort((a, b) => a.id - b.id);
+    // Group by stage
+    const jobsByStage = new Map();
+    for (const job of mappedJobs) {
+        const stageJobs = jobsByStage.get(job.stage) || [];
+        stageJobs.push(job);
+        jobsByStage.set(job.stage, stageJobs);
+    }
+    // Convert to stages array
+    const stages = Array.from(jobsByStage.entries()).map(([name, jobs]) => ({
+        name,
+        jobs: mergeRetriedJobs(removeStageProperty(jobs)).sort(byName)
+    }));
+    return {
+        commit,
+        stages
+    };
+}
+function byName(a, b) {
+    return a.name.localeCompare(b.name);
+}
+function findCommit(jobs) {
+    const [job] = jobs.filter(j => j.commit);
+    if (!job || !job.commit) {
+        return null;
+    }
+    return {
+        title: job.commit.title,
+        author: job.commit.author_name
+    };
+}
+function mergeRetriedJobs(jobs) {
+    return jobs.reduce((mergedJobs, job) => {
+        const index = mergedJobs.findIndex(mergedJob => mergedJob.name === job.name);
+        if (index >= 0) {
+            mergedJobs[index] = job;
+        }
+        else {
+            mergedJobs.push(job);
+        }
+        return mergedJobs;
+    }, []);
+}
+function removeStageProperty(jobs) {
+    return jobs.map(job => {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { stage, ...rest } = job;
+        return rest;
+    });
+}

package/src/gitlab/projects.js

@@ -0,0 +1,65 @@
+import { gitlabRequest } from "./client.js";
+export async function fetchProjects(gitlab) {
+    const projects = await fetchOwnProjects(gitlab);
+    return projects
+        // Ignore projects for which CI/CD is not enabled
+        .filter(project => project.jobs_enabled)
+        .map(projectMapper)
+        .filter(includeRegexFilter(gitlab))
+        .filter(excludeRegexFilter(gitlab))
+        .filter(archivedFilter(gitlab));
+}
+async function fetchOwnProjects(gitlab) {
+    const projects = [];
+    const SAFETY_MAX_PAGE = 10;
+    for (let page = 1; page <= SAFETY_MAX_PAGE; page += 1) {
+        const { data, headers } = await gitlabRequest('/projects', { page, per_page: 100, membership: true }, gitlab);
+        projects.push(...data);
+        if (data.length === 0 || !headers['x-next-page']) {
+            break;
+        }
+    }
+    return projects;
+}
+function projectMapper(project) {
+    return {
+        id: project.id,
+        name: project.path_with_namespace,
+        nameWithoutNamespace: project.path,
+        group: getGroupName(project),
+        archived: project.archived,
+        default_branch: project.default_branch || 'master',
+        url: project.web_url,
+        topics: (project.topics || []).map((t) => t.toLowerCase())
+    };
+}
+function getGroupName(project) {
+    const pathWithNameSpace = project.path_with_namespace;
+    return pathWithNameSpace.split('/')[0];
+}
+function includeRegexFilter(gitlab) {
+    return (project) => {
+        if (gitlab.projects?.include) {
+            const includeRegex = new RegExp(gitlab.projects.include, "i");
+            return includeRegex.test(project.name);
+        }
+        return true;
+    };
+}
+function excludeRegexFilter(gitlab) {
+    return (project) => {
+        if (gitlab.projects?.exclude) {
+            const excludeRegex = new RegExp(gitlab.projects.exclude, "i");
+            return !excludeRegex.test(project.name);
+        }
+        return true;
+    };
+}
+function archivedFilter(gitlab) {
+    return (project) => {
+        if (gitlab.ignoreArchived) {
+            return !project.archived;
+        }
+        return true;
+    };
+}

package/src/gitlab/runners.js

@@ -0,0 +1,23 @@
+import { gitlabRequest } from "./client.js";
+export async function fetchOfflineRunners(gitlab) {
+    if (gitlab.offlineRunners === 'none') {
+        return {
+            offline: [],
+            totalCount: 0
+        };
+    }
+    const runners = await fetchRunners(gitlab);
+    const offline = runners.filter(r => r.status === 'offline');
+    return {
+        offline,
+        totalCount: runners.length
+    };
+}
+async function fetchRunners(gitlab) {
+    const runnersApi = gitlab.offlineRunners === 'all' ? '/runners/all' : '/runners';
+    const { data: runners } = await gitlabRequest(runnersApi, null, gitlab);
+    return runners.map(r => ({
+        name: r.description || r.id.toString(),
+        status: r.status
+    }));
+}

package/src/less.js

@@ -0,0 +1,28 @@
+import fs from 'fs';
+import less from 'less';
+import path from 'path';
+import { config } from "./config.js";
+const filename = path.join('public', 'client.less');
+export async function serveLessAsCss(_req, res) {
+    try {
+        const source = await fs.promises.readFile(filename, 'utf-8');
+        const { css } = await less.render(withColorOverrides(source), { filename });
+        res.setHeader('content-type', 'text/css');
+        res.send(css);
+    }
+    catch (err) {
+        console.error('Failed to render client.less', err);
+        res.sendStatus(500);
+    }
+}
+function withColorOverrides(source) {
+    const { colors } = config;
+    if (!colors) {
+        return source;
+    }
+    let colorLess = '';
+    Object.keys(colors).forEach((stateName) => {
+        colorLess += `@${stateName}-color:${colors[stateName]};`;
+    });
+    return source + colorLess;
+}

package/src/tsconfig.build.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../../src/app.ts","../../src/auth.ts","../../src/config.ts","../../src/dev-assets.ts","../../src/less.ts","../../src/common/gitlab-types.d.ts","../../src/gitlab/client.ts","../../src/gitlab/index.ts","../../src/gitlab/pipelines.ts","../../src/gitlab/projects.ts","../../src/gitlab/runners.ts"],"version":"5.9.3"}

package/src/app.ts

@@ -1,85 +0,0 @@
-import {basicAuth} from './auth.ts'
-import compression from 'compression'
-import {config} from './config.ts'
-import express from 'express'
-import fs from 'fs'
-import {fetchOfflineRunners} from './gitlab/runners.ts'
-import http from 'http'
-import {serveLessAsCss} from './less.ts'
-import {Server} from 'socket.io'
-import {update} from './gitlab/index.ts'
-import type {GlobalState} from './common/gitlab-types.d.ts'
-
-const app = express()
-const httpServer = new http.Server(app)
-const socketIoServer = new Server(httpServer)
-
-if (process.env.NODE_ENV !== 'production' && fs.existsSync('./src/dev-assets.ts')) {
-  const {bindDevAssets} = await import('./dev-assets.ts')
-  bindDevAssets(app)
-}
-
-app.disable('x-powered-by')
-app.get('/client.css', serveLessAsCss)
-app.use(express.static('public'))
-app.use(compression())
-app.use(basicAuth(config.auth))
-
-httpServer.listen(config.port, () => {
-  console.log(`Listening on port *:${config.port}`)
-})
-
-const globalState: Omit<GlobalState, 'now'> = {
-  projects: null,
-  error: null,
-  zoom: config.zoom,
-  projectsOrder: config.projectsOrder,
-  columns: config.columns,
-  horizontal: config.horizontal,
-  rotateRunningPipelines: config.rotateRunningPipelines,
-  groupSuccessfulProjects: config.groupSuccessfulProjects
-}
-
-socketIoServer.on('connection', (socket) => {
-  socket.emit('state', withDate(globalState))
-})
-
-async function runUpdate() {
-  try {
-    globalState.projects = await update(config.gitlabs, config.rotateRunningPipelines > 0)
-    globalState.error = await errorIfRunnerOffline()
-    socketIoServer.emit('state', withDate(globalState))
-  } catch (error: unknown) {
-    const message = error instanceof Error ? error.message : String(error)
-    console.error(message)
-    globalState.error = `Failed to communicate with GitLab API: ${message}`
-    socketIoServer.emit('state', withDate(globalState))
-  }
-  setTimeout(runUpdate, config.interval)
-}
-
-async function errorIfRunnerOffline() {
-  const offlineRunnersPerGitlab = await Promise.all(config.gitlabs.map(fetchOfflineRunners))
-  const {offline, totalCount} = offlineRunnersPerGitlab.reduce((acc, runner) => {
-    return {
-      offline: acc.offline.concat(runner.offline),
-      totalCount: acc.totalCount + runner.totalCount
-    }
-  }, {offline: [], totalCount: 0})
-
-  if (offline.length > 0) {
-    const names = offline.map(r => r.name).sort().join(', ')
-    const counts = offline.length === totalCount ? 'All' : `${offline.length}/${totalCount}`
-    return `${counts} runners offline: ${names}`
-  }
-  return null
-}
-
-await runUpdate()
-
-function withDate(state: Omit<GlobalState, 'now'>): GlobalState {
-  return {
-    ...state,
-    now: Date.now()
-  }
-}

package/src/auth.ts

@@ -1,20 +0,0 @@
-import authenticate from 'basic-auth'
-import type {NextFunction, Request, Response} from 'express'
-
-export function basicAuth(auth: {username: string; password: string } | undefined) {
-  if (!auth) {
-    console.log('No authentication configured')
-    return (req: Request, res: Response, next: NextFunction) => next()
-  }
-
-  console.log('HTTP basic auth enabled')
-  return (req: Request, res: Response, next: NextFunction) => {
-    const {name, pass} = authenticate(req) || ({} as {name?: string; pass?: string})
-    if (auth.username === name && auth.password === pass) {
-      next()
-    } else {
-      res.setHeader('WWW-Authenticate', 'Basic realm="gitlab-radiator"')
-      res.status(401).end()
-    }
-  }
-}

package/src/common/gitlab-types.d.ts

@@ -1,57 +0,0 @@
-export interface GlobalState {
-  columns: number
-  error: string | null
-  groupSuccessfulProjects: boolean
-  horizontal: boolean
-  rotateRunningPipelines: number
-  projects: Project[] | null
-  projectsOrder: Array<ProjectsOrder>
-  zoom: number
-  now: number
-}
-
-export interface Project {
-  archived: boolean
-  group: string
-  id: number
-  name: string
-  nameWithoutNamespace: string
-  topics: string[]
-  url: string
-  default_branch: string
-  pipelines: Pipeline[]
-  maxNonFailedJobsVisible: number
-  status: JobStatus
-}
-
-// Keys that represent either string or number values, and can be compared with < and >
-export type ProjectsOrder = keyof Pick<Project, 'status' | 'name' | 'id' | 'nameWithoutNamespace' | 'group'>
-
-export interface Pipeline {
-  commit: Commit | null
-  id: number
-  ref: string
-  stages: Stage[]
-  status: JobStatus
-}
-
-export interface Commit {
-  title: string
-  author: string
-}
-
-export interface Stage {
-  jobs: Job[]
-  name: string
-}
-
-export interface Job {
-  finishedAt: string | null
-  id: number
-  name: string
-  startedAt: string | null
-  status: JobStatus
-  url: string
-}
-
-export type JobStatus = 'canceled' | 'created' | 'failed' | 'manual' | 'pending' | 'running' | 'skipped' | 'success'

package/src/config.ts

@@ -1,95 +0,0 @@
-import fs from 'fs'
-import os from 'os'
-import yaml from 'js-yaml'
-import {z} from 'zod'
-
-function expandTilde(path: string) {
-  return path.replace(/^~($|\/|\\)/, `${os.homedir()}$1`)
-}
-
-const JobStatusSchema = z.literal(['canceled', 'created', 'failed', 'manual', 'pending', 'running', 'skipped', 'success'])
-export type JobStatus = z.infer<typeof JobStatusSchema>
-
-const GitlabSchema = z.strictObject({
-  url: z.string().min(1, 'Mandatory gitlab url missing from configuration file'),
-  'access-token': z.string().min(1).optional(),
-  ignoreArchived: z.boolean().default(true),
-  maxNonFailedJobsVisible: z.coerce.number().int().default(999999),
-  branch: z.string().min(1).optional(),
-  caFile: z.string().optional(),
-  offlineRunners: z.literal(['all', 'default', 'none']).default('default'),
-  projects: z.strictObject({
-    excludePipelineStatus: z.array(JobStatusSchema).optional(),
-    include: z.string().min(1).optional(),
-    exclude: z.string().min(1).optional()
-  }).optional()
-}).transform(gitlab => {
-  const accessToken = gitlab['access-token'] || process.env.GITLAB_ACCESS_TOKEN
-  if (!accessToken) {
-    throw new Error('Mandatory gitlab access token missing from configuration (and none present at GITLAB_ACCESS_TOKEN env variable)')
-  }
-
-  const {url, ignoreArchived, maxNonFailedJobsVisible, caFile, branch,offlineRunners, projects} = gitlab
-  const ca = caFile && fs.existsSync(caFile) ? fs.readFileSync(caFile, 'utf-8') : undefined
-
-  return {
-    url,
-    ignoreArchived,
-    maxNonFailedJobsVisible,
-    branch,
-    ca,
-    offlineRunners,
-    'access-token': accessToken,
-    projects
-  }
-})
-
-export type Gitlab = z.infer<typeof GitlabSchema>
-
-const ColorSchema = z.literal([
-  'background',
-  'created-background',
-  'created-text',
-  'dark-text',
-  'error-message-background',
-  'error-message-text',
-  'failed-background',
-  'failed-text',
-  'group-background',
-  'light-text',
-  'pending-background',
-  'pending-text',
-  'project-background',
-  'running-background',
-  'running-text',
-  'skipped-background',
-  'skipped-text',
-  'success-background',
-  'success-text'
-])
-
-const OrderSchema = z.literal(['status', 'name', 'id', 'nameWithoutNamespace', 'group'])
-
-const ConfigSchema = z.strictObject({
-  interval: z.coerce.number().default(10).transform(sec => sec * 1000),
-  port: z.coerce.number().int().default(3000),
-  zoom: z.coerce.number().default(1.0),
-  columns: z.coerce.number().int().default(1),
-  horizontal: z.boolean().default(false),
-  rotateRunningPipelines: z.coerce.number().min(0).default(0).transform(sec => sec * 1000),
-  groupSuccessfulProjects: z.boolean().default(false),
-  projectsOrder: z.array(OrderSchema).default(['name']),
-  gitlabs: z.array(GitlabSchema).min(1, {message: 'Mandatory gitlab properties missing from configuration file'}),
-  colors: z.record(ColorSchema, z.string()).optional(),
-  auth: z.strictObject({
-    username: z.string(),
-    password: z.string()
-  }).optional()
-})
-
-export type Config = z.infer<typeof ConfigSchema>
-
-const configFile = expandTilde(process.env.GITLAB_RADIATOR_CONFIG || '~/.gitlab-radiator.yml')
-const yamlContent = fs.readFileSync(configFile, 'utf8')
-const rawConfig = yaml.load(yamlContent)
-export const config = ConfigSchema.parse(rawConfig)

package/src/gitlab/client.ts

@@ -1,34 +0,0 @@
-import axios from 'axios'
-import https from 'https'
-import url from 'url'
-import type {AxiosInstance} from 'axios'
-import type {Gitlab} from '../config'
-
-export type PartialGitlab = Pick<Gitlab, 'url' | 'access-token' | 'ca' | 'branch'>
-
-export interface GitlabRequestParams {
-  page?: number
-  per_page?: number
-  membership?: boolean
-  ref?: string
-}
-
-export function gitlabRequest<T>(pathStr: string, params: GitlabRequestParams | null, gitlab: PartialGitlab) {
-  return lazyClient(gitlab).get<T>(pathStr, {params: params || {}})
-}
-
-const clients = new Map<string, AxiosInstance>()
-
-function lazyClient(gitlab: PartialGitlab) {
-  let client = clients.get(gitlab.url)
-  if (!client) {
-    client = axios.create({
-        baseURL: url.resolve(gitlab.url, '/api/v4/'),
-        headers: {'PRIVATE-TOKEN': gitlab['access-token']},
-        httpsAgent: new https.Agent({keepAlive: true, ca: gitlab.ca}),
-        timeout: 30 * 1000
-      })
-    clients.set(gitlab.url, client)
-  }
-  return client
-}

package/src/gitlab/index.ts

@@ -1,59 +0,0 @@
-import {fetchLatestPipelines} from './pipelines.ts'
-import {fetchProjects} from './projects.ts'
-import type {Gitlab} from '../config.ts'
-import type {PartialProject} from './projects.ts'
-import type {Pipeline, Project} from '../common/gitlab-types.d.ts'
-
-export async function update(gitlabs: Gitlab[], prioritizeRunningPipelines: boolean): Promise<Project[]> {
-  const projectsWithPipelines = await loadProjectsWithPipelines(gitlabs, prioritizeRunningPipelines)
-  return projectsWithPipelines
-    .filter((project: Project) => project.pipelines.length > 0)
-}
-
-async function loadProjectsWithPipelines(gitlabs: Gitlab[], prioritizeRunningPipelines: boolean): Promise<Project[]> {
-  const allProjectsWithPipelines: Project[] = []
-  await Promise.all(gitlabs.map(async gitlab => {
-    const projects = (await fetchProjects(gitlab))
-      .map(project => ({
-        ...project,
-        maxNonFailedJobsVisible: gitlab.maxNonFailedJobsVisible
-      }))
-
-    for (const project of projects) {
-      allProjectsWithPipelines.push(await projectWithPipelines(project, gitlab, prioritizeRunningPipelines))
-    }
-  }))
-  return allProjectsWithPipelines
-}
-
-async function projectWithPipelines(project: PartialProject, gitlab: Gitlab, prioritizeRunningPipelines: boolean): Promise<Project> {
-  const pipelines = filterOutEmpty(await fetchLatestPipelines(project.id, gitlab, prioritizeRunningPipelines))
-    .filter(excludePipelineStatusFilter(gitlab))
-  const status = defaultBranchStatus(project, pipelines)
-  return {
-    ...project,
-    maxNonFailedJobsVisible: gitlab.maxNonFailedJobsVisible,
-    pipelines,
-    status
-  }
-}
-
-function defaultBranchStatus(project: PartialProject, pipelines: Pipeline[]) {
-  const [head] = pipelines
-    .filter(({ref}) => ref === project.default_branch)
-    .map(({status}) => status)
-  return head
-}
-
-function filterOutEmpty(pipelines: Pipeline[]): Pipeline[] {
-  return pipelines.filter(pipeline => pipeline.stages)
-}
-
-function excludePipelineStatusFilter(gitlab: Gitlab): (pipeline: Pipeline) => boolean {
-  return (pipeline: Pipeline) => {
-    if (gitlab.projects?.excludePipelineStatus) {
-      return !gitlab.projects.excludePipelineStatus.includes(pipeline.status)
-    }
-    return true
-  }
-}

package/src/gitlab/pipelines.ts

@@ -1,178 +0,0 @@
-import {gitlabRequest} from './client.ts'
-import type {Commit, Job, JobStatus, Pipeline, Stage} from '../common/gitlab-types.d.ts'
-import type {GitlabRequestParams, PartialGitlab} from './client.ts'
-
-interface GitlabPipelineResponse {
-  id: number
-  ref: string
-  status: JobStatus
-}
-
-// project_id is undocumented by docs.gitlab.com but is present in the API response
-interface GitlabDownstreamPipeline {
-  id: number
-  project_id: number
-  status: JobStatus
-}
-
-interface GitlabPipelineTriggerResponse {
-  stage: string
-  downstream_pipeline: GitlabDownstreamPipeline | null
-}
-
-interface GitlabJobResponse {
-  id: number
-  name: string
-  stage: string
-  status: JobStatus
-  started_at: string | null
-  finished_at: string | null
-  web_url: string
-  commit: {
-    title: string
-    author_name: string
-  } | null
-}
-
-export async function fetchLatestPipelines(projectId: number, gitlab: PartialGitlab, prioritizeRunningPipelines: boolean): Promise<Pipeline[]> {
-  const pipelines = await fetchLatestAndMasterPipeline(projectId, gitlab, prioritizeRunningPipelines)
-
-  const pipelinesWithStages: Pipeline[] = []
-  for (const {id, ref, status} of pipelines) {
-    const {commit, stages} = await fetchJobs(projectId, id, gitlab)
-    const downstreamStages = await fetchDownstreamJobs(projectId, id, gitlab)
-    pipelinesWithStages.push({
-      id,
-      ref,
-      status,
-      commit,
-      stages: stages.concat(downstreamStages)
-    })
-  }
-  return pipelinesWithStages
-}
-
-async function fetchLatestAndMasterPipeline(projectId: number, gitlab: PartialGitlab, prioritizeRunningPipelines: boolean): Promise<GitlabPipelineResponse[]> {
-  const options = {
-    per_page: 100,
-    ...(gitlab.branch ? {ref: gitlab.branch} : {})
-  }
-  const pipelines = await fetchPipelines(projectId, gitlab, options)
-  if (pipelines.length === 0) {
-    return []
-  }
-
-  const runningPipelines = pipelines.filter(pipeline => pipeline.status === 'running')
-  if (runningPipelines.length > 1 && prioritizeRunningPipelines) {
-    return runningPipelines
-  }
-
-  const latestPipeline = pipelines.slice(0, 1)
-  if (latestPipeline[0].ref === 'master') {
-    return latestPipeline
-  }
-  const latestMasterPipeline = pipelines.filter(p => p.ref === 'master').slice(0, 1)
-  if (latestMasterPipeline.length > 0) {
-    return latestPipeline.concat(latestMasterPipeline)
-  }
-  const masterPipelines = await fetchPipelines(projectId, gitlab, {per_page: 50, ref: 'master'})
-  return latestPipeline.concat(masterPipelines.slice(0, 1))
-}
-
-async function fetchPipelines(projectId: number, gitlab: PartialGitlab, params: GitlabRequestParams) {
-  const {data: pipelines} = await gitlabRequest<GitlabPipelineResponse[]>(`/projects/${projectId}/pipelines`, params, gitlab)
-  return pipelines.filter(pipeline => pipeline.status !== 'skipped')
-}
-
-async function fetchDownstreamJobs(projectId: number, pipelineId: number, gitlab: PartialGitlab): Promise<Stage[]> {
-  const {data: gitlabBridgeJobs} = await gitlabRequest<GitlabPipelineTriggerResponse[]>(`/projects/${projectId}/pipelines/${pipelineId}/bridges`, {per_page: 100}, gitlab)
-  const childPipelines = gitlabBridgeJobs.filter((bridge): bridge is GitlabPipelineTriggerResponse & {downstream_pipeline: GitlabDownstreamPipeline} =>
-    bridge.downstream_pipeline !== null && bridge.downstream_pipeline.status !== 'skipped'
-  )
-
-  const downstreamStages: Stage[][] = []
-  for(const childPipeline of childPipelines) {
-    const {stages} = await fetchJobs(childPipeline.downstream_pipeline.project_id, childPipeline.downstream_pipeline.id, gitlab)
-    downstreamStages.push(stages.map((stage: Stage) => ({
-      ...stage,
-      name: `${childPipeline.stage}:${stage.name}`
-    })))
-  }
-  return downstreamStages.flat()
-}
-
-async function fetchJobs(projectId: number, pipelineId: number, gitlab: PartialGitlab): Promise<{commit: Commit | null, stages: Stage[]}> {
-  const {data: gitlabJobs} = await gitlabRequest<GitlabJobResponse[]>(`/projects/${projectId}/pipelines/${pipelineId}/jobs?include_retried=true`, {per_page: 100}, gitlab)
-  if (gitlabJobs.length === 0) {
-    return {commit: null, stages: []}
-  }
-
-  const commit = findCommit(gitlabJobs)
-
-  // Map jobs and sort by id
-  const mappedJobs = gitlabJobs
-    .map(job => ({
-      id: job.id,
-      status: job.status,
-      stage: job.stage,
-      name: job.name,
-      startedAt: job.started_at,
-      finishedAt: job.finished_at,
-      url: job.web_url
-    } satisfies Job & {stage: string}))
-    .sort((a, b) => a.id - b.id)
-
-  // Group by stage
-  const jobsByStage = new Map<string, Array<Job & {stage: string}>>()
-  for (const job of mappedJobs) {
-    const stageJobs = jobsByStage.get(job.stage) || []
-    stageJobs.push(job)
-    jobsByStage.set(job.stage, stageJobs)
-  }
-
-  // Convert to stages array
-  const stages = Array.from(jobsByStage.entries()).map(([name, jobs]) => ({
-    name,
-    jobs: mergeRetriedJobs(removeStageProperty(jobs)).sort(byName)
-  }))
-
-  return {
-    commit,
-    stages
-  }
-}
-
-function byName(a: Job, b: Job): number {
-  return a.name.localeCompare(b.name)
-}
-
-function findCommit(jobs: GitlabJobResponse[]): Commit | null {
-  const [job] = jobs.filter(j => j.commit)
-  if (!job || !job.commit) {
-    return null
-  }
-  return {
-    title: job.commit.title,
-    author: job.commit.author_name
-  }
-}
-
-function mergeRetriedJobs(jobs: Job[]): Job[] {
-  return jobs.reduce((mergedJobs: Job[], job: Job) => {
-    const index = mergedJobs.findIndex(mergedJob => mergedJob.name === job.name)
-    if (index >= 0) {
-      mergedJobs[index] = job
-    } else {
-      mergedJobs.push(job)
-    }
-    return mergedJobs
-  }, [])
-}
-
-function removeStageProperty(jobs: Array<Job & {stage: string}>): Job[] {
-  return jobs.map(job => {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const {stage, ...rest} = job
-    return rest
-  })
-}

package/src/gitlab/projects.ts

@@ -1,87 +0,0 @@
-import {gitlabRequest} from './client.ts'
-import type {Gitlab} from '../config.ts'
-import type {Project} from '../common/gitlab-types.d.ts'
-
-export type PartialProject = Omit<Project, 'pipelines' | 'maxNonFailedJobsVisible' | 'status'>
-
-interface GitlabProjectResponse {
-  id: number
-  path: string
-  path_with_namespace: string
-  archived: boolean
-  default_branch: string | null
-  web_url: string
-  topics?: string[]
-  jobs_enabled: boolean
-}
-
-export async function fetchProjects(gitlab: Gitlab): Promise<PartialProject[]> {
-  const projects = await fetchOwnProjects(gitlab)
-  return projects
-    // Ignore projects for which CI/CD is not enabled
-    .filter(project => project.jobs_enabled)
-    .map(projectMapper)
-    .filter(includeRegexFilter(gitlab))
-    .filter(excludeRegexFilter(gitlab))
-    .filter(archivedFilter(gitlab))
-}
-
-async function fetchOwnProjects(gitlab: Gitlab) {
-  const projects: GitlabProjectResponse[] = []
-  const SAFETY_MAX_PAGE = 10
-  for (let page = 1; page <= SAFETY_MAX_PAGE; page += 1) {
-    const {data, headers} = await gitlabRequest<GitlabProjectResponse[]>('/projects', {page, per_page: 100, membership: true}, gitlab)
-    projects.push(...data)
-    if (data.length === 0 || !headers['x-next-page']) {
-      break
-    }
-  }
-  return projects
-}
-
-function projectMapper(project: GitlabProjectResponse): PartialProject {
-  return {
-    id: project.id,
-    name: project.path_with_namespace,
-    nameWithoutNamespace: project.path,
-    group: getGroupName(project),
-    archived: project.archived,
-    default_branch: project.default_branch || 'master',
-    url: project.web_url,
-    topics: (project.topics || []).map((t: string) => t.toLowerCase())
-  }
-}
-
-function getGroupName(project: GitlabProjectResponse) {
-  const pathWithNameSpace = project.path_with_namespace
-  return pathWithNameSpace.split('/')[0]
-}
-
-function includeRegexFilter(gitlab: Gitlab) {
-  return (project: PartialProject) => {
-    if (gitlab.projects?.include) {
-      const includeRegex = new RegExp(gitlab.projects.include, "i")
-      return includeRegex.test(project.name)
-    }
-    return true
-  }
-}
-
-function excludeRegexFilter(gitlab: Gitlab) {
-  return (project: PartialProject) => {
-    if (gitlab.projects?.exclude) {
-      const excludeRegex = new RegExp(gitlab.projects.exclude, "i")
-      return !excludeRegex.test(project.name)
-    }
-    return true
-  }
-}
-
-function archivedFilter(gitlab: Gitlab) {
-  return (project: PartialProject) => {
-    if (gitlab.ignoreArchived) {
-      return !project.archived
-    }
-    return true
-  }
-}

package/src/gitlab/runners.ts

@@ -1,35 +0,0 @@
-import {gitlabRequest} from './client.ts'
-import type {Gitlab} from '../config.ts'
-
-type RunnerStatus = 'online' | 'offline' | 'stale' | 'never_contacted'
-
-export async function fetchOfflineRunners(gitlab: Gitlab): Promise<{offline: {name: string, status: RunnerStatus}[], totalCount: number}> {
-  if (gitlab.offlineRunners === 'none') {
-    return {
-      offline: [],
-      totalCount: 0
-    }
-  }
-
-  const runners = await fetchRunners(gitlab)
-  const offline = runners.filter(r => r.status === 'offline')
-  return {
-    offline,
-    totalCount: runners.length
-  }
-}
-
-interface GitlabRunnerResponse {
-  id: number
-  description?: string
-  status: RunnerStatus
-}
-
-async function fetchRunners(gitlab: Gitlab) {
-  const runnersApi = gitlab.offlineRunners === 'all' ? '/runners/all' : '/runners'
-  const {data: runners} = await gitlabRequest<GitlabRunnerResponse[]>(runnersApi, null, gitlab)
-  return runners.map(r => ({
-    name: r.description || r.id.toString(),
-    status: r.status
-  }))
-}

package/src/less.ts

@@ -1,33 +0,0 @@
-import fs from 'fs'
-import less from 'less'
-import path from 'path'
-import {config} from './config.ts'
-import type {Config} from './config.ts'
-import type {Request, Response} from 'express'
-
-const filename = path.join('public', 'client.less')
-
-export async function serveLessAsCss(_req: Request, res: Response) {
-  try {
-    const source = await fs.promises.readFile(filename, 'utf-8')
-    const {css} = await less.render(withColorOverrides(source), {filename})
-    res.setHeader('content-type', 'text/css')
-    res.send(css)
-  } catch (err) {
-    console.error('Failed to render client.less', err)
-    res.sendStatus(500)
-  }
-}
-
-function withColorOverrides(source: string) {
-  const {colors} = config
-  if (!colors) {
-    return source
-  }
-
-  let colorLess = ''
-  Object.keys(colors).forEach((stateName) => {
-    colorLess += `@${stateName}-color:${colors[stateName as keyof Config["colors"]]};`
-  })
-  return source + colorLess
-}