pastilhasandClaude Opus 5
d7b775113b
both sidecars read their upstream from a new service_connections table instead of process.env: one row per (user, service), the secret encrypted at rest, upserted through a /_config route the app drives. transmission gains a Connection section, soulseek gains one too, and both take over the whole app while nothing is stored. TRANSMISSION_URL/USER/PASS/RPC_PATH and SLSKD_URL/API_KEY can come out of .env. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
92 lines
4.4 KiB
TypeScript
92 lines
4.4 KiB
TypeScript
import { deleteServiceConnection, getServiceConnection, saveServiceConnection } from 'officerdb';
|
|
import { probe } from './rpc';
|
|
import {
|
|
basicAuth,
|
|
getTransmissionConfig,
|
|
invalidateTransmissionConfig,
|
|
normalizeBase,
|
|
normalizeRpcPath,
|
|
} from './upstream';
|
|
|
|
// `/_config` — where the Transmission daemon is, driven from the app rather than from a shell on the server.
|
|
//
|
|
// ONE connection, not a registry: nobody runs two Transmission daemons. So there is no label, no id in the
|
|
// path and no activate route — a save is an upsert over the single row, and the UI is one form.
|
|
//
|
|
// The URL is the only thing usually needed. Most Transmission daemons run with no RPC auth at all, so
|
|
// username/password are optional and an EMPTY username means "no auth" rather than "empty credentials" —
|
|
// see basicAuth in upstream.ts, where sending a Basic header anyway makes the daemon reject the request.
|
|
// `rpcPath` is there for the reverse-proxy case and defaults to /transmission/rpc.
|
|
//
|
|
// The password is WRITE-ONLY across this boundary: the GET reports whether one is stored, never its value.
|
|
// A save is validated with a live session-get first, so a wrong URL or rejected credentials is a 400 with
|
|
// the reason rather than a stored row that makes every later screen fail mysteriously.
|
|
|
|
/** What the browser is allowed to know about the connection. Never includes the password. */
|
|
async function connectionState(userId: number): Promise<Response> {
|
|
const connection = await getServiceConnection(userId, 'transmission');
|
|
return Response.json({ configured: !!connection, connection });
|
|
}
|
|
|
|
const bad = (error: string, status = 400) => Response.json({ error }, { status });
|
|
|
|
type ConnectionBody = { url?: unknown; username?: unknown; password?: unknown; rpcPath?: unknown };
|
|
|
|
const isHttpUrl = (url: string): boolean => /^https?:\/\//i.test(url);
|
|
|
|
const readString = (value: unknown): string => (typeof value === 'string' ? value.trim() : '');
|
|
|
|
/** Save the connection: validated against the live daemon, then stored. */
|
|
async function save(req: Request, userId: number): Promise<Response> {
|
|
const body = ((await req.json().catch(() => null)) as ConnectionBody | null) ?? {};
|
|
const url = typeof body.url === 'string' ? normalizeBase(body.url) : '';
|
|
const username = readString(body.username);
|
|
const rpcPath = normalizeRpcPath(readString(body.rpcPath));
|
|
// A blank password with a username still set means "keep the stored one", so changing the URL does not
|
|
// need the password re-typed. Clearing the username clears the auth entirely.
|
|
const password = typeof body.password === 'string' && body.password ? body.password : null;
|
|
|
|
if (!url) return bad('url is required');
|
|
if (!isHttpUrl(url)) return bad('url must start with http:// or https://');
|
|
|
|
const current = await getServiceConnection(userId, 'transmission');
|
|
const keepPassword = !password && !!username && username === current?.username && current.hasSecret;
|
|
|
|
// Probing needs the real password, so a save that keeps the stored one borrows it through the normal read
|
|
// path rather than reaching for the ciphertext here.
|
|
const stored = keepPassword ? await getTransmissionConfig(userId) : null;
|
|
const auth = keepPassword ? (stored?.auth ?? null) : basicAuth(username || null, password);
|
|
|
|
const result = await probe({ base: url, rpcPath, auth });
|
|
if (!result.ok) return bad(result.error ?? 'could not reach the daemon');
|
|
|
|
const connection = await saveServiceConnection({
|
|
userId,
|
|
service: 'transmission',
|
|
url,
|
|
username: username || null,
|
|
// undefined keeps the stored password; null clears it, which is what dropping the username means.
|
|
secret: keepPassword ? undefined : (password ?? null),
|
|
path: rpcPath,
|
|
version: result.version ?? null,
|
|
});
|
|
invalidateTransmissionConfig(userId);
|
|
return Response.json({ connection, rpcVersion: result.rpcVersion ?? null });
|
|
}
|
|
|
|
/** `/_config` — GET the connection, PUT/POST to save it, DELETE to forget it. */
|
|
export async function handleConfigRoute(req: Request, userId: number, subpath: string): Promise<Response> {
|
|
if (subpath && subpath !== '/') return bad('not found', 404);
|
|
|
|
if (req.method === 'GET') return connectionState(userId);
|
|
if (req.method === 'POST' || req.method === 'PUT') return save(req, userId);
|
|
|
|
if (req.method === 'DELETE') {
|
|
await deleteServiceConnection(userId, 'transmission');
|
|
invalidateTransmissionConfig(userId);
|
|
return connectionState(userId);
|
|
}
|
|
|
|
return bad('method not allowed', 405);
|
|
}
|