Compare commits

..
Author SHA1 Message Date
Thomas Camlong 3dc382145c refactor(cli): rewrite CLI for reliability and better UX
Replace brocli framework with Node's built-in util.parseArgs and a
declarative command registry. The CLI no longer hangs after completing
because:
- DB connections are lazily created and explicitly closed
- Winston/Redis logging is excluded from the bundle entirely
- process.exit() is always called with proper exit codes

Additional improvements:
- Bundle size reduced from 5.3MB to 1.2MB (native drivers externalized)
- Proper column-aligned table output for list commands
- --json flag on list commands for scripting/automation
- Per-command --help with usage examples
- Execution timing shown on success
- Consistent exit codes (0=success, 1=error, 2=usage)
- Docker wrapper sets DISABLE_REDIS_LOGS and uses exec
2026-05-21 16:05:27 +02:00
Releases Homarr 48ef8eb6c0 chore(release): 1.61.1 [skip ci] 2026-05-18 19:45:44 +00:00
Austin e9142c0dbc fix(downloads-widget): increase name column default width ratio 2026-05-18 21:44:47 +02:00
44 changed files with 6447 additions and 5422 deletions

No files matched your search

+4
View File
@@ -12,6 +12,10 @@ AUTH_SECRET="supersecret"
# or starting the project without any (which will show a randomly generated one). # or starting the project without any (which will show a randomly generated one).
SECRET_ENCRYPTION_KEY=0000000000000000000000000000000000000000000000000000000000000000 SECRET_ENCRYPTION_KEY=0000000000000000000000000000000000000000000000000000000000000000
# Cron job API key is generated every time the container starts as it is required for communication between nextjs-api and tasks-api
# export CRON_JOB_API_KEY=$(openssl rand -base64 32)
# CRON_JOB_API_KEY="your-generated-api-key"
LOG_LEVEL='info' LOG_LEVEL='info'
# This is how you can use the sqlite driver: # This is how you can use the sqlite driver:
+8 -10
View File
@@ -5,7 +5,6 @@ on:
branches: branches:
- main - main
- beta - beta
- next
- dev - dev
workflow_dispatch: workflow_dispatch:
inputs: inputs:
@@ -35,7 +34,7 @@ jobs:
runs-on: ubuntu-latest runs-on: ubuntu-latest
timeout-minutes: 5 timeout-minutes: 5
env: env:
SKIP_RELEASE: ${{ github.event_name == 'workflow_dispatch' || github.ref_name == 'dev' || github.ref_name == 'next' }} SKIP_RELEASE: ${{ github.event_name == 'workflow_dispatch' || github.ref_name == 'dev' }}
outputs: outputs:
version: ${{ steps.read-semver.outputs.version || steps.version-fallback.outputs.version }} version: ${{ steps.read-semver.outputs.version || steps.version-fallback.outputs.version }}
git_ref: ${{ steps.read-git-ref.outputs.ref || github.ref }} git_ref: ${{ steps.read-git-ref.outputs.ref || github.ref }}
@@ -55,7 +54,7 @@ jobs:
with: with:
private-key: ${{ secrets.RENOVATE_MERGE_PRIVATE_KEY }} private-key: ${{ secrets.RENOVATE_MERGE_PRIVATE_KEY }}
client-id: ${{ secrets.RENOVATE_MERGE_APP_ID }} client-id: ${{ secrets.RENOVATE_MERGE_APP_ID }}
permission-contents: write # required to commit package.json & changelog changes, merge them to dev / next and publish the release permission-contents: write # required to commit package.json & changelog changes, merge them to dev and publish the release
- uses: actions/checkout@v6 - uses: actions/checkout@v6
if: env.SKIP_RELEASE == 'false' if: env.SKIP_RELEASE == 'false'
@@ -67,7 +66,7 @@ jobs:
if: env.SKIP_RELEASE == 'false' if: env.SKIP_RELEASE == 'false'
with: with:
node-version: 24.15.0 node-version: 24.15.0
package-manager-cache: false cache: "pnpm"
- run: npm i -g pnpm - run: npm i -g pnpm
if: env.SKIP_RELEASE == 'false' if: env.SKIP_RELEASE == 'false'
- name: Install dependencies - name: Install dependencies
@@ -96,21 +95,20 @@ jobs:
id: read-git-ref id: read-git-ref
run: | run: |
echo "ref=$(git rev-parse HEAD)" >> "$GITHUB_OUTPUT" echo "ref=$(git rev-parse HEAD)" >> "$GITHUB_OUTPUT"
- name: Update dev / next branch - name: Update dev branch
if: env.SKIP_RELEASE == 'false' if: env.SKIP_RELEASE == 'false'
continue-on-error: true # Prevent pipeline from failing when merge fails continue-on-error: true # Prevent pipeline from failing when merge fails
env: env:
GITHUB_TOKEN: ${{ steps.obtainToken.outputs.token }} GITHUB_TOKEN: ${{ steps.obtainToken.outputs.token }}
UPSTREAM_BRANCH: ${{ github.ref_name == 'main' && 'dev' || 'next' }}
run: | run: |
git config user.name "Releases Homarr" git config user.name "Releases Homarr"
git config user.email "175486441+homarr-releases[bot]@users.noreply.github.com" git config user.email "175486441+homarr-releases[bot]@users.noreply.github.com"
git remote set-url origin https://x-access-token:${{ steps.obtainToken.outputs.token }}@github.com/${{ github.repository }}.git git remote set-url origin https://x-access-token:${{ steps.obtainToken.outputs.token }}@github.com/${{ github.repository }}.git
git fetch origin ${{ env.UPSTREAM_BRANCH }} git fetch origin dev
git checkout ${{ env.UPSTREAM_BRANCH }} git checkout dev
git pull origin ${{ env.UPSTREAM_BRANCH }} git pull origin dev
git rebase ${{ github.ref_name }} git rebase ${{ github.ref_name }}
git push origin ${{ env.UPSTREAM_BRANCH }} git push origin dev
build-amd64: build-amd64:
name: Build docker image for amd64 name: Build docker image for amd64
needs: release needs: release
+3841 -3854
View File
File diff suppressed because it is too large. Load diff
+3 -1
View File
@@ -30,7 +30,7 @@ VOLUME /appdata
# Enable homarr cli # Enable homarr cli
COPY --from=builder /app/packages/cli/cli.cjs /app/apps/cli/cli.cjs COPY --from=builder /app/packages/cli/cli.cjs /app/apps/cli/cli.cjs
RUN echo $'#!/bin/bash\ncd /app/apps/cli && node ./cli.cjs "$@"' > /usr/bin/homarr RUN echo $'#!/bin/bash\nexport DISABLE_REDIS_LOGS=true\ncd /app/apps/cli && exec node ./cli.cjs "$@"' > /usr/bin/homarr
RUN chmod +x /usr/bin/homarr RUN chmod +x /usr/bin/homarr
# Don't run production as root # Don't run production as root
@@ -43,6 +43,8 @@ RUN mkdir -p /var/cache/nginx && \
COPY --from=builder /app/apps/nextjs/next.config.ts . COPY --from=builder /app/apps/nextjs/next.config.ts .
COPY --from=builder /app/apps/nextjs/package.json . COPY --from=builder /app/apps/nextjs/package.json .
COPY --from=builder /app/apps/tasks/tasks.cjs ./apps/tasks/tasks.cjs
COPY --from=builder /app/apps/websocket/wssServer.cjs ./apps/websocket/wssServer.cjs
COPY --from=builder /app/node_modules/better-sqlite3/build/Release/better_sqlite3.node /app/build/better_sqlite3.node COPY --from=builder /app/node_modules/better-sqlite3/build/Release/better_sqlite3.node /app/build/better_sqlite3.node
COPY --from=builder /app/packages/db/migrations ./db/migrations COPY --from=builder /app/packages/db/migrations ./db/migrations
-2
View File
@@ -32,8 +32,6 @@ const nextConfig: NextConfig = {
experimental: { experimental: {
optimizePackageImports: ["@mantine/core", "@mantine/hooks", "@tabler/icons-react"], optimizePackageImports: ["@mantine/core", "@mantine/hooks", "@tabler/icons-react"],
turbopackFileSystemCacheForDev: true, turbopackFileSystemCacheForDev: true,
preloadEntriesOnStart: false,
webpackMemoryOptimizations: true,
}, },
transpilePackages: ["@homarr/ui", "@homarr/notifications", "@homarr/modals", "@homarr/spotlight", "@homarr/widgets"], transpilePackages: ["@homarr/ui", "@homarr/notifications", "@homarr/modals", "@homarr/spotlight", "@homarr/widgets"],
images: { images: {
-2
View File
@@ -44,11 +44,9 @@
"@homarr/server-settings": "workspace:^0.1.0", "@homarr/server-settings": "workspace:^0.1.0",
"@homarr/settings": "workspace:^0.1.0", "@homarr/settings": "workspace:^0.1.0",
"@homarr/spotlight": "workspace:^0.1.0", "@homarr/spotlight": "workspace:^0.1.0",
"@homarr/tasks": "workspace:^0.1.0",
"@homarr/translation": "workspace:^0.1.0", "@homarr/translation": "workspace:^0.1.0",
"@homarr/ui": "workspace:^0.1.0", "@homarr/ui": "workspace:^0.1.0",
"@homarr/validation": "workspace:^0.1.0", "@homarr/validation": "workspace:^0.1.0",
"@homarr/websocket": "workspace:^0.1.0",
"@homarr/widgets": "workspace:^0.1.0", "@homarr/widgets": "workspace:^0.1.0",
"@mantine/colors-generator": "catalog:", "@mantine/colors-generator": "catalog:",
"@mantine/core": "catalog:", "@mantine/core": "catalog:",
-6
View File
@@ -1,6 +0,0 @@
export async function register() {
if (process.env.NEXT_RUNTIME === "nodejs") {
await import("@homarr/tasks");
await import("@homarr/websocket");
}
}
+3 -1
View File
@@ -5,11 +5,12 @@
"license": "Apache-2.0", "license": "Apache-2.0",
"type": "module", "type": "module",
"exports": { "exports": {
".": "./src/main.ts" ".": "./src/index.ts"
}, },
"main": "./src/main.ts", "main": "./src/main.ts",
"types": "./src/main.ts", "types": "./src/main.ts",
"scripts": { "scripts": {
"build": "esbuild src/main.ts --bundle --platform=node --loader:.scss=text --external:*.node --external:@opentelemetry/api --external:deasync --external:bcrypt --outfile=tasks.cjs",
"clean": "rm -rf .turbo node_modules", "clean": "rm -rf .turbo node_modules",
"dev": "pnpm with-env tsx ./src/main.ts", "dev": "pnpm with-env tsx ./src/main.ts",
"format": "prettier --check . --ignore-path ../../.gitignore", "format": "prettier --check . --ignore-path ../../.gitignore",
@@ -23,6 +24,7 @@
"@homarr/auth": "workspace:^0.1.0", "@homarr/auth": "workspace:^0.1.0",
"@homarr/common": "workspace:^0.1.0", "@homarr/common": "workspace:^0.1.0",
"@homarr/core": "workspace:^", "@homarr/core": "workspace:^",
"@homarr/cron-job-api": "workspace:^0.1.0",
"@homarr/cron-jobs": "workspace:^0.1.0", "@homarr/cron-jobs": "workspace:^0.1.0",
"@homarr/cron-jobs-core": "workspace:^0.1.0", "@homarr/cron-jobs-core": "workspace:^0.1.0",
"@homarr/db": "workspace:^0.1.0", "@homarr/db": "workspace:^0.1.0",
@@ -1,6 +1,7 @@
import { Cron } from "croner"; import { Cron } from "croner";
import { createLogger } from "@homarr/core/infrastructure/logs"; import { createLogger } from "@homarr/core/infrastructure/logs";
import type { IJobManager } from "@homarr/cron-job-api";
import type { jobGroup as cronJobGroup, JobGroupKeys } from "@homarr/cron-jobs"; import type { jobGroup as cronJobGroup, JobGroupKeys } from "@homarr/cron-jobs";
import type { Database, InferInsertModel } from "@homarr/db"; import type { Database, InferInsertModel } from "@homarr/db";
import { eq } from "@homarr/db"; import { eq } from "@homarr/db";
@@ -8,7 +9,7 @@ import { cronJobConfigurations } from "@homarr/db/schema";
const logger = createLogger({ module: "jobManager" }); const logger = createLogger({ module: "jobManager" });
export class JobManager { export class JobManager implements IJobManager {
constructor( constructor(
private db: Database, private db: Database,
private jobGroup: typeof cronJobGroup, private jobGroup: typeof cronJobGroup,
+41 -1
View File
@@ -1,12 +1,52 @@
// This import has to be the first import in the file so that the agent is overridden before any other modules are imported. // This import has to be the first import in the file so that the agent is overridden before any other modules are imported.
import "./overrides"; import "./overrides";
import { jobGroup } from "@homarr/cron-jobs"; import type { FastifyTRPCPluginOptions } from "@trpc/server/adapters/fastify";
import { fastifyTRPCPlugin } from "@trpc/server/adapters/fastify";
import fastify from "fastify";
import { createLogger } from "@homarr/core/infrastructure/logs";
import { ErrorWithMetadata } from "@homarr/core/infrastructure/logs/error";
import type { JobRouter } from "@homarr/cron-job-api";
import { jobRouter } from "@homarr/cron-job-api";
import { CRON_JOB_API_KEY_HEADER, CRON_JOB_API_PATH, CRON_JOB_API_PORT } from "@homarr/cron-job-api/constants";
import { jobGroup } from "@homarr/cron-jobs";
import { db } from "@homarr/db";
import { JobManager } from "./job-manager";
import { onStartAsync } from "./on-start"; import { onStartAsync } from "./on-start";
const logger = createLogger({ module: "tasksMain" });
const server = fastify({
maxParamLength: 5000,
});
server.register(fastifyTRPCPlugin, {
prefix: CRON_JOB_API_PATH,
trpcOptions: {
router: jobRouter,
createContext: ({ req }) => ({
manager: new JobManager(db, jobGroup),
apiKey: req.headers[CRON_JOB_API_KEY_HEADER] as string | undefined,
}),
onError({ path, error }) {
logger.error(new ErrorWithMetadata("Error in tasks tRPC handler", { path }, { cause: error }));
},
} satisfies FastifyTRPCPluginOptions<JobRouter>["trpcOptions"],
});
void (async () => { void (async () => {
await onStartAsync(); await onStartAsync();
await jobGroup.initializeAsync(); await jobGroup.initializeAsync();
await jobGroup.startAllAsync(); await jobGroup.startAllAsync();
try {
await server.listen({ port: CRON_JOB_API_PORT });
logger.info("Tasks web server started successfully", { port: CRON_JOB_API_PORT });
} catch (err) {
logger.error(
new ErrorWithMetadata("Failed to start tasks web server", { port: CRON_JOB_API_PORT }, { cause: err }),
);
process.exit(1);
}
})(); })();
+1 -3
View File
@@ -4,12 +4,10 @@
"private": true, "private": true,
"license": "Apache-2.0", "license": "Apache-2.0",
"type": "module", "type": "module",
"exports": {
".": "./src/main.ts"
},
"main": "./src/main.ts", "main": "./src/main.ts",
"types": "./src/main.ts", "types": "./src/main.ts",
"scripts": { "scripts": {
"build": "esbuild src/main.ts --bundle --platform=node --outfile=wssServer.cjs --external:bcrypt --external:@opentelemetry/api --external:deasync --external:cpu-features --loader:.html=text --loader:.scss=text --loader:.node=text",
"clean": "rm -rf .turbo node_modules", "clean": "rm -rf .turbo node_modules",
"dev": "pnpm with-env tsx ./src/main.ts", "dev": "pnpm with-env tsx ./src/main.ts",
"format": "prettier --check . --ignore-path ../../.gitignore", "format": "prettier --check . --ignore-path ../../.gitignore",
+2 -2
View File
@@ -1,6 +1,6 @@
{ {
"name": "homarr", "name": "homarr",
"version": "1.61.1-beta.1", "version": "1.61.1",
"private": true, "private": true,
"scripts": { "scripts": {
"build": "cross-env CI=true turbo build", "build": "cross-env CI=true turbo build",
@@ -15,7 +15,7 @@
"db:migration:sqlite:run": "pnpm -F db migration:sqlite:run", "db:migration:sqlite:run": "pnpm -F db migration:sqlite:run",
"db:push": "pnpm -F db push:sqlite", "db:push": "pnpm -F db push:sqlite",
"db:studio": "pnpm -F db studio", "db:studio": "pnpm -F db studio",
"dev": "pnpm -F nextjs dev", "dev": "turbo dev --parallel",
"docker:dev": "docker compose -f ./development/development.docker-compose.yml up", "docker:dev": "docker compose -f ./development/development.docker-compose.yml up",
"format": "turbo format --continue -- --cache --cache-location node_modules/.cache/.prettiercache", "format": "turbo format --continue -- --cache --cache-location node_modules/.cache/.prettiercache",
"format:fix": "turbo format --continue -- --write --cache --cache-location node_modules/.cache/.prettiercache", "format:fix": "turbo format --continue -- --write --cache --cache-location node_modules/.cache/.prettiercache",
+1
View File
@@ -25,6 +25,7 @@
"@homarr/auth": "workspace:^0.1.0", "@homarr/auth": "workspace:^0.1.0",
"@homarr/common": "workspace:^0.1.0", "@homarr/common": "workspace:^0.1.0",
"@homarr/core": "workspace:^0.1.0", "@homarr/core": "workspace:^0.1.0",
"@homarr/cron-job-api": "workspace:^0.1.0",
"@homarr/cron-job-status": "workspace:^0.1.0", "@homarr/cron-job-status": "workspace:^0.1.0",
"@homarr/cron-jobs": "workspace:^0.1.0", "@homarr/cron-jobs": "workspace:^0.1.0",
"@homarr/db": "workspace:^0.1.0", "@homarr/db": "workspace:^0.1.0",
+16 -19
View File
@@ -2,36 +2,33 @@ import { observable } from "@trpc/server/observable";
import z from "zod/v4"; import z from "zod/v4";
import { createLogger } from "@homarr/core/infrastructure/logs"; import { createLogger } from "@homarr/core/infrastructure/logs";
import { jobGroupKeys, jobNameSchema } from "@homarr/cron-job-api";
import { cronJobApi } from "@homarr/cron-job-api/client";
import type { TaskStatus } from "@homarr/cron-job-status"; import type { TaskStatus } from "@homarr/cron-job-status";
import { createCronJobStatusChannel } from "@homarr/cron-job-status"; import { createCronJobStatusChannel } from "@homarr/cron-job-status";
import { jobGroup } from "@homarr/cron-jobs";
import { JobManager } from "@homarr/cron-jobs/job-manager";
import { createTRPCRouter, permissionRequiredProcedure } from "../trpc"; import { createTRPCRouter, permissionRequiredProcedure } from "../trpc";
const jobGroupKeys = jobGroup.getKeys();
const jobNameSchema = z.enum(jobGroup.getKeys());
const logger = createLogger({ module: "cronJobsRouter" }); const logger = createLogger({ module: "cronJobsRouter" });
export const cronJobsRouter = createTRPCRouter({ export const cronJobsRouter = createTRPCRouter({
triggerJob: permissionRequiredProcedure triggerJob: permissionRequiredProcedure
.requiresPermission("admin") .requiresPermission("admin")
.input(jobNameSchema) .input(jobNameSchema)
.mutation(async ({ input, ctx }) => { .mutation(async ({ input }) => {
await new JobManager(ctx.db, jobGroup).triggerAsync(input); await cronJobApi.trigger.mutate(input);
}), }),
startJob: permissionRequiredProcedure startJob: permissionRequiredProcedure
.requiresPermission("admin") .requiresPermission("admin")
.input(jobNameSchema) .input(jobNameSchema)
.mutation(async ({ input, ctx }) => { .mutation(async ({ input }) => {
await new JobManager(ctx.db, jobGroup).startAsync(input); await cronJobApi.start.mutate(input);
}), }),
stopJob: permissionRequiredProcedure stopJob: permissionRequiredProcedure
.requiresPermission("admin") .requiresPermission("admin")
.input(jobNameSchema) .input(jobNameSchema)
.mutation(({ input, ctx }) => { .mutation(async ({ input }) => {
new JobManager(ctx.db, jobGroup).stop(input); await cronJobApi.stop.mutate(input);
}), }),
updateJobInterval: permissionRequiredProcedure updateJobInterval: permissionRequiredProcedure
.requiresPermission("admin") .requiresPermission("admin")
@@ -41,23 +38,23 @@ export const cronJobsRouter = createTRPCRouter({
cron: z.string(), cron: z.string(),
}), }),
) )
.mutation(async ({ input, ctx }) => { .mutation(async ({ input }) => {
await new JobManager(ctx.db, jobGroup).updateIntervalAsync(input.name, input.cron); await cronJobApi.updateInterval.mutate(input);
}), }),
disableJob: permissionRequiredProcedure disableJob: permissionRequiredProcedure
.requiresPermission("admin") .requiresPermission("admin")
.input(jobNameSchema) .input(jobNameSchema)
.mutation(async ({ input, ctx }) => { .mutation(async ({ input }) => {
await new JobManager(ctx.db, jobGroup).disableAsync(input); await cronJobApi.disable.mutate(input);
}), }),
enableJob: permissionRequiredProcedure enableJob: permissionRequiredProcedure
.requiresPermission("admin") .requiresPermission("admin")
.input(jobNameSchema) .input(jobNameSchema)
.mutation(async ({ input, ctx }) => { .mutation(async ({ input }) => {
await new JobManager(ctx.db, jobGroup).enableAsync(input); await cronJobApi.enable.mutate(input);
}), }),
getJobs: permissionRequiredProcedure.requiresPermission("admin").query(async ({ ctx }) => { getJobs: permissionRequiredProcedure.requiresPermission("admin").query(async () => {
return await new JobManager(ctx.db, jobGroup).getAllAsync(); return await cronJobApi.getAll.query();
}), }),
subscribeToStatusUpdates: permissionRequiredProcedure.requiresPermission("admin").subscription(() => { subscribeToStatusUpdates: permissionRequiredProcedure.requiresPermission("admin").subscription(() => {
return observable<TaskStatus>((emit) => { return observable<TaskStatus>((emit) => {
+7 -3
View File
@@ -15,7 +15,7 @@
} }
}, },
"scripts": { "scripts": {
"build": "esbuild src/index.ts --bundle --platform=node --outfile=cli.cjs --external:bcrypt --external:cpu-features --loader:.html=text --loader:.node=text", "build": "esbuild src/index.ts --bundle --platform=node --outfile=cli.cjs --external:bcrypt --external:cpu-features --external:better-sqlite3 --external:mysql2 --external:pg --loader:.html=text --loader:.node=text",
"clean": "rm -rf .turbo node_modules", "clean": "rm -rf .turbo node_modules",
"format": "prettier --check . --ignore-path ../../.gitignore", "format": "prettier --check . --ignore-path ../../.gitignore",
"lint": "eslint", "lint": "eslint",
@@ -25,12 +25,16 @@
}, },
"prettier": "@homarr/prettier-config", "prettier": "@homarr/prettier-config",
"dependencies": { "dependencies": {
"@drizzle-team/brocli": "catalog:",
"@homarr/auth": "workspace:^0.1.0", "@homarr/auth": "workspace:^0.1.0",
"@homarr/common": "workspace:^0.1.0", "@homarr/common": "workspace:^0.1.0",
"@homarr/core": "workspace:^0.1.0",
"@homarr/db": "workspace:^0.1.0", "@homarr/db": "workspace:^0.1.0",
"@homarr/validation": "workspace:^0.1.0", "@homarr/validation": "workspace:^0.1.0",
"dotenv": "catalog:" "better-sqlite3": "catalog:",
"dotenv": "catalog:",
"drizzle-orm": "catalog:",
"mysql2": "catalog:",
"pg": "catalog:"
}, },
"devDependencies": { "devDependencies": {
"@homarr/eslint-config": "workspace:^0.2.0", "@homarr/eslint-config": "workspace:^0.2.0",
+127
View File
@@ -0,0 +1,127 @@
import Database from "better-sqlite3";
import { drizzle as drizzleSqlite } from "drizzle-orm/better-sqlite3";
import { drizzle as drizzleMysql } from "drizzle-orm/mysql2";
import { drizzle as drizzlePostgres } from "drizzle-orm/node-postgres";
import mysql from "mysql2";
import type { Pool as MysqlPool } from "mysql2";
import { Pool as PostgresPool } from "pg";
import { DB_CASING } from "@homarr/core/infrastructure/db/constants";
import { dbEnv } from "@homarr/core/infrastructure/db/env";
import { schema } from "@homarr/db/schema";
const CONNECT_TIMEOUT_MS = 10_000;
const dbConfig = {
schema,
casing: DB_CASING,
};
export type CliDatabase = ReturnType<typeof drizzleSqlite<typeof schema>>;
type CliConnection =
| { driver: "better-sqlite3"; raw: Database.Database; db: CliDatabase }
| { driver: "mysql2"; raw: MysqlPool; db: CliDatabase }
| { driver: "node-postgres"; raw: PostgresPool; db: CliDatabase };
let connection: CliConnection | null = null;
const createMysqlPool = () => {
const poolOptions = {
maxIdle: 0,
idleTimeout: 60000,
enableKeepAlive: true,
connectTimeout: CONNECT_TIMEOUT_MS,
};
if (!dbEnv.HOST) {
return mysql.createPool({ ...poolOptions, uri: dbEnv.URL });
}
return mysql.createPool({
...poolOptions,
host: dbEnv.HOST,
port: dbEnv.PORT,
database: dbEnv.NAME,
user: dbEnv.USER,
password: dbEnv.PASSWORD,
});
};
const createPostgresPool = () => {
const poolOptions = {
max: 1,
idleTimeoutMillis: 60000,
connectionTimeoutMillis: CONNECT_TIMEOUT_MS,
allowExitOnIdle: true,
};
if (!dbEnv.HOST) {
return new PostgresPool({
...poolOptions,
connectionString: dbEnv.URL,
});
}
return new PostgresPool({
...poolOptions,
host: dbEnv.HOST,
port: dbEnv.PORT,
database: dbEnv.NAME,
user: dbEnv.USER,
password: dbEnv.PASSWORD,
});
};
const connectionFactories = {
"better-sqlite3": (): CliConnection => {
const raw = new Database(dbEnv.URL);
const db = drizzleSqlite(raw, dbConfig);
return { driver: "better-sqlite3", raw, db };
},
mysql2: (): CliConnection => {
const raw = createMysqlPool();
const db = drizzleMysql(raw, { ...dbConfig, mode: "default" }) as unknown as CliDatabase;
return { driver: "mysql2", raw, db };
},
"node-postgres": (): CliConnection => {
const raw = createPostgresPool();
const db = drizzlePostgres({ ...dbConfig, client: raw }) as unknown as CliDatabase;
return { driver: "node-postgres", raw, db };
},
};
const closeHandlers: Record<CliConnection["driver"], (entry: CliConnection) => Promise<void>> = {
"better-sqlite3": async (entry) => {
(entry as Extract<CliConnection, { driver: "better-sqlite3" }>).raw.close();
},
mysql2: (entry) => {
const pool = (entry as Extract<CliConnection, { driver: "mysql2" }>).raw;
return new Promise<void>((resolve, reject) => {
pool.end((err) => (err ? reject(err) : resolve()));
});
},
"node-postgres": async (entry) => {
await (entry as Extract<CliConnection, { driver: "node-postgres" }>).raw.end();
},
};
export const getCliDb = (): CliDatabase => {
if (connection) {
return connection.db;
}
const driver = dbEnv.DRIVER ?? "better-sqlite3";
connection = connectionFactories[driver]();
return connection.db;
};
export const closeCliDbAsync = async (): Promise<void> => {
if (!connection) {
return;
}
const current = connection;
connection = null;
await closeHandlers[current.driver](current);
};
+28 -29
View File
@@ -1,36 +1,35 @@
import { command } from "@drizzle-team/brocli"; import { eq } from "drizzle-orm";
import { db, eq } from "@homarr/db"; import { getCliDb } from "../cli-db";
import { requireCredentialsProvider } from "../errors";
import { users } from "@homarr/db/schema"; import { users } from "@homarr/db/schema";
export const fixUsernames = command({ export async function fixUsernamesHandler(): Promise<number> {
name: "fix-usernames", requireCredentialsProvider();
desc: "Changes all credentials usernames to lowercase",
// eslint-disable-next-line no-restricted-syntax const db = getCliDb();
handler: async () => { const credentialUsers = await db.query.users.findMany({
if (!process.env.AUTH_PROVIDERS?.toLowerCase().includes("credentials")) { where: eq(users.provider, "credentials"),
console.error("Credentials provider is not enabled"); });
return;
for (const user of credentialUsers) {
if (!user.name) {
continue;
}
if (user.name === user.name.toLowerCase()) {
continue;
} }
const credentialUsers = await db.query.users.findMany({ await db
where: eq(users.provider, "credentials"), .update(users)
}); .set({
name: user.name.toLowerCase(),
})
.where(eq(users.id, user.id));
for (const user of credentialUsers) { console.log(`Changed username from ${user.name} to ${user.name.toLowerCase()}`);
if (!user.name) continue; }
if (user.name === user.name.toLowerCase()) continue;
await db console.log("All usernames have been fixed");
.update(users) return 0;
.set({ }
name: user.name.toLowerCase(),
})
.where(eq(users.id, user.id));
console.log(`Changed username from ${user.name} to ${user.name.toLowerCase()}`);
}
console.log("All usernames have been fixed");
},
});
@@ -1,39 +1,50 @@
import { command, string } from "@drizzle-team/brocli"; import { parseArgs } from "node:util";
import { db, eq } from "@homarr/db"; import { eq } from "drizzle-orm";
import type { CliDatabase } from "../cli-db";
import { getCliDb } from "../cli-db";
import { CliError } from "../errors";
import { integrations } from "@homarr/db/schema"; import { integrations } from "@homarr/db/schema";
export const integrationsDelete = command({ const integrationLookup: Record<
name: "delete", "id" | "name",
desc: "Delete an integration by id or name", (db: CliDatabase, value: string) => Promise<{ id: string; name: string } | undefined>
options: { > = {
id: string("id").alias("i").desc("ID of the integration"), id: (db, value) =>
name: string("name").alias("n").desc("Name of the integration"), db.query.integrations.findFirst({
}, where: eq(integrations.id, value),
// eslint-disable-next-line no-restricted-syntax }),
handler: async (options) => { name: (db, value) =>
if (!options.id && !options.name) { db.query.integrations.findFirst({
console.error("Either --id or --name must be provided"); where: eq(integrations.name, value),
return; }),
} };
let entry; export async function integrationsDeleteHandler(args: string[]): Promise<number> {
if (options.id) { const { values } = parseArgs({
entry = await db.query.integrations.findFirst({ args,
where: eq(integrations.id, options.id), options: {
}); id: { type: "string", short: "i" },
} else if (options.name) { name: { type: "string", short: "n" },
entry = await db.query.integrations.findFirst({ },
where: eq(integrations.name, options.name), });
});
}
if (!entry) { const lookupKey = values.id ? "id" : values.name ? "name" : null;
console.error("Integration not found"); const lookupValue = values.id ?? values.name;
return;
}
await db.delete(integrations).where(eq(integrations.id, entry.id)); if (!lookupKey || !lookupValue) {
console.log(`Integration ${entry.name} (${entry.id}) deleted`); throw new CliError("Either --id or --name must be provided", 2);
}, }
});
const db = getCliDb();
const entry = await integrationLookup[lookupKey](db, lookupValue);
if (!entry) {
throw new CliError("Integration not found");
}
await db.delete(integrations).where(eq(integrations.id, entry.id));
console.log(`Integration ${entry.name} (${entry.id}) deleted`);
return 0;
}
+32 -18
View File
@@ -1,21 +1,35 @@
import { command } from "@drizzle-team/brocli"; import { parseArgs } from "node:util";
import { db } from "@homarr/db"; import { getCliDb } from "../cli-db";
import { printTable } from "../utils";
export const integrationsList = command({ export async function integrationsListHandler(args: string[] = []): Promise<number> {
name: "list", const { values } = parseArgs({
desc: "List all integrations (id and name)", args,
// eslint-disable-next-line no-restricted-syntax options: {
handler: async () => { json: { type: "boolean", default: false },
const all = await db.query.integrations.findMany(); },
if (all.length === 0) { strict: false,
console.log("No integrations found"); });
return;
}
console.log("ID\t\t\t\tName"); const db = getCliDb();
for (const i of all) { const all = await db.query.integrations.findMany();
console.log(`${i.id}\t${i.name}`);
} if (values.json) {
}, const output = all.map((i) => ({ id: i.id, name: i.name, kind: i.kind, url: i.url }));
}); console.log(JSON.stringify(output, null, 2));
return 0;
}
if (all.length === 0) {
console.log("No integrations found");
return 0;
}
printTable(
["ID", "Name", "Kind", "URL"],
all.map((i) => [i.id, i.name, i.kind, i.url]),
);
console.log(`\n${all.length} integration(s) total`);
return 0;
}
-10
View File
@@ -1,10 +0,0 @@
import { command } from "@drizzle-team/brocli";
import { integrationsDelete } from "./integrations-delete";
import { integrationsList } from "./integrations-list";
export const integrationsRoot = command({
name: "integrations",
desc: "Group of commands to manage integrations",
subcommands: [integrationsList, integrationsDelete],
});
+80 -76
View File
@@ -1,94 +1,98 @@
import { command, string } from "@drizzle-team/brocli"; import { parseArgs } from "node:util";
import { hashPasswordAsync } from "@homarr/auth"; import { hashPasswordAsync } from "@homarr/auth/security";
import { createId } from "@homarr/common"; import { createId } from "@homarr/common";
import { generateSecureRandomToken } from "@homarr/common/server"; import { generateSecureRandomToken } from "../utils";
import { and, count, db, eq } from "@homarr/db"; import { and, count, eq, max } from "drizzle-orm";
import { getMaxGroupPositionAsync } from "@homarr/db/queries";
import { getCliDb } from "../cli-db";
import { CliError, requireCredentialsProvider } from "../errors";
import { groupMembers, groupPermissions, groups, users } from "@homarr/db/schema"; import { groupMembers, groupPermissions, groups, users } from "@homarr/db/schema";
import { usernameSchema } from "@homarr/validation/user"; import { usernameSchema } from "@homarr/validation/user";
export const recreateAdmin = command({ export async function recreateAdminHandler(args: string[]): Promise<number> {
name: "recreate-admin", requireCredentialsProvider();
desc: "Recreate credentials admin user if none exists anymore",
options: {
username: string("username").required().alias("u").desc("Name of the admin"),
},
// eslint-disable-next-line no-restricted-syntax
handler: async (options) => {
if (!process.env.AUTH_PROVIDERS?.toLowerCase().includes("credentials")) {
console.error("Credentials provider is not enabled");
return;
}
const result = await usernameSchema.safeParseAsync(options.username); const { values } = parseArgs({
args,
options: {
username: { type: "string", short: "u" },
},
});
if (!result.success) { if (!values.username) {
console.error("Invalid username:"); throw new CliError("Missing required option: --username / -u", 2);
console.error(result.error.issues.map((error) => `- ${error.message}`).join("\n")); }
return;
}
const totalCount = await db const result = await usernameSchema.safeParseAsync(values.username);
.select({ if (!result.success) {
count: count(), const messages = result.error.issues.map((issue) => `- ${issue.message}`).join("\n");
}) throw new CliError(`Invalid username:\n${messages}`, 2);
.from(groupPermissions) }
.leftJoin(groupMembers, eq(groupMembers.groupId, groupPermissions.groupId))
.leftJoin(users, eq(users.id, groupMembers.userId))
.where(and(eq(groupPermissions.permission, "admin"), eq(users.provider, "credentials")))
.then((rows) => rows.at(0)?.count ?? 0);
if (totalCount > 0) { const db = getCliDb();
console.error("Credentials admin user exists");
return;
}
const existingUser = await db.query.users.findFirst({ const totalCount = await db
where: eq(users.name, result.data), .select({
}); count: count(),
})
.from(groupPermissions)
.leftJoin(groupMembers, eq(groupMembers.groupId, groupPermissions.groupId))
.leftJoin(users, eq(users.id, groupMembers.userId))
.where(and(eq(groupPermissions.permission, "admin"), eq(users.provider, "credentials")))
.then((rows: { count: number }[]) => rows.at(0)?.count ?? 0);
if (existingUser) { if (totalCount > 0) {
console.error("User with this name already exists"); throw new CliError("Credentials admin user exists");
return; }
}
const temporaryGroupId = createId(); const existingUser = await db.query.users.findFirst({
where: eq(users.name, result.data),
});
const maxPosition = await getMaxGroupPositionAsync(db); if (existingUser) {
await db.insert(groups).values({ throw new CliError("User with this name already exists");
id: temporaryGroupId, }
name: temporaryGroupId,
position: maxPosition + 1,
});
await db.insert(groupPermissions).values({ const temporaryGroupId = createId();
groupId: temporaryGroupId, const maxPosition = await db
permission: "admin", .select({ value: max(groups.position) })
}); .from(groups)
.then((result: { value: number | null }[]) => result[0]?.value ?? 1);
const password = generateSecureRandomToken(24); await db.insert(groups).values({
const hashedPassword = await hashPasswordAsync(password); id: temporaryGroupId,
name: temporaryGroupId,
position: maxPosition + 1,
});
const userId = createId(); await db.insert(groupPermissions).values({
await db.insert(users).values({ groupId: temporaryGroupId,
id: userId, permission: "admin",
name: result.data, });
provider: "credentials",
password: hashedPassword,
});
await db.insert(groupMembers).values({ const password = generateSecureRandomToken(24);
groupId: temporaryGroupId, const hashedPassword = await hashPasswordAsync(password);
userId, const userId = createId();
});
console.log( await db.insert(users).values({
"We created a new admin user for you. Please keep in mind, that the admin group of it has a temporary name. You should change it to something more meaningful.", id: userId,
); name: result.data,
console.log(`\tUsername: ${result.data}`); provider: "credentials",
console.log(`\tPassword: ${password}`); password: hashedPassword,
console.log(`\tGroup: ${temporaryGroupId}`); });
console.log(""); // Empty line for better readability
}, await db.insert(groupMembers).values({
}); groupId: temporaryGroupId,
userId,
});
console.log(
"We created a new admin user for you. Please keep in mind, that the admin group of it has a temporary name. You should change it to something more meaningful.",
);
console.log(`\tUsername: ${result.data}`);
console.log(`\tPassword: ${password}`);
console.log(`\tGroup: ${temporaryGroupId}`);
console.log("");
return 0;
}
+39 -37
View File
@@ -1,46 +1,48 @@
import { command, string } from "@drizzle-team/brocli"; import { parseArgs } from "node:util";
import { hashPasswordAsync } from "@homarr/auth"; import { hashPasswordAsync } from "@homarr/auth/security";
import { generateSecureRandomToken } from "@homarr/common/server"; import { generateSecureRandomToken } from "../utils";
import { and, db, eq } from "@homarr/db"; import { and, eq } from "drizzle-orm";
import { getCliDb } from "../cli-db";
import { CliError, requireCredentialsProvider } from "../errors";
import { sessions, users } from "@homarr/db/schema"; import { sessions, users } from "@homarr/db/schema";
export const resetPassword = command({ export async function resetPasswordHandler(args: string[]): Promise<number> {
name: "reset-password", requireCredentialsProvider();
desc: "Reset password for a user",
options: {
username: string("username").required().alias("u").desc("Name of the user"),
},
// eslint-disable-next-line no-restricted-syntax
handler: async (options) => {
if (!process.env.AUTH_PROVIDERS?.toLowerCase().includes("credentials")) {
console.error("Credentials provider is not enabled");
return;
}
const user = await db.query.users.findFirst({ const { values } = parseArgs({
where: and(eq(users.name, options.username), eq(users.provider, "credentials")), args,
}); options: {
username: { type: "string", short: "u" },
},
});
if (!user?.password) { if (!values.username) {
console.error(`User ${options.username} not found`); throw new CliError("Missing required option: --username / -u", 2);
return; }
}
// Generates a new password with 48 characters const db = getCliDb();
const newPassword = generateSecureRandomToken(24); const user = await db.query.users.findFirst({
where: and(eq(users.name, values.username), eq(users.provider, "credentials")),
});
await db if (!user?.password) {
.update(users) throw new CliError(`User ${values.username} not found`);
.set({ }
password: await hashPasswordAsync(newPassword),
})
.where(eq(users.id, user.id));
await db.delete(sessions).where(eq(sessions.userId, user.id)); const newPassword = generateSecureRandomToken(24);
console.log(`All sessions for user ${options.username} have been deleted`);
console.log("You can now login with the new password"); await db
console.log(`New password for user ${options.username}: ${newPassword}`); .update(users)
}, .set({
}); password: await hashPasswordAsync(newPassword),
})
.where(eq(users.id, user.id));
await db.delete(sessions).where(eq(sessions.userId, user.id));
console.log(`All sessions for user ${values.username} have been deleted`);
console.log("You can now login with the new password");
console.log(`New password for user ${values.username}: ${newPassword}`);
return 0;
}
+41 -33
View File
@@ -1,39 +1,47 @@
import { command, string } from "@drizzle-team/brocli"; import { parseArgs } from "node:util";
import { db, eq } from "@homarr/db"; import { eq } from "drizzle-orm";
import type { CliDatabase } from "../cli-db";
import { getCliDb } from "../cli-db";
import { CliError } from "../errors";
import { users } from "@homarr/db/schema"; import { users } from "@homarr/db/schema";
export const usersDelete = command({ const userLookup: Record<"id" | "username", (db: CliDatabase, value: string) => Promise<{ id: string; name: string | null } | undefined>> = {
name: "delete", id: (db, value) =>
desc: "Delete a user by id or username", db.query.users.findFirst({
options: { where: eq(users.id, value),
id: string("id").alias("i").desc("ID of the user"), }),
username: string("username").alias("u").desc("Name of the user"), username: (db, value) =>
}, db.query.users.findFirst({
// eslint-disable-next-line no-restricted-syntax where: eq(users.name, value),
handler: async (options) => { }),
if (!options.id && !options.username) { };
console.error("Either --id or --username must be provided");
return;
}
let user; export async function usersDeleteHandler(args: string[]): Promise<number> {
if (options.id) { const { values } = parseArgs({
user = await db.query.users.findFirst({ args,
where: eq(users.id, options.id), options: {
}); id: { type: "string", short: "i" },
} else if (options.username) { username: { type: "string", short: "u" },
user = await db.query.users.findFirst({ },
where: eq(users.name, options.username), });
});
}
if (!user) { const lookupKey = values.id ? "id" : values.username ? "username" : null;
console.error("User not found"); const lookupValue = values.id ?? values.username;
return;
}
await db.delete(users).where(eq(users.id, user.id)); if (!lookupKey || !lookupValue) {
console.log(`User ${user.name ?? user.id} (${user.id}) deleted`); throw new CliError("Either --id or --username must be provided", 2);
}, }
});
const db = getCliDb();
const user = await userLookup[lookupKey](db, lookupValue);
if (!user) {
throw new CliError("User not found");
}
await db.delete(users).where(eq(users.id, user.id));
console.log(`User ${user.name ?? user.id} (${user.id}) deleted`);
return 0;
}
+31 -18
View File
@@ -1,22 +1,35 @@
import { command } from "@drizzle-team/brocli"; import { parseArgs } from "node:util";
import { db } from "@homarr/db"; import { getCliDb } from "../cli-db";
import { printTable } from "../utils";
export const usersList = command({ export async function usersListHandler(args: string[] = []): Promise<number> {
name: "list", const { values } = parseArgs({
desc: "List all users (id, username, email)", args,
// eslint-disable-next-line no-restricted-syntax options: {
handler: async () => { json: { type: "boolean", default: false },
const allUsers = await db.query.users.findMany(); },
strict: false,
});
if (allUsers.length === 0) { const db = getCliDb();
console.log("No users found"); const allUsers = await db.query.users.findMany();
return;
}
console.log("ID\t\t\t\tUsername\tEmail"); if (values.json) {
for (const user of allUsers) { const output = allUsers.map((u) => ({ id: u.id, name: u.name, email: u.email, provider: u.provider }));
console.log(`${user.id}\t${user.name ?? ""}\t${user.email ?? ""}`); console.log(JSON.stringify(output, null, 2));
} return 0;
}, }
});
if (allUsers.length === 0) {
console.log("No users found");
return 0;
}
printTable(
["ID", "Username", "Email", "Provider"],
allUsers.map((u) => [u.id, u.name ?? "", u.email ?? "", u.provider]),
);
console.log(`\n${allUsers.length} user(s) total`);
return 0;
}
@@ -1,50 +1,66 @@
import { command, string } from "@drizzle-team/brocli"; import { parseArgs } from "node:util";
import { hashPasswordAsync } from "@homarr/auth"; import { hashPasswordAsync } from "@homarr/auth/security";
import { db, eq } from "@homarr/db"; import { eq } from "drizzle-orm";
import type { CliDatabase } from "../cli-db";
import { getCliDb } from "../cli-db";
import { CliError, requireCredentialsProvider } from "../errors";
import { sessions, users } from "@homarr/db/schema"; import { sessions, users } from "@homarr/db/schema";
export const usersUpdatePassword = command({ const userLookup: Record<
name: "update-password", "id" | "username",
desc: "Update the password for a user (credentials provider only)", (db: CliDatabase, value: string) => Promise<{ id: string; name: string | null; password: string | null } | undefined>
options: { > = {
id: string("id").alias("i").desc("ID of the user"), id: (db, value) =>
username: string("username").alias("u").desc("Name of the user"), db.query.users.findFirst({
password: string("password").alias("p").required().desc("New password"), where: eq(users.id, value),
}, }),
// eslint-disable-next-line no-restricted-syntax username: (db, value) =>
handler: async (options) => { db.query.users.findFirst({
if (!process.env.AUTH_PROVIDERS?.toLowerCase().includes("credentials")) { where: eq(users.name, value),
console.error("Credentials provider is not enabled"); }),
return; };
}
if (!options.id && !options.username) { export async function usersUpdatePasswordHandler(args: string[]): Promise<number> {
console.error("Either --id or --username must be provided"); requireCredentialsProvider();
return;
}
const user = await db.query.users.findFirst({ const { values } = parseArgs({
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion args,
where: options.id ? eq(users.id, options.id) : eq(users.name, options.username!), options: {
}); id: { type: "string", short: "i" },
username: { type: "string", short: "u" },
password: { type: "string", short: "p" },
},
});
if (!user?.password) { const lookupKey = values.id ? "id" : values.username ? "username" : null;
console.error("User not found or has no credentials record"); const lookupValue = values.id ?? values.username;
return;
}
await db if (!lookupKey || !lookupValue) {
.update(users) throw new CliError("Either --id or --username must be provided", 2);
.set({ }
password: await hashPasswordAsync(options.password),
})
.where(eq(users.id, user.id));
// invalidate existing sessions if (!values.password) {
await db.delete(sessions).where(eq(sessions.userId, user.id)); throw new CliError("Missing required option: --password / -p", 2);
console.log(`All sessions for user ${user.name ?? user.id} have been deleted`); }
console.log("Password updated successfully"); const db = getCliDb();
}, const user = await userLookup[lookupKey](db, lookupValue);
});
if (!user?.password) {
throw new CliError("User not found or has no credentials record");
}
await db
.update(users)
.set({
password: await hashPasswordAsync(values.password),
})
.where(eq(users.id, user.id));
await db.delete(sessions).where(eq(sessions.userId, user.id));
console.log(`All sessions for user ${user.name ?? user.id} have been deleted`);
console.log("Password updated successfully");
return 0;
}
-11
View File
@@ -1,11 +0,0 @@
import { command } from "@drizzle-team/brocli";
import { usersDelete } from "./users-delete";
import { usersList } from "./users-list";
import { usersUpdatePassword } from "./users-update-password";
export const usersRoot = command({
name: "users",
desc: "Group of commands to manage users",
subcommands: [usersList, usersDelete, usersUpdatePassword],
});
+16
View File
@@ -0,0 +1,16 @@
export class CliError extends Error {
constructor(
message: string,
readonly exitCode: 1 | 2 = 1,
) {
super(message);
this.name = "CliError";
}
}
export const requireCredentialsProvider = () => {
const enabled = process.env.AUTH_PROVIDERS?.toLowerCase().includes("credentials") ?? false;
if (!enabled) {
throw new CliError("Credentials provider is not enabled");
}
};
+38 -11
View File
@@ -1,14 +1,41 @@
import { run } from "@drizzle-team/brocli"; import { closeCliDbAsync } from "./cli-db";
import { CliError } from "./errors";
import { runCliAsync } from "./router";
import { fixUsernames } from "./commands/fix-usernames"; const mainAsync = async (): Promise<number> => {
import { integrationsRoot } from "./commands/integrations"; const argv = process.argv.slice(2);
import { recreateAdmin } from "./commands/recreate-admin"; const start = performance.now();
import { resetPassword } from "./commands/reset-password";
import { usersRoot } from "./commands/users";
const commands = [usersRoot, integrationsRoot, resetPassword, fixUsernames, recreateAdmin]; try {
const code = await runCliAsync(argv);
if (code === 0) {
const elapsed = Math.round(performance.now() - start);
console.error(`\nDone in ${elapsed}ms`);
}
return code;
} catch (error) {
if (error instanceof CliError) {
console.error(error.message);
return error.exitCode;
}
void run(commands, { if (error instanceof TypeError && error.message.startsWith("Unknown option")) {
name: "homarr-cli", console.error(error.message);
version: "1.0.0", return 2;
}); }
console.error(error instanceof Error ? error.message : error);
return 1;
}
};
mainAsync()
.then(async (code) => {
await closeCliDbAsync();
process.exit(code);
})
.catch(async (error) => {
console.error(error instanceof Error ? error.message : error);
await closeCliDbAsync();
process.exit(1);
});
+167
View File
@@ -0,0 +1,167 @@
import { fixUsernamesHandler } from "./commands/fix-usernames";
import { integrationsDeleteHandler } from "./commands/integrations-delete";
import { integrationsListHandler } from "./commands/integrations-list";
import { recreateAdminHandler } from "./commands/recreate-admin";
import { resetPasswordHandler } from "./commands/reset-password";
import { usersDeleteHandler } from "./commands/users-delete";
import { usersListHandler } from "./commands/users-list";
import { usersUpdatePasswordHandler } from "./commands/users-update-password";
import { CliError } from "./errors";
const VERSION = "1.0.0";
type CommandHandler = (args: string[]) => Promise<number>;
interface CommandDef {
handler: CommandHandler;
desc: string;
usage: string;
}
type CommandGroup = Record<string, CommandDef>;
const topLevelCommands: Record<string, CommandDef> = {
"reset-password": {
handler: resetPasswordHandler,
desc: "Reset password for a credentials user",
usage: "homarr reset-password -u <username>",
},
"fix-usernames": {
handler: (args) => fixUsernamesHandler(),
desc: "Lowercase all credentials usernames",
usage: "homarr fix-usernames",
},
"recreate-admin": {
handler: recreateAdminHandler,
desc: "Create credentials admin if none exists",
usage: "homarr recreate-admin -u <username>",
},
};
const commandGroups: Record<string, CommandGroup> = {
users: {
list: {
handler: (args) => usersListHandler(args),
desc: "List all users",
usage: "homarr users list [--json]",
},
delete: {
handler: usersDeleteHandler,
desc: "Delete a user by id or username",
usage: "homarr users delete --id <id> | --username <name>",
},
"update-password": {
handler: usersUpdatePasswordHandler,
desc: "Set password for a credentials user",
usage: "homarr users update-password (--id <id> | --username <name>) --password <pw>",
},
},
integrations: {
list: {
handler: (args) => integrationsListHandler(args),
desc: "List all integrations",
usage: "homarr integrations list [--json]",
},
delete: {
handler: integrationsDeleteHandler,
desc: "Delete an integration by id or name",
usage: "homarr integrations delete --id <id> | --name <name>",
},
},
};
const HELP_TEXT = `homarr-cli ${VERSION}
Usage:
homarr <command> [options]
Commands:
reset-password Reset password for a credentials user
recreate-admin Create credentials admin if none exists
fix-usernames Lowercase all credentials usernames
users list List all users
users delete Delete a user by id or username
users update-password Set password for a credentials user
integrations list List all integrations
integrations delete Delete an integration by id or name
Global Options:
-h, --help Show help (use after a command for command-specific help)
-v, --version Show CLI version
`;
const printHelp = () => {
console.log(HELP_TEXT);
};
const printCommandHelp = (def: CommandDef) => {
console.log(`${def.desc}\n`);
console.log(`Usage:\n ${def.usage}\n`);
};
const resolveHandler = (argv: string[]): { handler: CommandHandler; args: string[] } => {
const [command, subcommand, ...rest] = argv;
if (!command) {
throw new CliError("Missing command", 2);
}
const group = commandGroups[command];
if (group) {
if (!subcommand || subcommand === "--help" || subcommand === "-h") {
const subcommands = Object.entries(group)
.map(([name, def]) => ` ${name.padEnd(18)} ${def.desc}`)
.join("\n");
console.log(`Usage:\n homarr ${command} <subcommand> [options]\n\nSubcommands:\n${subcommands}\n`);
return { handler: async () => subcommand ? 0 : 2, args: [] };
}
const def = group[subcommand];
if (!def) {
throw new CliError(`Unknown subcommand "${subcommand}" for "${command}"`, 2);
}
if (hasFlag(rest, "--help", "-h")) {
printCommandHelp(def);
return { handler: async () => 0, args: [] };
}
return { handler: def.handler, args: rest };
}
const def = topLevelCommands[command];
if (!def) {
throw new CliError(`Unknown command "${command}"`, 2);
}
const args = argv.slice(1);
if (hasFlag(args, "--help", "-h")) {
printCommandHelp(def);
return { handler: async () => 0, args: [] };
}
return { handler: def.handler, args };
};
const hasFlag = (argv: string[], flag: string, short: string) =>
argv.some((arg) => arg === flag || arg === short);
export const runCliAsync = async (argv: string[]): Promise<number> => {
if (hasFlag(argv, "--help", "-h") && argv.length === 1) {
printHelp();
return 0;
}
if (hasFlag(argv, "--version", "-v")) {
console.log(VERSION);
return 0;
}
if (argv.length === 0) {
printHelp();
return 2;
}
const { handler, args } = resolveHandler(argv);
return handler(args);
};
+18
View File
@@ -0,0 +1,18 @@
import { randomBytes } from "node:crypto";
export const generateSecureRandomToken = (size: number) => randomBytes(size).toString("hex");
export const printTable = (headers: string[], rows: string[][]) => {
const widths = headers.map((h, i) =>
Math.max(h.length, ...rows.map((r) => (r[i] ?? "").length)),
);
const formatRow = (cells: string[]) =>
cells.map((cell, i) => cell.padEnd(widths[i]!)).join(" ");
console.log(formatRow(headers));
console.log(widths.map((w) => "─".repeat(w)).join(" "));
for (const row of rows) {
console.log(formatRow(row));
}
};
+1
View File
@@ -14,6 +14,7 @@
"./infrastructure/db": "./src/infrastructure/db/index.ts", "./infrastructure/db": "./src/infrastructure/db/index.ts",
"./infrastructure/db/env": "./src/infrastructure/db/env.ts", "./infrastructure/db/env": "./src/infrastructure/db/env.ts",
"./infrastructure/db/constants": "./src/infrastructure/db/constants.ts", "./infrastructure/db/constants": "./src/infrastructure/db/constants.ts",
"./infrastructure/db/mapping": "./src/infrastructure/db/mapping.ts",
"./infrastructure/certificates": "./src/infrastructure/certificates/index.ts", "./infrastructure/certificates": "./src/infrastructure/certificates/index.ts",
"./infrastructure/certificates/hostnames/db/sqlite": "./src/infrastructure/certificates/hostnames/db/sqlite.ts", "./infrastructure/certificates/hostnames/db/sqlite": "./src/infrastructure/certificates/hostnames/db/sqlite.ts",
"./infrastructure/certificates/hostnames/db/mysql": "./src/infrastructure/certificates/hostnames/db/mysql.ts", "./infrastructure/certificates/hostnames/db/mysql": "./src/infrastructure/certificates/hostnames/db/mysql.ts",
+9
View File
@@ -0,0 +1,9 @@
import baseConfig from "@homarr/eslint-config/base";
/** @type {import('typescript-eslint').Config} */
export default [
{
ignores: [],
},
...baseConfig,
];
+46
View File
@@ -0,0 +1,46 @@
{
"name": "@homarr/cron-job-api",
"version": "0.1.0",
"private": true,
"license": "Apache-2.0",
"type": "module",
"exports": {
".": "./src/index.ts",
"./env": "./src/env.ts",
"./constants": "./src/constants.ts",
"./client": "./src/client.ts"
},
"typesVersions": {
"*": {
"*": [
"src/*"
]
}
},
"scripts": {
"clean": "rm -rf .turbo node_modules",
"format": "prettier --check . --ignore-path ../../.gitignore",
"lint": "eslint",
"typecheck": "tsc --noEmit"
},
"prettier": "@homarr/prettier-config",
"dependencies": {
"@homarr/common": "workspace:^0.1.0",
"@homarr/core": "workspace:^0.1.0",
"@homarr/cron-jobs": "workspace:^0.1.0",
"@tanstack/react-query": "catalog:",
"@trpc/client": "catalog:",
"@trpc/server": "catalog:",
"@trpc/tanstack-react-query": "catalog:",
"react": "catalog:",
"zod": "catalog:"
},
"devDependencies": {
"@homarr/eslint-config": "workspace:^0.2.0",
"@homarr/prettier-config": "workspace:^0.1.0",
"@homarr/tsconfig": "workspace:^0.1.0",
"@types/react": "catalog:",
"eslint": "catalog:",
"typescript": "catalog:"
}
}
+20
View File
@@ -0,0 +1,20 @@
import { createTRPCClient, httpLink } from "@trpc/client";
import type { JobRouter } from ".";
import { CRON_JOB_API_KEY_HEADER, CRON_JOB_API_PATH, CRON_JOB_API_PORT } from "./constants";
import { env } from "./env";
export const cronJobApi = createTRPCClient<JobRouter>({
links: [
httpLink({
url: `${getBaseUrl()}${CRON_JOB_API_PATH}`,
headers: {
[CRON_JOB_API_KEY_HEADER]: env.CRON_JOB_API_KEY,
},
}),
],
});
function getBaseUrl() {
return `http://localhost:${CRON_JOB_API_PORT}`;
}
+3
View File
@@ -0,0 +1,3 @@
export const CRON_JOB_API_PORT = 3002;
export const CRON_JOB_API_PATH = "/trpc";
export const CRON_JOB_API_KEY_HEADER = "cron-job-api-key";
+11
View File
@@ -0,0 +1,11 @@
import { z } from "zod/v4";
import { env as commonEnv } from "@homarr/common/env";
import { createEnv } from "@homarr/core/infrastructure/env";
export const env = createEnv({
server: {
CRON_JOB_API_KEY: commonEnv.NODE_ENV === "development" ? z.string().default("test") : z.string(),
},
experimental__runtimeEnv: process.env,
});
+85
View File
@@ -0,0 +1,85 @@
import { initTRPC, TRPCError } from "@trpc/server";
import { z } from "zod/v4";
import type { JobGroupKeys } from "@homarr/cron-jobs";
import { jobGroup } from "@homarr/cron-jobs";
import { env } from "./env";
export const jobGroupKeys = jobGroup.getKeys();
export const jobNameSchema = z.enum(jobGroup.getKeys());
export interface IJobManager {
startAsync(name: JobGroupKeys): Promise<void>;
triggerAsync(name: JobGroupKeys): Promise<void>;
stop(name: JobGroupKeys): void;
updateIntervalAsync(name: JobGroupKeys, cron: string): Promise<void>;
disableAsync(name: JobGroupKeys): Promise<void>;
enableAsync(name: JobGroupKeys): Promise<void>;
getAllAsync(): Promise<
{
name: JobGroupKeys;
cron: string;
preventManualExecution: boolean;
preventCustomInterval: boolean;
isEnabled: boolean;
}[]
>;
}
const t = initTRPC
.context<{
manager: IJobManager;
apiKey?: string;
}>()
.create();
const createTrpcRouter = t.router;
const apiKeyProcedure = t.procedure.use(({ ctx, next }) => {
if (ctx.apiKey !== env.CRON_JOB_API_KEY) {
throw new TRPCError({
code: "FORBIDDEN",
message: "Missing or invalid API key",
});
}
return next({
ctx: {
...ctx,
apiKey: undefined, // Clear the API key after checking
},
});
});
export const jobRouter = createTrpcRouter({
start: apiKeyProcedure.input(jobNameSchema).mutation(async ({ input, ctx }) => {
await ctx.manager.startAsync(input);
}),
trigger: apiKeyProcedure.input(jobNameSchema).mutation(async ({ input, ctx }) => {
await ctx.manager.triggerAsync(input);
}),
stop: apiKeyProcedure.input(jobNameSchema).mutation(({ input, ctx }) => {
ctx.manager.stop(input);
}),
updateInterval: apiKeyProcedure
.input(
z.object({
name: jobNameSchema,
cron: z.string(),
}),
)
.mutation(async ({ input, ctx }) => {
await ctx.manager.updateIntervalAsync(input.name, input.cron);
}),
disable: apiKeyProcedure.input(jobNameSchema).mutation(async ({ input, ctx }) => {
await ctx.manager.disableAsync(input);
}),
enable: apiKeyProcedure.input(jobNameSchema).mutation(async ({ input, ctx }) => {
await ctx.manager.enableAsync(input);
}),
getAll: apiKeyProcedure.query(({ ctx }) => {
return ctx.manager.getAllAsync();
}),
});
export type JobRouter = typeof jobRouter;
+8
View File
@@ -0,0 +1,8 @@
{
"extends": "@homarr/tsconfig/base.json",
"compilerOptions": {
"tsBuildInfoFile": "node_modules/.cache/tsbuildinfo.json"
},
"include": ["*.ts", "src"],
"exclude": ["node_modules"]
}
+2 -4
View File
@@ -5,8 +5,7 @@
"license": "Apache-2.0", "license": "Apache-2.0",
"type": "module", "type": "module",
"exports": { "exports": {
".": "./index.ts", ".": "./index.ts"
"./job-manager": "./src/job-manager.ts"
}, },
"typesVersions": { "typesVersions": {
"*": { "*": {
@@ -39,8 +38,7 @@
"@homarr/server-settings": "workspace:^0.1.0", "@homarr/server-settings": "workspace:^0.1.0",
"@homarr/translation": "workspace:^0.1.0", "@homarr/translation": "workspace:^0.1.0",
"@homarr/validation": "workspace:^0.1.0", "@homarr/validation": "workspace:^0.1.0",
"semver-parser": "catalog:", "semver-parser": "catalog:"
"zod": "catalog:"
}, },
"devDependencies": { "devDependencies": {
"@homarr/eslint-config": "workspace:^0.2.0", "@homarr/eslint-config": "workspace:^0.2.0",
+29 -40
View File
@@ -28,45 +28,34 @@ import { updateCheckerJob } from "./jobs/update-checker";
import { weatherJob } from "./jobs/weather"; import { weatherJob } from "./jobs/weather";
import { createCronJobGroup } from "./lib"; import { createCronJobGroup } from "./lib";
const getJobGroup = () => { export const jobGroup = createCronJobGroup({
return createCronJobGroup({ analytics: analyticsJob,
analytics: analyticsJob, iconsUpdater: iconsUpdaterJob,
iconsUpdater: iconsUpdaterJob, ping: pingJob,
ping: pingJob, smartHomeEntityState: smartHomeEntityStateJob,
smartHomeEntityState: smartHomeEntityStateJob, mediaServer: mediaServerJob,
mediaServer: mediaServerJob, mediaOrganizer: mediaOrganizerJob,
mediaOrganizer: mediaOrganizerJob, downloads: downloadsJob,
downloads: downloadsJob, dnsHole: dnsHoleJob,
dnsHole: dnsHoleJob, mediaRequestStats: mediaRequestStatsJob,
mediaRequestStats: mediaRequestStatsJob, mediaRequestList: mediaRequestListJob,
mediaRequestList: mediaRequestListJob, rssFeeds: rssFeedsJob,
rssFeeds: rssFeedsJob, indexerManager: indexerManagerJob,
indexerManager: indexerManagerJob, healthMonitoring: healthMonitoringJob,
healthMonitoring: healthMonitoringJob, updateChecker: updateCheckerJob,
updateChecker: updateCheckerJob, mediaTranscoding: mediaTranscodingJob,
mediaTranscoding: mediaTranscodingJob, minecraftServerStatus: minecraftServerStatusJob,
minecraftServerStatus: minecraftServerStatusJob, dockerContainers: dockerContainersJob,
dockerContainers: dockerContainersJob, networkController: networkControllerJob,
networkController: networkControllerJob, firewallCpu: firewallCpuJob,
firewallCpu: firewallCpuJob, firewallMemory: firewallMemoryJob,
firewallMemory: firewallMemoryJob, firewallVersion: firewallVersionJob,
firewallVersion: firewallVersionJob, firewallInterfaces: firewallInterfacesJob,
firewallInterfaces: firewallInterfacesJob, refreshNotifications: refreshNotificationsJob,
refreshNotifications: refreshNotificationsJob, weather: weatherJob,
weather: weatherJob, timetable: timetableJob,
timetable: timetableJob, tracearr: tracearrJob,
tracearr: tracearrJob, umamiActiveVisitors: umamiActiveVisitorsJob,
umamiActiveVisitors: umamiActiveVisitorsJob, });
});
};
// Add global type augmentation for homarr
declare global {
var cronJobs: ReturnType<typeof getJobGroup> | undefined;
}
global.cronJobs ??= getJobGroup();
export const jobGroup = global.cronJobs;
export type JobGroupKeys = ReturnType<(typeof jobGroup)["getKeys"]>[number]; export type JobGroupKeys = ReturnType<(typeof jobGroup)["getKeys"]>[number];
+1 -1
View File
@@ -1,6 +1,6 @@
import type { InferSelectModel } from "drizzle-orm"; import type { InferSelectModel } from "drizzle-orm";
import { createSchema } from "@homarr/core/infrastructure/db"; import { createDbMapping as createSchema } from "@homarr/core/infrastructure/db/mapping";
import * as mysqlSchema from "./mysql"; import * as mysqlSchema from "./mysql";
import * as pgSchema from "./postgresql"; import * as pgSchema from "./postgresql";
+2 -2
View File
@@ -65,8 +65,8 @@ const columnsRatios: Record<keyof ExtendedDownloadClientItem, number> = {
id: 1, id: 1,
index: 1, index: 1,
integration: 1, integration: 1,
name: 8, name: 16,
progress: 4, progress: 6,
ratio: 2, ratio: 2,
received: 3, received: 3,
sent: 3, sent: 3,
+1572 -1152
View File
File diff suppressed because it is too large. Load diff
+11 -1
View File
@@ -16,6 +16,8 @@ fi
# Auth secret is generated every time the container starts as it is required, but not used because we don't need JWTs or Mail hashing # Auth secret is generated every time the container starts as it is required, but not used because we don't need JWTs or Mail hashing
export AUTH_SECRET=$(openssl rand -base64 32) export AUTH_SECRET=$(openssl rand -base64 32)
# Cron job API key is generated every time the container starts as it is required for communication between nextjs-api and tasks-api
export CRON_JOB_API_KEY=$(openssl rand -base64 32)
# Start nginx proxy # Start nginx proxy
# 1. Replace the HOSTNAME in the nginx template file # 1. Replace the HOSTNAME in the nginx template file
@@ -36,13 +38,21 @@ else
REDIS_PID=$! REDIS_PID=$!
fi fi
node apps/tasks/tasks.cjs &
TASKS_PID=$!
node apps/websocket/wssServer.cjs &
WSS_PID=$!
node apps/nextjs/server.js & node apps/nextjs/server.js &
NEXTJS_PID=$! NEXTJS_PID=$!
# Function to handle SIGTERM and shut down services # Function to handle SIGTERM and shut down services
terminate() { terminate() {
echo "Received SIGTERM. Shutting down..." echo "Received SIGTERM. Shutting down..."
kill -TERM $NGINX_PID $NEXTJS_PID 2>/dev/null kill -TERM $NGINX_PID $TASKS_PID $WSS_PID $NEXTJS_PID 2>/dev/null
wait wait
# kill redis-server last because of logging of other services and only if $REDIS_PID is set # kill redis-server last because of logging of other services and only if $REDIS_PID is set
if [ -n "$REDIS_PID" ]; then if [ -n "$REDIS_PID" ]; then