From a3c202a6627455841ba32a58499c39258bc31f00 Mon Sep 17 00:00:00 2001 From: ZTatman Date: Thu, 9 Apr 2026 20:40:55 -0400 Subject: [PATCH] feat(cli): add config print, verify, and doctor commands for config validation - myst config print: show current config with redacted secrets - myst verify: verify Forgejo connectivity and API token - myst doctor: comprehensive validation of config and connectivity - add start script to service package.json --- .dockerignore | 14 ++ Dockerfile | 22 +++ packages/cli/src/commands/config.ts | 96 ++++++++++ packages/cli/src/commands/doctor.ts | 226 ++++++++++++++++++++++++ packages/cli/src/commands/verify.ts | 260 ++++++++++++++++++++++++++++ packages/cli/src/index.ts | 8 +- packages/service/package.json | 1 + 7 files changed, 626 insertions(+), 1 deletion(-) create mode 100644 .dockerignore create mode 100644 Dockerfile create mode 100644 packages/cli/src/commands/config.ts create mode 100644 packages/cli/src/commands/doctor.ts create mode 100644 packages/cli/src/commands/verify.ts diff --git a/.dockerignore b/.dockerignore new file mode 100644 index 0000000..1adec87 --- /dev/null +++ b/.dockerignore @@ -0,0 +1,14 @@ +node_modules +.git +*.log +.env +.env.* +!.env.example +dist +tsconfig.tsbuildinfo +*.tsbuildinfo +coverage +.vscode +.idea +*.md +!README.md diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..6466c05 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,22 @@ +FROM node:22-alpine + +WORKDIR /app + +COPY package*.json ./ +COPY packages/service/package*.json ./packages/service/ +COPY packages/shared/package*.json ./packages/shared/ +COPY tsconfig.base.json ./ + +RUN npm install -g pnpm + +RUN pnpm install --frozen-lockfile + +COPY . . + +RUN pnpm -r --filter @myst/service build + +ENV PORT=3000 + +EXPOSE 3000 + +CMD ["pnpm", "--filter", "@myst/service", "start"] diff --git a/packages/cli/src/commands/config.ts b/packages/cli/src/commands/config.ts new file mode 100644 index 0000000..30baa73 --- /dev/null +++ b/packages/cli/src/commands/config.ts @@ -0,0 +1,96 @@ +import fs from "node:fs"; +import path from "node:path"; + +import * as c from "yoctocolors"; + +interface MystConfig { + publicUrl?: string; + adminUrl?: string; + databaseUrl?: string; + forgejoBaseUrl?: string; + forgejoBotUsername?: string; + forgejoPat?: string; + grantTokenSecret?: string; +} + +function redactSecret(value: string | undefined): string { + if (!value) return c.dim("not set"); + if (value.length <= 4) return c.dim("****"); + return value.slice(0, 4) + c.dim("****"); +} + +function parseEnvFile(envPath: string): MystConfig { + const config: MystConfig = {}; + + const content = fs.readFileSync(envPath, "utf-8"); + const lines = content.split("\n"); + + for (const line of lines) { + const trimmed = line.trim(); + if (!trimmed || trimmed.startsWith("#")) continue; + + const [key, ...valueParts] = trimmed.split("="); + if (!key) continue; + + const value = valueParts.join("=").trim(); + + switch (key) { + case "MYST_PUBLIC_URL": + config.publicUrl = value; + break; + case "MYST_ADMIN_URL": + config.adminUrl = value; + break; + case "DATABASE_URL": + config.databaseUrl = value; + break; + case "FORGEJO_BASE_URL": + config.forgejoBaseUrl = value; + break; + case "FORGEJO_BOT_USERNAME": + config.forgejoBotUsername = value; + break; + case "FORGEJO_PAT": + config.forgejoPat = value; + break; + case "GRANT_TOKEN_SECRET": + config.grantTokenSecret = value; + break; + } + } + + return config; +} + +export async function configCommand(): Promise { + const envPath = path.join(process.cwd(), ".env"); + + let config: MystConfig; + + try { + config = parseEnvFile(envPath); + } catch (error) { + const err = error as NodeJS.ErrnoException; + if (err.code === "ENOENT") { + process.stderr.write( + `${c.red("Error:")} .env file not found in ${process.cwd()}\n`, + ); + process.exitCode = 1; + return; + } + throw error; + } + + process.stdout.write(c.bold("Myst Configuration\n")); + process.stdout.write(`${c.dim("─".repeat(40))}\n`); + + process.stdout.write(`${c.bold("MYST_PUBLIC_URL:")} ${config.publicUrl || c.dim("not set")}\n`); + process.stdout.write(`${c.bold("MYST_ADMIN_URL:")} ${config.adminUrl || c.dim("not set")}\n`); + process.stdout.write(`${c.bold("DATABASE_URL:")} ${config.databaseUrl || c.dim("not set")}\n`); + process.stdout.write(`${c.bold("FORGEJO_BASE_URL:")} ${config.forgejoBaseUrl || c.dim("not set")}\n`); + process.stdout.write(`${c.bold("FORGEJO_BOT_USERNAME:")} ${config.forgejoBotUsername || c.dim("not set")}\n`); + process.stdout.write(`${c.bold("FORGEJO_PAT:")} ${redactSecret(config.forgejoPat)}\n`); + process.stdout.write(`${c.bold("GRANT_TOKEN_SECRET:")} ${redactSecret(config.grantTokenSecret)}\n`); + + process.exitCode = 0; +} diff --git a/packages/cli/src/commands/doctor.ts b/packages/cli/src/commands/doctor.ts new file mode 100644 index 0000000..78d4821 --- /dev/null +++ b/packages/cli/src/commands/doctor.ts @@ -0,0 +1,226 @@ +import fs from "node:fs"; +import path from "node:path"; + +import * as c from "yoctocolors"; +import * as p from "@clack/prompts"; + +interface MystConfig { + publicUrl?: string; + adminUrl?: string; + databaseUrl?: string; + forgejoBaseUrl?: string; + forgejoBotUsername?: string; + forgejoPat?: string; + grantTokenSecret?: string; +} + +function parseEnvFile(envPath: string): MystConfig { + const config: MystConfig = {}; + + const content = fs.readFileSync(envPath, "utf-8"); + const lines = content.split("\n"); + + for (const line of lines) { + const trimmed = line.trim(); + if (!trimmed || trimmed.startsWith("#")) continue; + + const [key, ...valueParts] = trimmed.split("="); + if (!key) continue; + + const value = valueParts.join("=").trim(); + + switch (key) { + case "MYST_PUBLIC_URL": + config.publicUrl = value; + break; + case "MYST_ADMIN_URL": + config.adminUrl = value; + break; + case "DATABASE_URL": + config.databaseUrl = value; + break; + case "FORGEJO_BASE_URL": + config.forgejoBaseUrl = value; + break; + case "FORGEJO_BOT_USERNAME": + config.forgejoBotUsername = value; + break; + case "FORGEJO_PAT": + config.forgejoPat = value; + break; + case "GRANT_TOKEN_SECRET": + config.grantTokenSecret = value; + break; + } + } + + return config; +} + +type CheckResult = { + name: string; + success: boolean; + message?: string; +}; + +async function checkForgejoReachability(baseUrl: string): Promise { + try { + const response = await fetch(baseUrl, { method: "GET" }); + if (response.ok || response.status === 200) { + return { name: "Forgejo reachability", success: true }; + } + return { + name: "Forgejo reachability", + success: false, + message: `HTTP ${response.status}`, + }; + } catch (error) { + const message = error instanceof Error ? error.message : "Unknown error"; + return { + name: "Forgejo reachability", + success: false, + message, + }; + } +} + +async function checkForgejoApi( + baseUrl: string, + pat: string, +): Promise { + try { + const response = await fetch(`${baseUrl}/api/v1/user`, { + method: "GET", + headers: { + Authorization: `Bearer ${pat}`, + }, + }); + + if (response.status === 401) { + return { + name: "Forgejo API token", + success: false, + message: "Invalid or expired token", + }; + } + + if (!response.ok) { + return { + name: "Forgejo API token", + success: false, + message: `HTTP ${response.status}`, + }; + } + + const user = (await response.json()) as { login: string }; + return { + name: "Forgejo API token", + success: true, + message: `Authenticated as ${c.green(user.login)}`, + }; + } catch (error) { + const message = error instanceof Error ? error.message : "Unknown error"; + return { + name: "Forgejo API token", + success: false, + message, + }; + } +} + +export async function doctorCommand(): Promise { + p.intro(c.bold("myst doctor")); + + const envPath = path.join(process.cwd(), ".env"); + const results: CheckResult[] = []; + + let config: MystConfig; + + try { + config = parseEnvFile(envPath); + } catch (error) { + const err = error as NodeJS.ErrnoException; + if (err.code === "ENOENT") { + p.cancel(`${c.red("Error:")} .env file not found in ${process.cwd()}`); + process.exitCode = 1; + return; + } + throw error; + } + + function addResult(name: string, success: boolean, message?: string) { + results.push({ name, success, ...(message && { message }) }); + } + + addResult("Config file exists", true, envPath); + + const requiredFields = [ + { key: "publicUrl", name: "MYST_PUBLIC_URL" }, + { key: "adminUrl", name: "MYST_ADMIN_URL" }, + { key: "databaseUrl", name: "DATABASE_URL" }, + { key: "forgejoBaseUrl", name: "FORGEJO_BASE_URL" }, + { key: "forgejoBotUsername", name: "FORGEJO_BOT_USERNAME" }, + { key: "forgejoPat", name: "FORGEJO_PAT" }, + { key: "grantTokenSecret", name: "GRANT_TOKEN_SECRET" }, + ]; + + for (const field of requiredFields) { + const value = config[field.key as keyof MystConfig]; + addResult(`${field.name} set`, !!value, value ? "configured" : "missing"); + } + + if (config.databaseUrl) { + try { + const url = new URL(config.databaseUrl); + const valid = url.protocol === "postgres:" || + url.protocol === "postgresql:"; + addResult("Database URL format", valid, valid ? "valid" : "invalid"); + } catch { + addResult("Database URL format", false, "invalid format"); + } + } + + if (config.forgejoBaseUrl && config.forgejoPat) { + const reachability = await checkForgejoReachability(config.forgejoBaseUrl); + results.push(reachability); + + if (reachability.success) { + const apiToken = await checkForgejoApi( + config.forgejoBaseUrl, + config.forgejoPat, + ); + results.push(apiToken); + } + } + + const s = p.spinner(); + + try { + s.start("Running diagnostics"); + + s.stop("Diagnostics complete"); + + const lines = results.map((r) => { + const icon = r.success ? c.green("✓") : c.red("✗"); + const msg = r.message ? ` ${r.message}` : ""; + return `${icon} ${r.name}${msg}`; + }); + + p.note(lines.join("\n"), c.yellow("Results")); + + const failures = results.filter((r) => !r.success); + + if (failures.length > 0) { + p.outro(c.red(`${failures.length} issue(s) found`)); + process.exitCode = 1; + return; + } + + p.outro(c.green("All checks passed")); + } catch (error) { + s.stop(); + const message = error instanceof Error ? error.message : "Unknown error"; + p.cancel(`${c.red("Error:")} ${message}`); + process.exitCode = 1; + } +} diff --git a/packages/cli/src/commands/verify.ts b/packages/cli/src/commands/verify.ts new file mode 100644 index 0000000..1362b98 --- /dev/null +++ b/packages/cli/src/commands/verify.ts @@ -0,0 +1,260 @@ +import fs from "node:fs"; +import path from "node:path"; + +import * as c from "yoctocolors"; +import * as p from "@clack/prompts"; + +interface MystConfig { + forgejoBaseUrl?: string; + forgejoBotUsername?: string; + forgejoPat?: string; +} + +function parseEnvFile(envPath: string): MystConfig { + const config: MystConfig = {}; + + const content = fs.readFileSync(envPath, "utf-8"); + const lines = content.split("\n"); + + for (const line of lines) { + const trimmed = line.trim(); + if (!trimmed || trimmed.startsWith("#")) continue; + + const [key, ...valueParts] = trimmed.split("="); + if (!key) continue; + + const value = valueParts.join("=").trim(); + + switch (key) { + case "FORGEJO_BASE_URL": + config.forgejoBaseUrl = value; + break; + case "FORGEJO_BOT_USERNAME": + config.forgejoBotUsername = value; + break; + case "FORGEJO_PAT": + config.forgejoPat = value; + break; + } + } + + return config; +} + +type CheckResult = { + name: string; + success: boolean; + message?: string; +}; + +async function checkForgejoReachability(baseUrl: string): Promise { + try { + const response = await fetch(baseUrl, { method: "GET" }); + if (response.ok || response.status === 200) { + return { name: "Forgejo reachability", success: true }; + } + return { + name: "Forgejo reachability", + success: false, + message: `HTTP ${response.status}`, + }; + } catch (error) { + const message = error instanceof Error ? error.message : "Unknown error"; + return { + name: "Forgejo reachability", + success: false, + message, + }; + } +} + +async function checkForgejoApi( + baseUrl: string, + pat: string, +): Promise { + try { + const response = await fetch(`${baseUrl}/api/v1/user`, { + method: "GET", + headers: { + Authorization: `Bearer ${pat}`, + }, + }); + + if (response.status === 401) { + return { + name: "Forgejo API token", + success: false, + message: "Invalid or expired token", + }; + } + + if (!response.ok) { + return { + name: "Forgejo API token", + success: false, + message: `HTTP ${response.status}`, + }; + } + + const user = (await response.json()) as { login: string }; + return { + name: "Forgejo API token", + success: true, + message: `Authenticated as ${c.green(user.login)}`, + }; + } catch (error) { + const message = error instanceof Error ? error.message : "Unknown error"; + return { + name: "Forgejo API token", + success: false, + message, + }; + } +} + +async function checkRepoAccess( + baseUrl: string, + pat: string, + username: string, +): Promise { + try { + const response = await fetch( + `${baseUrl}/api/v1/users/${username}/repos?limit=1`, + { + method: "GET", + headers: { + Authorization: `Bearer ${pat}`, + }, + }, + ); + + if (!response.ok) { + return { + name: "Repository access", + success: false, + message: `HTTP ${response.status}`, + }; + } + + const repos = (await response.json()) as Array<{ name: string }>; + if (repos.length > 0) { + const firstRepo = repos[0]!; + return { + name: "Repository access", + success: true, + message: `Can access repos (sample: ${c.green(firstRepo.name)})`, + }; + } + + return { + name: "Repository access", + success: true, + message: "Token valid but no repos found", + }; + } catch (error) { + const message = error instanceof Error ? error.message : "Unknown error"; + return { + name: "Repository access", + success: false, + message, + }; + } +} + +export async function verifyCommand(): Promise { + p.intro(c.bold("myst verify")); + + const envPath = path.join(process.cwd(), ".env"); + + let config: MystConfig; + + try { + config = parseEnvFile(envPath); + } catch (error) { + const err = error as NodeJS.ErrnoException; + if (err.code === "ENOENT") { + p.cancel( + `${c.red("Error:")} .env file not found in ${process.cwd()}`, + ); + process.exitCode = 1; + return; + } + throw error; + } + + const missing: string[] = []; + + if (!config.forgejoBaseUrl) { + missing.push("FORGEJO_BASE_URL"); + } + if (!config.forgejoPat) { + missing.push("FORGEJO_PAT"); + } + if (!config.forgejoBotUsername) { + missing.push("FORGEJO_BOT_USERNAME"); + } + + if (missing.length > 0) { + p.cancel( + `${c.red("Error:")} Missing required config: ${missing.join(", ")}`, + ); + process.exitCode = 1; + return; + } + + const s = p.spinner(); + + try { + s.start("Verifying Forgejo configuration"); + + const reachability = await checkForgejoReachability(config.forgejoBaseUrl!); + + if (!reachability.success) { + s.stop(reachability.message); + p.cancel(`${c.red("✗")} ${reachability.name}: ${reachability.message}`); + process.exitCode = 1; + return; + } + + const apiToken = await checkForgejoApi( + config.forgejoBaseUrl!, + config.forgejoPat!, + ); + + if (!apiToken.success) { + s.stop(apiToken.message); + p.cancel(`${c.red("✗")} ${apiToken.name}: ${apiToken.message}`); + process.exitCode = 1; + return; + } + + const repoAccess = await checkRepoAccess( + config.forgejoBaseUrl!, + config.forgejoPat!, + config.forgejoBotUsername!, + ); + + s.stop("Verification complete"); + + p.note( + [ + `${c.green("✓")} ${reachability.name}`, + `${c.green("✓")} ${apiToken.name}: ${apiToken.message}`, + `${c.green(repoAccess.success ? "✓" : "✗")} ${repoAccess.name}: ${repoAccess.message}`, + ].join("\n"), + c.yellow("Results"), + ); + + if (!repoAccess.success) { + process.exitCode = 1; + return; + } + + p.outro(c.green("Forgejo verification passed")); + } catch (error) { + s.stop(); + const message = error instanceof Error ? error.message : "Unknown error"; + p.cancel(`${c.red("Error:")} ${message}`); + process.exitCode = 1; + } +} diff --git a/packages/cli/src/index.ts b/packages/cli/src/index.ts index e5a5f61..3d40c10 100644 --- a/packages/cli/src/index.ts +++ b/packages/cli/src/index.ts @@ -5,14 +5,20 @@ import * as c from "yoctocolors"; import pkg from "../package.json" with { type: "json" }; import { initCommand } from "./commands/init.js"; +import { configCommand } from "./commands/config.js"; +import { verifyCommand } from "./commands/verify.js"; +import { doctorCommand } from "./commands/doctor.js"; import { getHelpText } from "./help.js"; -type CommandName = "init"; +type CommandName = "init" | "config" | "verify" | "doctor"; type CommandHandler = (args?: string[]) => Promise; const commandHandlers: Record = { init: initCommand, + config: configCommand, + verify: verifyCommand, + doctor: doctorCommand, }; async function main(): Promise { diff --git a/packages/service/package.json b/packages/service/package.json index 4479140..5d75bc5 100644 --- a/packages/service/package.json +++ b/packages/service/package.json @@ -5,6 +5,7 @@ "type": "module", "scripts": { "build": "tsc -p tsconfig.json", + "start": "node dist/index.js", "check": "tsc -b tsconfig.json", "clean": "rm -rf dist" },