Files

175 lines
5.7 KiB
TypeScript

import { NextResponse } from "next/server"
import { Client } from "ssh2"
import { buildControllerNodePlan, type ControllerPlanRequest } from "@/app/lib/controllerNodePlan"
import { upsertControllerNode } from "@/app/lib/controllerNodeRegistry"
export const runtime = "nodejs"
type DeployRequest = ControllerPlanRequest & {
remoteHost?: unknown
remotePort?: unknown
remoteUser?: unknown
remotePassword?: unknown
allowSudo?: unknown
acceptUnknownHostKey?: unknown
expectedHostKeySha256?: unknown
}
const SAFE_REMOTE_USER = /^[a-z_][a-z0-9_-]{0,31}$/i
const MAX_OUTPUT_BYTES = 160_000
function text(value: unknown, fallback = "") {
return typeof value === "string" ? value.trim() : fallback
}
function port(value: unknown) {
const parsed = Number.parseInt(String(value ?? "22"), 10)
return Number.isFinite(parsed) && parsed > 0 && parsed <= 65535 ? parsed : 22
}
function appendBounded(current: string, chunk: Buffer | string) {
const next = current + String(chunk)
return next.length > MAX_OUTPUT_BYTES ? next.slice(next.length - MAX_OUTPUT_BYTES) : next
}
function normalizeFingerprint(value: string) {
return value.trim().replace(/^SHA256:/i, "")
}
function runRemoteDeploy(params: {
host: string
port: number
username: string
password: string
script: string
allowSudo: boolean
acceptUnknownHostKey: boolean
expectedHostKeySha256: string
}) {
return new Promise<{ stdout: string; stderr: string; hostKeySha256: string | null }>((resolve, reject) => {
const conn = new Client()
let stdout = ""
let stderr = ""
let hostKeySha256: string | null = null
let settled = false
const finish = (error?: Error) => {
if (settled) return
settled = true
conn.end()
if (error) reject(error)
else resolve({ stdout: stdout.trim(), stderr: stderr.trim(), hostKeySha256 })
}
const timer = setTimeout(() => {
finish(new Error("Remote deploy timed out after 10 minutes"))
}, 10 * 60 * 1000)
conn
.on("ready", () => {
const command = params.allowSudo ? "sudo -S -p '' bash -s" : "bash -s"
conn.exec(command, { pty: params.allowSudo }, (error, stream) => {
if (error) {
clearTimeout(timer)
finish(error)
return
}
stream
.on("close", (code: number | null, signal: string | null) => {
clearTimeout(timer)
if (code === 0) {
finish()
} else {
finish(new Error(`Remote deploy failed with exit code ${code ?? "unknown"}${signal ? ` signal ${signal}` : ""}`))
}
})
.on("data", (chunk: Buffer) => {
stdout = appendBounded(stdout, chunk)
})
stream.stderr.on("data", (chunk: Buffer) => {
stderr = appendBounded(stderr, chunk)
})
if (params.allowSudo) stream.write(`${params.password}\n`)
stream.end(`${params.script}\n`)
})
})
.on("error", (error) => {
clearTimeout(timer)
finish(error)
})
.connect({
host: params.host,
port: params.port,
username: params.username,
password: params.password,
readyTimeout: 30000,
hostHash: "sha256",
hostVerifier: (hashedKey: string) => {
hostKeySha256 = hashedKey
const expected = normalizeFingerprint(params.expectedHostKeySha256)
if (expected) return hashedKey === expected
return params.acceptUnknownHostKey
},
})
})
}
export async function POST(request: Request) {
try {
const body = (await request.json().catch(() => ({}))) as DeployRequest
const remoteHost = text(body.remoteHost, text(body.controllerHost))
const remoteUser = text(body.remoteUser)
const remotePassword = typeof body.remotePassword === "string" ? body.remotePassword : ""
const expectedHostKeySha256 = text(body.expectedHostKeySha256)
const acceptUnknownHostKey = Boolean(body.acceptUnknownHostKey)
const allowSudo = Boolean(body.allowSudo)
if (!remoteHost) throw new Error("remoteHost is required")
if (!remoteUser || !SAFE_REMOTE_USER.test(remoteUser)) throw new Error("remoteUser must be a valid Linux username")
if (!remotePassword) throw new Error("remotePassword is required for autodeploy")
if (!expectedHostKeySha256 && !acceptUnknownHostKey) {
throw new Error("Provide expectedHostKeySha256 or explicitly allow trust-on-first-deploy.")
}
const plan = buildControllerNodePlan({
...body,
controllerHost: text(body.controllerHost, remoteHost),
})
const deployed = await runRemoteDeploy({
host: remoteHost,
port: port(body.remotePort),
username: remoteUser,
password: remotePassword,
script: plan.commands.localBootstrap,
allowSudo,
acceptUnknownHostKey,
expectedHostKeySha256,
})
await upsertControllerNode({
id: plan.controller.name,
name: plan.controller.name,
host: plan.controller.host,
url: plan.controller.url,
role: "controller-node",
})
return NextResponse.json({
ok: true,
...plan,
controller: plan.controller,
hostKeySha256: deployed.hostKeySha256,
stdout: deployed.stdout,
stderr: deployed.stderr,
note: allowSudo
? "Autodeploy completed using sudo. The controller service was installed when systemd was available."
: "Autodeploy completed without sudo. Start the controller manually if systemd service installation was skipped.",
})
} catch (error) {
const message = error instanceof Error ? error.message : "Failed to autodeploy controller node"
return NextResponse.json({ ok: false, error: message }, { status: 400 })
}
}