Files
canina/backend/src/orchestration-worker/worker-transport.module.ts
T

344 lines
13 KiB
TypeScript

import {
BadRequestException,
Body,
CanActivate,
ConflictException,
Controller,
DynamicModule,
ForbiddenException,
Get,
Inject,
Injectable,
Module,
NotFoundException,
Param,
Post,
Req,
UnauthorizedException,
UseGuards,
UsePipes,
ValidationPipe,
} from "@nestjs/common";
import { IsString, IsUUID, Matches, MaxLength } from "class-validator";
import { createHash, timingSafeEqual } from "crypto";
import { mkdir, open, FileHandle } from "fs/promises";
import { constants } from "fs";
import { isAbsolute } from "path";
import { PrismaModule } from "../prisma/prisma.module";
import { PrismaService } from "../prisma/prisma.service";
import {
PREPARE_WORKFLOW_CONFIG,
PrepareWorkflowService,
WorkflowIdentity,
} from "../orchestration/prepare-workflow.service";
// This is reviewed static configuration, not a URL fetched by the transport.
function validArtifactBase(value: string): boolean {
try {
const u = new URL(value);
// DNS name only: reject all IP literals, localhost/private single-label names,
// noncanonical paths/escapes, credentials, query, fragment and alternate ports.
return u.protocol === "https:" && !u.username && !u.password && !u.port &&
/^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/.test(u.hostname) &&
u.hostname.includes(".") && !/^[0-9.]+$/.test(u.hostname) &&
!/(^|\.)(localhost|local|internal|lan|home)$/.test(u.hostname) &&
u.pathname === "/internal/prepare-worker/artifacts" &&
value === u.origin + u.pathname;
} catch { return false; }
}
const CONFIG = Symbol("WORKER_TRANSPORT_CONFIG");
export interface WorkerTransportConfig {
enabled: boolean;
grants: {
id: string;
role: "WORKFLOW_WORKER" | "STAGE_CI";
credentialSha256: string;
}[];
workerIds: string[];
stageCiIds: string[];
artifactDirectory: string;
artifactBaseUrl: string;
}
class ClaimDto {
@IsUUID() taskId!: string;
}
class LeaseDto extends ClaimDto {
@IsUUID() runId!: string;
@IsUUID() leaseToken!: string;
}
class CompleteDto extends LeaseDto {
@IsString() @MaxLength(2048) report!: string;
}
class StageEvidenceDto extends ClaimDto {
@IsUUID() runId!: string;
@Matches(/^[a-f0-9]{40}$/) commitSha!: string;
@Matches(/^[a-f0-9]{64}$/) sha256!: string;
@Matches(/^[a-f0-9]{64}$/) evidenceSha256!: string;
@Matches(/^https:\/\/[^\s]+$/) @MaxLength(2000) uri!: string;
}
export function tracerReport(lease: {
taskId: string;
runId: string;
commitSha: string;
}) {
return JSON.stringify({
kind: "DETERMINISTIC_PREPARE_TRACER",
schemaVersion: 1,
taskId: lease.taskId,
runId: lease.runId,
commitSha: lease.commitSha,
environment: "staging",
llmPilot: false,
browserExecuted: false,
shellExecuted: false,
deploymentExecuted: false,
checks: ["lease-bound identity", "deterministic JSON serialization"],
actualCents: 0,
});
}
@Injectable()
class WorkerIdentityGuard implements CanActivate {
constructor(@Inject(CONFIG) private readonly config: WorkerTransportConfig) {}
canActivate(context: any) {
if (!this.config.enabled)
throw new ForbiddenException("Worker transport disabled");
const req = context.switchToHttp().getRequest();
const auth = req.headers.authorization;
if (typeof auth !== "string" || !/^Bearer [\x21-\x7e]{32,512}$/.test(auth))
throw new UnauthorizedException();
const digest = createHash("sha256").update(auth.slice(7)).digest();
const grant = this.config.grants.find((g) =>
timingSafeEqual(Buffer.from(g.credentialSha256, "hex"), digest),
);
if (!grant) throw new UnauthorizedException();
req.workerIdentity = { id: grant.id, role: grant.role };
return true;
}
}
@Injectable()
class WorkerTransportService {
constructor(
private readonly workflow: PrepareWorkflowService,
private readonly db: PrismaService,
@Inject(CONFIG) private readonly config: WorkerTransportConfig,
) {}
// Linux descriptor-relative traversal pins each directory across renames. Never
// realpath-check then reopen by name: that reintroduces a symlink race.
private async artifactDir(): Promise<FileHandle> {
let dir = await open("/", constants.O_RDONLY | constants.O_DIRECTORY);
try {
for (const part of this.config.artifactDirectory.split("/").filter(Boolean)) {
const path = `/proc/self/fd/${dir.fd}/${part}`;
try { await mkdir(path, { mode: 0o700 }); }
catch (e: any) { if (e.code !== "EEXIST") throw e; }
const next = await open(path, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
await dir.close();
dir = next;
}
const stat = await dir.stat();
if (stat.uid !== process.getuid!() || (stat.mode & 0o077) !== 0)
throw new Error("Private owned artifact directory required");
return dir;
} catch (e) { await dir.close(); throw e; }
}
private worker(a: WorkflowIdentity) {
if (a.role !== "WORKFLOW_WORKER" || !this.config.workerIds.includes(a.id))
throw new ForbiddenException("Worker allowlist required");
}
async claim(a: WorkflowIdentity, dto: ClaimDto) {
this.worker(a);
const t = await this.db.orchestrationTask.findUnique({
where: { id: dto.taskId },
});
// Explicit per-task pilot scope; never opportunistically consume arbitrary queued work.
if (!t || !["READY", "RUNNING"].includes(t.state)) return { lease: null };
if (t.budgetLimitCents !== 20)
throw new ForbiddenException("Pilot hard task cap is 20 cents");
return { lease: await this.workflow.claim(a, dto.taskId) };
}
heartbeat(a: WorkflowIdentity, dto: LeaseDto) {
this.worker(a);
return this.workflow.heartbeat(a, dto);
}
async complete(a: WorkflowIdentity, dto: CompleteDto) {
this.worker(a);
// Recheck stop/interrupt and fencing before artifact creation; core rechecks atomically at commit.
await this.workflow.heartbeat(a, dto);
const run = await this.db.orchestrationRun.findUniqueOrThrow({
where: { id: dto.runId },
});
const expected = tracerReport({ ...dto, commitSha: run.commitSha });
if (dto.report !== expected)
throw new BadRequestException(
"Only deterministic harmless tracer report accepted",
);
const sha256 = createHash("sha256").update(expected).digest("hex");
let dir: FileHandle | undefined, file: FileHandle | undefined;
try {
dir = await this.artifactDir();
file = await open(`/proc/self/fd/${dir.fd}/${sha256}.json`,
constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
await file.writeFile(expected, "utf8");
await file.sync();
} catch { throw new ConflictException("Artifact creation refused"); }
finally { await file?.close(); await dir?.close(); }
const result = await this.workflow.complete(a, {
...dto,
sha256,
uri: this.config.artifactBaseUrl + "/" + sha256,
actualCents: 0,
});
return {
state: result.state,
taskId: result.id,
runId: dto.runId,
sha256,
actualCents: 0,
};
}
async artifact(a: WorkflowIdentity, hash: string) {
if (!/^[a-f0-9]{64}$/.test(hash))
throw new BadRequestException("Invalid artifact hash");
const registered = await this.db.orchestrationArtifact.findFirst({
where: {
sha256: hash, kind: "QA", uri: this.config.artifactBaseUrl + "/" + hash,
run: { environment: "staging", status: "SUCCEEDED", task: {
operationMode: "PREPARE", budgetLimitCents: 20,
} },
},
});
if (!registered) throw new NotFoundException("Artifact not registered");
const run = await this.db.orchestrationRun.findUniqueOrThrow({ where: { id: registered.runId } });
const task = await this.db.orchestrationTask.findUniqueOrThrow({ where: { id: run.taskId } });
const outbox = await this.db.prepareWorkflowOutbox.findUnique({ where: { taskId: run.taskId } });
if (!outbox || outbox.status !== "DONE" || outbox.runId !== run.id ||
(a.role === "WORKFLOW_WORKER" && outbox.leaseOwner !== a.id))
throw new NotFoundException("Artifact not registered");
const metadata = task.metadata as any;
if (metadata?.workflowScope !== "STAGE_PREPARE" || metadata?.commitSha !== run.commitSha)
throw new NotFoundException("Artifact not registered");
let bytes: string;
let dir: FileHandle | undefined, file: FileHandle | undefined;
try {
dir = await this.artifactDir();
file = await open(`/proc/self/fd/${dir.fd}/${hash}.json`,
constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
const stat = await file.stat();
if (!stat.isFile() || stat.nlink !== 1 || stat.uid !== process.getuid!() ||
(stat.mode & 0o077) !== 0 || stat.size > 2048)
throw new Error("Unsafe artifact file");
// Fixed-size descriptor read: concurrent growth cannot allocate unbounded memory.
const buffer = Buffer.alloc(2049);
const { bytesRead } = await file.read(buffer, 0, buffer.length, 0);
if (bytesRead > 2048) throw new Error("Oversized artifact");
bytes = buffer.subarray(0, bytesRead).toString("utf8");
} catch {
throw new NotFoundException("Artifact unavailable");
} finally { await file?.close(); await dir?.close(); }
if (createHash("sha256").update(bytes).digest("hex") !== hash)
throw new ConflictException("Artifact integrity mismatch");
if (bytes !== tracerReport({ taskId: run.taskId, runId: run.id, commitSha: run.commitSha }))
throw new ConflictException("Artifact binding mismatch");
return JSON.parse(bytes);
}
stage(a: WorkflowIdentity, dto: StageEvidenceDto) {
return this.workflow.stageEvidence(a, dto);
}
}
@Controller("internal/prepare-worker")
@UseGuards(WorkerIdentityGuard)
@UsePipes(
new ValidationPipe({
whitelist: true,
forbidNonWhitelisted: true,
transform: true,
}),
)
class WorkerTransportController {
constructor(private readonly service: WorkerTransportService) {}
@Post("claim") claim(@Req() req: any, @Body() dto: ClaimDto) {
return this.service.claim(req.workerIdentity, dto);
}
@Post("heartbeat") heartbeat(@Req() req: any, @Body() dto: LeaseDto) {
return this.service.heartbeat(req.workerIdentity, dto);
}
@Post("complete") complete(@Req() req: any, @Body() dto: CompleteDto) {
return this.service.complete(req.workerIdentity, dto);
}
@Post("stage-evidence") stage(
@Req() req: any,
@Body() dto: StageEvidenceDto,
) {
return this.service.stage(req.workerIdentity, dto);
}
@Get("artifacts/:hash") artifact(@Req() req: any, @Param("hash") hash: string) {
return this.service.artifact(req.workerIdentity, hash);
}
}
@Module({})
export class WorkerTransportModule {
static register(config: WorkerTransportConfig): DynamicModule {
if (typeof config.enabled !== "boolean" || !Array.isArray(config.grants) ||
!Array.isArray(config.workerIds) || !Array.isArray(config.stageCiIds))
throw new Error("Explicit boolean enable and credential allowlists required");
const allIds = [...config.workerIds, ...config.stageCiIds];
if (allIds.some(id => typeof id !== "string" || !/^[a-zA-Z0-9_-]{1,100}$/.test(id)) ||
new Set(allIds).size !== allIds.length)
throw new Error("Invalid or overlapping worker/CI allowlists");
const ids = new Set<string>(),
digests = new Set<string>();
if (
!isAbsolute(config.artifactDirectory) || config.artifactDirectory === "/" ||
config.artifactDirectory.split("/").some(p => p === "." || p === "..") ||
!validArtifactBase(config.artifactBaseUrl)
)
throw new Error(
"Absolute artifact directory and fixed HTTPS artifact base required",
);
for (const g of config.grants) {
const allowed =
g.role === "WORKFLOW_WORKER"
? config.workerIds
: g.role === "STAGE_CI"
? config.stageCiIds
: [];
if (
!/^[a-zA-Z0-9_-]{1,100}$/.test(g.id) ||
!allowed.includes(g.id) ||
!/^[a-f0-9]{64}$/.test(g.credentialSha256) ||
ids.has(g.id) ||
digests.has(g.credentialSha256) ||
(config.workerIds.includes(g.id) && config.stageCiIds.includes(g.id))
)
throw new Error("Invalid or overlapping worker/CI credential grants");
ids.add(g.id);
digests.add(g.credentialSha256);
}
const snapshot = JSON.parse(JSON.stringify(config)) as WorkerTransportConfig;
snapshot.grants.forEach(Object.freeze);
Object.freeze(snapshot.grants);
Object.freeze(snapshot.workerIds);
Object.freeze(snapshot.stageCiIds);
Object.freeze(snapshot);
return {
module: WorkerTransportModule,
imports: [PrismaModule],
controllers: [WorkerTransportController],
providers: [
PrepareWorkflowService,
WorkerIdentityGuard,
WorkerTransportService,
{ provide: CONFIG, useValue: snapshot },
{
provide: PREPARE_WORKFLOW_CONFIG,
useValue: Object.freeze({
workerIds: snapshot.workerIds,
stageCiIds: snapshot.stageCiIds,
}),
},
],
exports: [PrepareWorkflowService],
};
}
}