gitlab-radiator 5.2.0 → 5.2.1

package/public/client.js.LICENSE.txt

@@ -0,0 +1,43 @@
+/**
+ * @license React
+ * react-dom-client.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * @license React
+ * react-dom.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * @license React
+ * react.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * @license React
+ * scheduler.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+//! moment.js
+
+//! moment.js locale configuration

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,82 @@
+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'),
+    commitAsTitle: z.boolean().default(false),
+    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, commitAsTitle, projects } = gitlab;
+    const ca = caFile && fs.existsSync(caFile) ? fs.readFileSync(caFile, 'utf-8') : undefined;
+    return {
+        url,
+        ignoreArchived,
+        maxNonFailedJobsVisible,
+        branch,
+        ca,
+        offlineRunners,
+        'access-token': accessToken,
+        commitAsTitle,
+        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,50 @@
+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,
+        commitAsTitle: gitlab.commitAsTitle,
+        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/.github/copilot-instructions.md

@@ -1,55 +0,0 @@
-This repository is a small Node.js + React radiator that fetches CI pipelines from GitLab and serves a live dashboard.
-
-Purpose for an AI coding agent
-- Help maintain and extend the server-side polling & GitLab API logic in `src/gitlab/*`.
-- Help evolve the client UI in `src/client/*` while preserving the Socket.IO state contract.
-- Be conservative: prefer minimal, focused changes that keep the current runtime behavior and configuration semantics.
-
-Big picture
-- The server (`src/app.js`) loads a YAML config (`~/.gitlab-radiator.yml` or `GITLAB_RADIATOR_CONFIG`) and repeatedly calls `update(config)` from `src/gitlab/index.js` to produce a `globalState` object.
-- The server emits `state` via Socket.IO to clients. The client entry is `src/client/index.tsx` which listens for the `state` event and renders via React components such as `groupedProjects.tsx`.
-- GitLab API interactions are implemented under `src/gitlab` (`client.js`, `projects.js`, `pipelines.js`, `runners.js`). `client.js` uses axios with a cached client per GitLab URL and passes `ca` into the https.Agent when configured.
-
-Key files (examples)
-- Server start / main loop: `src/app.js` (socket gating, `runUpdate()`, error handling)
-- Config loading & normalization: `src/config.js` (YAML file loading, env overrides, interval/port normalization)
-- GitLab API client: `src/gitlab/client.js` (lazy client cache, `gitlabRequest()`)
-- GitLab update orchestration: `src/gitlab/index.js` (fetch projects + pipelines, filtering)
-- Frontend entry and Socket.IO usage: `src/client/index.tsx` (listens to `state` and applies `argumentsFromDocumentUrl()`)
-- CLI / installable binary: `bin/gitlab-radiator.js` (installed via npm `bin` in `package.json`)
-
-Build / run / test commands (exact)
-- Use `nvm use` always first to select correct Node.js version as per `.nvmrc`.
-- Start server in dev/prod: `npm start` (runs `node src/app.js`).
-- Build distribution: `npm run build` (invokes `./build-npm` wrapper in the repo root).
-- Lint and auto-fix: `npm run eslint`.
-- Typecheck: `npm run typecheck`.
-- Run tests: `npm test` (Mocha, timeout 20s). Tests live under `test/*.js`.
-- When talking to an on-prem GitLab with self-signed certs, either set `gitlabs[].caFile` in config or run: `NODE_TLS_REJECT_UNAUTHORIZED=0 gitlab-radiator`.
-
-Project conventions and patterns
-- ESM modules: `package.json` has `"type": "module"` — use `import`/`export` style and avoid CommonJS `require` unless very deliberate.
-- All code is in TypeScript (`.ts`/`.tsx`), but runtime type checks are not enforced; treat types as documentation and IDE assistance. No need to transpile or use ts-node for backend code.
-- Config-first: almost all behavior is driven by `~/.gitlab-radiator.yml`. `src/config.ts` maps YAML values to normalized runtime values (note: `interval` is converted to milliseconds).
-- Socket contract is stable: server emits `state` (object with `projects`, `now`, `error`, `zoom`, `columns`, `projectsOrder`, `horizontal`, `groupSuccessfulProjects`); the client expects that shape. Changing the contract requires coordinated server+client changes.
-- GitLab clients are cached by URL in `src/gitlab/client.ts`; create clients via `lazyClient(gitlab)` to reuse keep-alive connections.
-- CA handling: `config.gitlabs[].caFile` is read in `src/config.ts` and passed as `ca` to axios `https.Agent` in `client.js`.
-
-Safe edit guidance for agents
-- Small, isolated changes preferred. When changing data shapes emitted as `state`, update `src/client/*` in the same PR to keep runtime compatibility.
-- Preserve environment-driven behavior: `GITLAB_ACCESS_TOKEN`, `GITLAB_RADIATOR_CONFIG`, and `NODE_TLS_REJECT_UNAUTHORIZED` are intentionally supported; prefer config changes over hardcoding tokens.
-- When adding new dependencies, ensure they are added to `package.json` and usage fits ESM. Use exact versions as per existing dependencies.
-- Keep `package.json` sorted alphabetically in `dependencies` and `devDependencies`.
-- Follow existing style: minimal new inline comments, keep utility functions small, and do not rework CI/test harnesses unless requested.
-
-Debugging notes
-- To reproduce the runtime locally, create a `~/.gitlab-radiator.yml` with at least one `gitlabs` entry with `url` and `access-token` (or set `GITLAB_ACCESS_TOKEN`).
-- Logs and errors are printed on the server console; network timeouts are 30s in `src/gitlab/client.ts`.
-- Dev mode: `src/dev-assets.ts` is loaded when `NODE_ENV !== 'production'` and `./src/dev-assets.ts` exists — use it to bind webpack dev middleware for frontend HMR.
-
-When to ask for human guidance
-- Any change that modifies the `state` emitted to clients, the YAML config schema, or the HTTP endpoints should be flagged for review.
-- Changes touching authentication flows or handling of GitLab tokens/CA files should be reviewed for security implications.
-
-References
-- See `src/app.ts`, `src/config.ts`, `src/gitlab/*`, and `src/client/*` as primary examples of the runtime and data flow.

package/.github/workflows/test.yml

@@ -1,22 +0,0 @@
-name: Run tests
-
-on: [push, pull_request]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        node-version: [22.x, 24.x]
-    steps:
-      - uses: actions/checkout@v5
-      - name: Use Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@v5
-        with:
-          node-version: ${{ matrix.node-version }}
-      - run: npm ci
-      - run: npm audit
-      - run: npm run eslint
-      - run: npm run typecheck
-      - run: npm test
-      - run: npm run build

package/.nvmrc

@@ -1 +0,0 @@
-22.18.0

package/build-npm

@@ -1,22 +0,0 @@
-#!/bin/bash
-
-set -e
-
-rm -fr build
-mkdir -p build/src
-
-# Copy static resources
-cp -r public build
-
-# Copy LICENSE, README and package.json
-cp LICENSE package.json README.md build
-
-# Copy bin script
-cp -r bin build
-
-# Transpile server
-tsc --build tsconfig.build.json
-rm -f build/src/dev-assets.ts
-
-# Bundle and minify client JS
-npx webpack --config webpack.prod.cjs