chore(changelog): add initial changelog file to document project updates

- Introduces a CLI tool for creating systemd .timer and .service units
- Adds options for configuring unit names, commands, scheduling, and more
- Supports dry-run mode and user-level unit file generation

.vscode/settings.json

@@ -0,0 +1,15 @@
+{
+    "workbench.colorCustomizations": {
+        "activityBar.activeBackground": "#d48282",
+        "activityBar.background": "#d48282",
+        "activityBar.foreground": "#15202b",
+        "activityBar.inactiveForeground": "#15202b99",
+        "activityBarBadge.background": "#b8e7b8",
+        "activityBarBadge.foreground": "#15202b"
+    },
+    "peacock.color": "#c75c5c",
+    "exportall.config.folderListener": [
+        "/src/utils",
+        "/src/types"
+    ]
+}

CHANGELOG.md

@@ -0,0 +1,32 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [unreleased]
+
+### 🚀 Features
+
+- *(cli)* Add command to generate systemd unit files - ([97dc3fe](https://git.0xmax42.io/maxp/systemd-timer/commit/97dc3fe23acf2c35053aced7b34918bab7778c35))
+- *(utils)* Export utility functions for filesystem and naming - ([428e849](https://git.0xmax42.io/maxp/systemd-timer/commit/428e84927f8a9a379fa014ea763dd61115be34d6))
+- *(types)* Add TimerOptions interface for timer configuration - ([ba4b933](https://git.0xmax42.io/maxp/systemd-timer/commit/ba4b933f78c48a52b1c199fe28dc82d7ebabd7fe))
+- *(cli)* Add entry point for CLI commands - ([d5a383a](https://git.0xmax42.io/maxp/systemd-timer/commit/d5a383a62c965b60de7429ac1cb89f02639935f6))
+- *(utils)* Add function to derive sanitized job names - ([9539fe0](https://git.0xmax42.io/maxp/systemd-timer/commit/9539fe053245e9fea10ceda0e46fe61e9de80797))
+
+### 🚜 Refactor
+
+- *(utils)* Update import path for TimerOptions - ([316f3af](https://git.0xmax42.io/maxp/systemd-timer/commit/316f3af04ef7fe4c08963cfe3ad7780ed3bc262c))
+
+### 🧪 Testing
+
+- *(generate)* Add unit tests for service and timer generation - ([569b14d](https://git.0xmax42.io/maxp/systemd-timer/commit/569b14d57432589107a0f33e52881b605c5f79f9))
+- *(utils)* Add unit tests for systemd file handling - ([ef2ac41](https://git.0xmax42.io/maxp/systemd-timer/commit/ef2ac416d92f59efe3390317af46e943549adc47))
+
+### ⚙️ Miscellaneous Tasks
+
+- Add VSCode settings for color customizations and folder listener - ([6608f48](https://git.0xmax42.io/maxp/systemd-timer/commit/6608f488405adefc7993f47a137a824e5de62154))
+- *(config)* Add deno configuration and lockfile - ([0b72050](https://git.0xmax42.io/maxp/systemd-timer/commit/0b720500e0fe34db087b3277c38fa6bb07875e80))
+- Add automated release workflow and scripts for version management - ([a058e7b](https://git.0xmax42.io/maxp/systemd-timer/commit/a058e7b6838d41a98f3269db9a9d1e31f752121f))
+- *(gitignore)* Add dist/ and .env files to ignore list - ([2da372d](https://git.0xmax42.io/maxp/systemd-timer/commit/2da372d20dd0e023feb7e2da391dd0971da6a73d))
+- *(gitignore)* Add common build and coverage directories - ([2990af3](https://git.0xmax42.io/maxp/systemd-timer/commit/2990af3628b036c1d61daaf3d8efd3d2f0d4b761))
+
+

src/cli/create.ts

@@ -0,0 +1,39 @@
+import { Command } from '@cliffy/command';
+import { generateUnitFiles } from '../templates/unit-generator.ts';
+import { TimerOptions } from '../types/options.ts';
+
+export const createCommand = new Command()
+    .description('Erzeugt eine systemd .service und .timer Unit')
+    .option(
+        '--name <name:string>',
+        'Name der Unit-Dateien (optional, wird sonst aus dem Exec generiert)',
+    )
+    .option(
+        '--exec <cmd:string>',
+        'Kommando, das durch systemd ausgeführt werden soll',
+        { required: true },
+    )
+    .option('--calendar <time:string>', 'OnCalendar-Ausdruck für den Timer', {
+        required: true,
+    })
+    .option('--description <desc:string>', 'Beschreibung des Timers')
+    .option('--user', 'Erstellt die Unit als User-Timer')
+    .option('--output <dir:string>', 'Zielverzeichnis der Unit-Dateien')
+    .option(
+        '--after <target:string>',
+        'Optionales After= für die Service-Unit',
+        { collect: true },
+    )
+    .option(
+        '--environment <env:string>',
+        'Environment-Variablen im Format KEY=VALUE',
+        { collect: true },
+    )
+    .option(
+        '--logfile <file:string>',
+        'Dateipfad für Log-Ausgabe (stdout/stderr)',
+    )
+    .option('--dry-run', 'Gibt die Unit-Dateien nur aus, ohne sie zu schreiben')
+    .action(async (options: TimerOptions) => {
+        await generateUnitFiles(options);
+    });

src/cli/main.ts

@@ -0,0 +1,9 @@
+import { Command } from '@cliffy/command';
+import { createCommand } from './create.ts';
+
+await new Command()
+    .name('systemd-timer')
+    .version('0.1.0')
+    .description('CLI Tool zum Erzeugen von systemd .timer und .service Units')
+    .command('create', createCommand)
+    .parse(Deno.args);

src/mod.ts

@@ -0,0 +1,5 @@
+import './cli/main.ts';
+
+// ────────────────────────────────────────────────
+// Entry Point for CLI
+// Delegates to src/cli/main.ts, which registers all CLI commands

src/templates/__tests__/generate.test.ts

@@ -0,0 +1,55 @@
+import {
+    assertStringIncludes,
+} from 'https://deno.land/std@0.224.0/assert/mod.ts';
+import { TimerOptions } from '../../types/mod.ts';
+import { generateUnits } from '../unit-generator.ts';
+
+Deno.test('generateUnits erzeugt Basis-Service und Timer korrekt', () => {
+    const opts: TimerOptions = {
+        exec: '/usr/bin/my-script',
+        calendar: 'daily',
+    };
+    const { serviceUnit, timerUnit } = generateUnits('myjob', opts);
+
+    assertStringIncludes(serviceUnit, 'ExecStart=/usr/bin/my-script');
+    assertStringIncludes(timerUnit, 'OnCalendar=daily');
+    assertStringIncludes(timerUnit, '[Install]');
+});
+
+Deno.test('generateUnits setzt Beschreibung aus Option', () => {
+    const opts: TimerOptions = {
+        exec: '/bin/true',
+        calendar: 'daily',
+        description: 'Meine Unit',
+    };
+    const { serviceUnit } = generateUnits('job', opts);
+
+    assertStringIncludes(serviceUnit, 'Description=Meine Unit');
+});
+
+Deno.test('generateUnits berücksichtigt after=', () => {
+    const opts: TimerOptions = {
+        exec: '/bin/true',
+        calendar: 'daily',
+        after: ['network-online.target', 'docker.service'],
+    };
+    const { serviceUnit } = generateUnits('job', opts);
+
+    assertStringIncludes(serviceUnit, 'After=network-online.target');
+    assertStringIncludes(serviceUnit, 'After=docker.service');
+});
+
+Deno.test('generateUnits berücksichtigt environment und logfile', () => {
+    const opts: TimerOptions = {
+        exec: '/bin/true',
+        calendar: 'daily',
+        environment: ['FOO=bar', 'DEBUG=1'],
+        logfile: '/var/log/job.log',
+    };
+    const { serviceUnit } = generateUnits('job', opts);
+
+    assertStringIncludes(serviceUnit, 'Environment=FOO=bar');
+    assertStringIncludes(serviceUnit, 'Environment=DEBUG=1');
+    assertStringIncludes(serviceUnit, 'StandardOutput=append:/var/log/job.log');
+    assertStringIncludes(serviceUnit, 'StandardError=append:/var/log/job.log');
+});

src/templates/unit-generator.ts

@@ -0,0 +1,63 @@
+import { TimerOptions } from '../types/mod.ts';
+import { deriveNameFromExec, writeUnitFiles } from '../utils/mod.ts';
+
+export async function generateUnitFiles(options: TimerOptions): Promise<void> {
+    const name = options.name || deriveNameFromExec(options.exec);
+
+    const { serviceUnit, timerUnit } = generateUnits(name, options);
+
+    if (options.dryRun) {
+        console.log(`===== ${name}.service =====`);
+        console.log(serviceUnit);
+        console.log(`\n===== ${name}.timer =====`);
+        console.log(timerUnit);
+    } else {
+        const { servicePath, timerPath } = await writeUnitFiles(
+            name,
+            serviceUnit,
+            timerUnit,
+            options,
+        );
+        console.log(`Service unit written to: ${servicePath}`);
+        console.log(`Timer unit written to: ${timerPath}`);
+    }
+}
+
+export function generateUnits(name: string, options: TimerOptions): {
+    serviceUnit: string;
+    timerUnit: string;
+} {
+    const unitParts = [
+        `[Unit]`,
+        `Description=${options.description ?? name}`,
+        ...(options.after?.map((a) => `After=${a}`) ?? []),
+        ``,
+        `[Service]`,
+        `Type=oneshot`,
+        `ExecStart=${options.exec}`,
+        ...(options.environment?.map((e) => `Environment=${e}`) ?? []),
+    ];
+
+    if (options.logfile) {
+        unitParts.push(`StandardOutput=append:${options.logfile}`);
+        unitParts.push(`StandardError=append:${options.logfile}`);
+    }
+
+    const serviceUnit = unitParts.join('\n');
+
+    const timerParts = [
+        `[Unit]`,
+        `Description=Timer for ${name}`,
+        ``,
+        `[Timer]`,
+        `OnCalendar=${options.calendar}`,
+        `Persistent=true`,
+        ``,
+        `[Install]`,
+        `WantedBy=timers.target`,
+    ];
+
+    const timerUnit = timerParts.join('\n');
+
+    return { serviceUnit, timerUnit };
+}

src/types/mod.ts

@@ -0,0 +1 @@
+export type { TimerOptions } from './options.ts';

src/types/options.ts

@@ -0,0 +1,12 @@
+export interface TimerOptions {
+    name?: string;
+    exec: string;
+    calendar: string;
+    description?: string;
+    user?: boolean;
+    output?: string;
+    after?: string[];
+    environment?: string[];
+    logfile?: string;
+    dryRun?: boolean;
+}

src/utils/__tests__/fs.test.ts

@@ -0,0 +1,59 @@
+import {
+    assertEquals,
+    assertExists,
+    assertStringIncludes,
+} from 'https://deno.land/std@0.224.0/assert/mod.ts';
+import { join } from 'https://deno.land/std@0.224.0/path/mod.ts';
+import { resolveUnitTargetPath, writeUnitFiles } from '../mod.ts';
+import { TimerOptions } from '../../types/options.ts';
+
+Deno.test('writeUnitFiles schreibt .service und .timer korrekt', async () => {
+    const tmp = await Deno.makeTempDir({ prefix: 'test-units-' });
+
+    const options = {
+        output: tmp,
+        user: false,
+    };
+
+    const name = 'test-backup';
+    const serviceContent = '[Service]\nExecStart=/bin/true';
+    const timerContent = '[Timer]\nOnCalendar=daily';
+
+    const { servicePath, timerPath } = await writeUnitFiles(
+        name,
+        serviceContent,
+        timerContent,
+        options as TimerOptions,
+    );
+
+    // Überprüfe Pfade
+    assertEquals(servicePath, join(tmp, 'test-backup.service'));
+    assertEquals(timerPath, join(tmp, 'test-backup.timer'));
+
+    // Existieren Dateien?
+    assertExists(await Deno.stat(servicePath));
+    assertExists(await Deno.stat(timerPath));
+
+    // Enthält die Datei den erwarteten Inhalt?
+    const readService = await Deno.readTextFile(servicePath);
+    const readTimer = await Deno.readTextFile(timerPath);
+
+    assertStringIncludes(readService, 'ExecStart=/bin/true');
+    assertStringIncludes(readTimer, 'OnCalendar=daily');
+});
+
+Deno.test('resolveUnitTargetPath mit --output', () => {
+    const result = resolveUnitTargetPath({ output: '/tmp/units', user: false });
+    assertEquals(result, '/tmp/units');
+});
+
+Deno.test('resolveUnitTargetPath mit --user ohne output', () => {
+    Deno.env.set('HOME', '/home/maxp');
+    const result = resolveUnitTargetPath({ output: undefined, user: true });
+    assertEquals(result, '/home/maxp/.config/systemd/user');
+});
+
+Deno.test('resolveUnitTargetPath ohne output und ohne user', () => {
+    const result = resolveUnitTargetPath({ output: undefined, user: false });
+    assertEquals(result, '/etc/systemd/system');
+});

src/utils/__tests__/misc.test.ts

@@ -0,0 +1,19 @@
+import { assertEquals } from 'https://deno.land/std@0.224.0/assert/mod.ts';
+import { deriveNameFromExec } from '../mod.ts';
+
+Deno.test('deriveNameFromExec - entfernt Pfad, Endung und Sonderzeichen', () => {
+    const tests: Array<[string, string]> = [
+        ['/usr/local/bin/backup.sh', 'backup'],
+        ['/usr/bin/python3 /home/user/myscript.py', 'python3'],
+        ['./my-job.ts', 'my-job'],
+        ['node ./tools/start.js', 'node'],
+        ['/bin/custom-script.rb', 'custom-script'],
+        ['  /usr/bin/something-strange!.bin  ', 'something-strange'],
+        ['weird:name?.sh', 'weird-name'],
+        ['', 'job'],
+    ];
+
+    for (const [input, expected] of tests) {
+        assertEquals(deriveNameFromExec(input), expected);
+    }
+});

src/utils/fs.ts

@@ -0,0 +1,30 @@
+import { ensureDir } from 'https://deno.land/std@0.224.0/fs/mod.ts';
+import { join } from 'https://deno.land/std@0.224.0/path/mod.ts';
+import { TimerOptions } from '../types/mod.ts';
+
+export async function writeUnitFiles(
+    name: string,
+    serviceContent: string,
+    timerContent: string,
+    options: TimerOptions,
+): Promise<{ servicePath: string; timerPath: string }> {
+    const basePath = resolveUnitTargetPath(options);
+
+    await ensureDir(basePath);
+
+    const servicePath = join(basePath, `${name}.service`);
+    const timerPath = join(basePath, `${name}.timer`);
+
+    await Deno.writeTextFile(servicePath, serviceContent);
+    await Deno.writeTextFile(timerPath, timerContent);
+
+    return { servicePath, timerPath };
+}
+
+export function resolveUnitTargetPath(
+    options: Pick<TimerOptions, 'output' | 'user'>,
+): string {
+    if (options.output) return options.output;
+    if (options.user) return `${Deno.env.get('HOME')}/.config/systemd/user`;
+    return '/etc/systemd/system';
+}

src/utils/misc.ts

@@ -0,0 +1,12 @@
+export function deriveNameFromExec(exec: string): string {
+    const parts = exec.trim().split(' ');
+    const base = parts[0].split('/').pop() || 'job';
+
+    // remove the file extension
+    const withoutExt = base.replace(/\.(sh|py|ts|js|pl|rb|exe|bin)$/, '');
+
+    // replace illegal chars, then trim leading/trailing hyphens
+    return withoutExt
+        .replaceAll(/[^a-zA-Z0-9_-]/g, '-')
+        .replace(/^-+|-+$/g, '');
+}

src/utils/mod.ts

@@ -0,0 +1,2 @@
+export { resolveUnitTargetPath, writeUnitFiles } from './fs.ts';
+export { deriveNameFromExec } from './misc.ts';