The available-models checklist has a "get models" button. The control plane asks the gateway's /v1/models with its own key and returns names only, to owners and admins. Co-Authored-By: Claude Haiku 4.5 (1M context) <noreply@anthropic.com>
934 lines
38 KiB
TypeScript
934 lines
38 KiB
TypeScript
import {
|
|
Body,
|
|
Controller,
|
|
Delete,
|
|
Get,
|
|
HttpCode,
|
|
Inject,
|
|
Param,
|
|
Patch,
|
|
Post,
|
|
Query,
|
|
Req,
|
|
Res,
|
|
type ExceptionFilter,
|
|
Catch,
|
|
HttpException,
|
|
type ArgumentsHost,
|
|
} from '@nestjs/common';
|
|
import type { Request, Response } from 'express';
|
|
import { z, ZodError } from 'zod';
|
|
import {
|
|
DomainError,
|
|
codeReviewPolicyInput,
|
|
orderProjectModels,
|
|
projectModelsInput,
|
|
commandList,
|
|
gitBranchName,
|
|
wishRulesInput,
|
|
type Actor,
|
|
type Run,
|
|
isProduction,
|
|
type Workspace,
|
|
} from '@wishforge/contracts';
|
|
import { Authenticator, localUser } from './auth.js';
|
|
import { ControlPlane, must, projectAccess, record, touch } from './domain/control-plane.js';
|
|
import { Releases } from './domain/releases.js';
|
|
import { AgentBundles } from './domain/agent-bundles.js';
|
|
import { Lessons } from './domain/lessons.js';
|
|
import { Skills } from './domain/skills.js';
|
|
import { WishReports } from './domain/wish-report.js';
|
|
import { Connections } from './domain/connections.js';
|
|
import { RunnerBroker } from './domain/runner-broker.js';
|
|
import { GitStorage } from './domain/git-storage.js';
|
|
import { WorkspaceGit, commitAuthor } from './domain/workspace-git.js';
|
|
import { GitHubIntegration } from './domain/github.js';
|
|
import { Usage } from './domain/usage.js';
|
|
import { ProviderProxy } from './domain/provider-proxy.js';
|
|
import { Entitlements, requireCapacity } from './domain/entitlements.js';
|
|
import { requireRole, requireHuman } from './domain/policy.js';
|
|
import { configuredVerificationProfiles, selectVerificationProfile } from './domain/verification-policy.js';
|
|
import { LocalAccounts, localAccountsEnabled } from './domain/local-accounts.js';
|
|
import { permissionsOf } from './domain/permissions.js';
|
|
import { WishRefiner } from './domain/wish-refiner.js';
|
|
import { ModelCatalog } from './domain/model-catalog.js';
|
|
import { notificationsConfigured } from './domain/notifications.js';
|
|
|
|
export class Services {
|
|
auth: Authenticator;
|
|
releases: Releases;
|
|
bundles: AgentBundles;
|
|
lessons: Lessons;
|
|
skills: Skills;
|
|
reports: WishReports;
|
|
connections: Connections;
|
|
runners: RunnerBroker;
|
|
github: GitHubIntegration;
|
|
accounts: LocalAccounts;
|
|
refiner: WishRefiner;
|
|
modelCatalog: ModelCatalog;
|
|
constructor(readonly control: ControlPlane) {
|
|
this.auth = new Authenticator(control.store, control.env);
|
|
this.releases = new Releases(control.store, control.env);
|
|
this.bundles = new AgentBundles(control.store);
|
|
this.lessons = new Lessons(control.store);
|
|
this.skills = new Skills(control.store, control.env);
|
|
this.reports = new WishReports(control.store);
|
|
this.connections = new Connections(control.store, control.env);
|
|
this.runners = new RunnerBroker(control.store, this.releases, control.env);
|
|
this.github = new GitHubIntegration(control.store, control.env);
|
|
this.accounts = new LocalAccounts(control.store, control.env);
|
|
this.refiner = new WishRefiner(control.store, control.env);
|
|
this.modelCatalog = new ModelCatalog(control.env);
|
|
}
|
|
}
|
|
type AuthRequest = Request & { actor: Actor };
|
|
const ok = <T>(data: T) => ({ data });
|
|
const key = (req: Request) => req.header('Idempotency-Key');
|
|
const leaseToken = z.number().int().positive();
|
|
const commitSha = z.string().regex(/^[0-9a-f]{40,64}$/);
|
|
const leaseBody = z.object({ leaseToken }).strict();
|
|
const fencedBody = z.object({ leaseToken, fence: z.number().int().positive() }).strict();
|
|
const leaseRequest = z
|
|
.object({ workerId: z.string().min(1).max(200), generation: z.string().max(200).optional() })
|
|
.strict();
|
|
const checkpointBody = z
|
|
.object({
|
|
leaseToken,
|
|
workspace: z.string().max(4096).optional(),
|
|
checkpoint: z
|
|
.object({
|
|
schemaVersion: z.literal(1),
|
|
runId: z.string().min(1).max(200),
|
|
provider: z.string().min(1).max(40),
|
|
sourceCommit: commitSha,
|
|
baseCommit: commitSha,
|
|
patch: z.string().max(4 * 1024 * 1024),
|
|
patchSha256: z.string().regex(/^[a-f0-9]{64}$/),
|
|
gitBundleBase64: z.string().optional(),
|
|
gitBundleSha256: z
|
|
.string()
|
|
.regex(/^[a-f0-9]{64}$/)
|
|
.optional(),
|
|
createdAt: z.string().max(64),
|
|
sessionId: z.string().max(200).optional(),
|
|
providerCompletion: z
|
|
.object({
|
|
status: z.enum(['completed', 'failed', 'canceled']),
|
|
revision: z.number().int().positive(),
|
|
repairCount: z.number().int().nonnegative(),
|
|
summary: z.string().max(4000).optional(),
|
|
finalUsage: z
|
|
.array(
|
|
z
|
|
.object({
|
|
operationId: z.string().min(1).max(300),
|
|
tokens: z.number().int().nonnegative().safe(),
|
|
})
|
|
.strict(),
|
|
)
|
|
.max(100),
|
|
})
|
|
.strict()
|
|
.optional(),
|
|
})
|
|
.strict(),
|
|
})
|
|
.strict();
|
|
const classificationBody = z
|
|
.object({
|
|
leaseToken,
|
|
sourceCommit: commitSha,
|
|
changedPaths: z.array(z.string().min(1).max(4096)).max(10000),
|
|
migration: z.boolean(),
|
|
permissionsExpanded: z.boolean(),
|
|
partial: z.boolean().optional(),
|
|
})
|
|
.strict();
|
|
const meterBody = z
|
|
.object({
|
|
leaseToken,
|
|
operationId: z.string().min(1).max(300),
|
|
tokens: z.number().int().min(0),
|
|
computeSeconds: z.number().min(0),
|
|
})
|
|
.strict();
|
|
/** The first check of an IDE session carries the user's token; later checks name the established user. */
|
|
const authorizeBody = z
|
|
.object({
|
|
userToken: z.string().min(1).max(16384).optional(),
|
|
userId: z.string().min(1).max(200).optional(),
|
|
operation: z.enum(['edit', 'terminal', 'debug']),
|
|
})
|
|
.strict()
|
|
.refine(body => Boolean(body.userToken) !== Boolean(body.userId), 'Provide either userToken or userId');
|
|
const gatewayUserBody = z.object({ userId: z.string().min(1).max(200) }).strict();
|
|
|
|
@Catch()
|
|
export class Errors implements ExceptionFilter {
|
|
catch(error: unknown, host: ArgumentsHost) {
|
|
const res = host.switchToHttp().getResponse<Response>();
|
|
if (res.headersSent) return res.end();
|
|
if (error instanceof ZodError)
|
|
return res
|
|
.status(400)
|
|
.json({ error: { code: 'INVALID_INPUT', message: 'Request validation failed', details: error.flatten() } });
|
|
if (error instanceof DomainError)
|
|
return res
|
|
.status(error.status)
|
|
.json({ error: { code: error.code, message: error.message, details: error.details } });
|
|
// Framework errors (unknown route, wrong method) keep their status with the same envelope.
|
|
if (error instanceof HttpException) {
|
|
const status = error.getStatus();
|
|
const code = status === 404 ? 'NOT_FOUND' : status === 405 ? 'METHOD_NOT_ALLOWED' : `HTTP_${status}`;
|
|
return res.status(status).json({ error: { code, message: status === 404 ? 'Route not found' : error.message } });
|
|
}
|
|
console.error(error instanceof Error ? `${error.name}: ${error.message}` : 'Internal request failure');
|
|
return res
|
|
.status(500)
|
|
.json({ error: { code: 'INTERNAL_ERROR', message: 'Request failed. Consult the server audit log.' } });
|
|
}
|
|
}
|
|
|
|
@Controller('v1')
|
|
export class ApiController {
|
|
constructor(@Inject(Services) private s: Services) {}
|
|
@Get('identity') identity(@Req() req: AuthRequest) {
|
|
const { userId, role, kind, displayName } = req.actor;
|
|
return ok({
|
|
userId,
|
|
role,
|
|
kind,
|
|
...(displayName ? { displayName } : {}),
|
|
permissions: permissionsOf(req.actor),
|
|
// Permissions of one's own account apply as they are; a role's can be raised by a project.
|
|
permissionSource: req.actor.permissions ? 'account' : 'role',
|
|
});
|
|
}
|
|
/** What this deployment offers, so the console shows only what works here. */
|
|
@Get('capabilities') capabilities(@Req() req: AuthRequest) {
|
|
return ok({
|
|
wishRefinement: this.s.refiner.available(req.actor.tenantId),
|
|
modelCatalog: this.s.modelCatalog.available(req.actor.tenantId),
|
|
localAccounts: localAccountsEnabled(this.s.control.env),
|
|
notifications: notificationsConfigured(this.s.control.env),
|
|
});
|
|
}
|
|
/** The models the gateway offers, for choosing a project's models. */
|
|
@Get('models') async models(@Req() req: AuthRequest) {
|
|
return ok(await this.s.modelCatalog.list(req.actor));
|
|
}
|
|
@Get('dashboard') async dashboard(@Req() req: AuthRequest) {
|
|
const a = req.actor;
|
|
const [projects, runs, releases, providers, usage] = await Promise.all([
|
|
this.s.control.projects(a),
|
|
this.s.control.runs(a),
|
|
this.s.releases.list(a),
|
|
this.s.control.providers(a),
|
|
this.s.control.usage(a),
|
|
]);
|
|
return ok({
|
|
projects,
|
|
runs,
|
|
releases,
|
|
providers,
|
|
usage,
|
|
system: {
|
|
mode: isProduction(this.s.control.env) ? 'production' : 'development',
|
|
region: this.s.control.env.WF_REGION ?? 'unconfigured',
|
|
authMode: this.s.control.env.WF_DEV_AUTH_TOKEN ? 'local-development' : 'oidc',
|
|
},
|
|
});
|
|
}
|
|
@Get('projects') async projects(@Req() r: AuthRequest) {
|
|
return ok(await this.s.control.projects(r.actor));
|
|
}
|
|
@Post('projects') async createProject(@Req() r: AuthRequest, @Body() b: unknown) {
|
|
return ok(await this.s.control.createProject(r.actor, b));
|
|
}
|
|
@Get('verification-profiles') async verificationProfiles() {
|
|
return ok(configuredVerificationProfiles(this.s.control.env).map(({ id, version }) => ({ id, version })));
|
|
}
|
|
@Post('projects/:id/verification-profile') async verificationProfile(
|
|
@Req() r: AuthRequest,
|
|
@Param('id') id: string,
|
|
@Body() body: unknown,
|
|
) {
|
|
requireRole(r.actor, ['owner', 'admin']);
|
|
requireHuman(r.actor);
|
|
const { profileId } = z
|
|
.object({ profileId: z.string().min(1).max(80) })
|
|
.strict()
|
|
.parse(body);
|
|
const profile = selectVerificationProfile(profileId, this.s.control.env);
|
|
return ok(
|
|
await this.s.control.store.transaction(r.actor.tenantId, async tx => {
|
|
const project = await projectAccess(tx, r.actor, id);
|
|
const next = { ...touch(project), verificationProfile: profile };
|
|
await tx.put('project', next);
|
|
return next;
|
|
}),
|
|
);
|
|
}
|
|
@Post('projects/:id/repository') async provisionRepository(@Req() r: AuthRequest, @Param('id') id: string) {
|
|
return ok(await this.s.control.provisionRepository(r.actor, id));
|
|
}
|
|
@Get('projects/:id/github') async githubStatus(@Req() r: AuthRequest, @Param('id') id: string) {
|
|
return ok(await this.s.github.status(r.actor, id));
|
|
}
|
|
@Post('runs/:id/github/pull-requests') async githubPr(
|
|
@Req() r: AuthRequest,
|
|
@Param('id') id: string,
|
|
@Body() b: unknown,
|
|
) {
|
|
return ok(await this.s.github.createPullRequest(r.actor, id, b));
|
|
}
|
|
@Get('github/operations/:id') async githubRead(@Req() r: AuthRequest, @Param('id') id: string) {
|
|
return ok(await this.s.github.readPullRequest(r.actor, id));
|
|
}
|
|
@Post('github/operations/:id/authorize-merge') async githubAuthorize(
|
|
@Req() r: AuthRequest,
|
|
@Param('id') id: string,
|
|
@Body() b: { expectedHeadSha: string; expectedBaseSha: string },
|
|
) {
|
|
return ok(await this.s.github.authorizeMerge(r.actor, id, b));
|
|
}
|
|
@Post('github/operations/:id/merge') async githubMerge(@Req() r: AuthRequest, @Param('id') id: string) {
|
|
return ok(await this.s.github.merge(r.actor, id));
|
|
}
|
|
@Get('projects/:id') async project(@Req() r: AuthRequest, @Param('id') id: string) {
|
|
return ok(await this.s.control.store.read(r.actor.tenantId, tx => projectAccess(tx, r.actor, id)));
|
|
}
|
|
@Patch('projects/:id') async settings(@Req() r: AuthRequest, @Param('id') id: string, @Body() b: unknown) {
|
|
requireRole(r.actor, ['owner', 'admin']);
|
|
requireHuman(r.actor);
|
|
const data = z
|
|
.object({
|
|
targetBranch: gitBranchName.optional(),
|
|
verificationCommands: commandList.optional(),
|
|
installCommands: commandList.optional(),
|
|
memberIds: z.array(z.string().min(1)).optional(),
|
|
codeReview: codeReviewPolicyInput.nullable().optional(),
|
|
wishRules: wishRulesInput.optional(),
|
|
models: projectModelsInput.nullable().optional(),
|
|
deliveryConfig: z
|
|
.object({
|
|
imageRepository: z.string().min(1),
|
|
architecture: z.enum(['linux/amd64', 'linux/arm64']),
|
|
environmentId: z.string().min(1),
|
|
dockerfile: z.string().default('Dockerfile'),
|
|
sourceContext: z.string().default('.'),
|
|
containerPort: z.number().int().min(1).max(65535),
|
|
healthPath: z.string().startsWith('/'),
|
|
smokeChecks: z
|
|
.array(
|
|
z.object({
|
|
path: z.string().startsWith('/'),
|
|
expectedStatus: z.number().int().min(100).max(599),
|
|
bodyIncludes: z.string().optional(),
|
|
}),
|
|
)
|
|
.min(1),
|
|
})
|
|
.strict()
|
|
.optional(),
|
|
})
|
|
.strict()
|
|
.parse(b);
|
|
return ok(
|
|
await this.s.control.store.transaction(r.actor.tenantId, async tx => {
|
|
const p = await projectAccess(tx, r.actor, id);
|
|
const { codeReview, models, ...rest } = data;
|
|
const next = { ...touch(p), ...rest };
|
|
// null or none clears the list: wishes run with the executor's default model again.
|
|
if (models !== undefined) next.models = models?.length ? orderProjectModels(models) : undefined;
|
|
// null clears the policy: changes no longer wait for a review, and nobody's permission is kept.
|
|
if (codeReview !== undefined)
|
|
next.codeReview = codeReview?.paths.length || codeReview?.trustedMembers.length ? codeReview : undefined;
|
|
await tx.put('project', next);
|
|
return next;
|
|
}),
|
|
);
|
|
}
|
|
@Get('projects/:id/lessons') async lessons(@Req() r: AuthRequest, @Param('id') id: string) {
|
|
return ok(await this.s.lessons.list(r.actor, id));
|
|
}
|
|
@Post('projects/:id/lessons') async createLesson(@Req() r: AuthRequest, @Param('id') id: string, @Body() b: unknown) {
|
|
return ok(await this.s.lessons.create(r.actor, id, b));
|
|
}
|
|
@Patch('lessons/:id') async updateLesson(@Req() r: AuthRequest, @Param('id') id: string, @Body() b: unknown) {
|
|
return ok(await this.s.lessons.setStatus(r.actor, id, b));
|
|
}
|
|
@Delete('lessons/:id') async deleteLesson(@Req() r: AuthRequest, @Param('id') id: string) {
|
|
return ok(await this.s.lessons.remove(r.actor, id));
|
|
}
|
|
@Get('projects/:id/skills') async skills(@Req() r: AuthRequest, @Param('id') id: string) {
|
|
return ok(await this.s.skills.list(r.actor, id));
|
|
}
|
|
@Post('projects/:id/skills') async createSkill(@Req() r: AuthRequest, @Param('id') id: string, @Body() b: unknown) {
|
|
return ok(await this.s.skills.create(r.actor, id, b));
|
|
}
|
|
/** Every active skill (and with ?proposed=1 the proposals) as a zip, one directory per skill. */
|
|
@Get('projects/:id/skills/export') async exportSkills(
|
|
@Req() r: AuthRequest,
|
|
@Res() res: Response,
|
|
@Param('id') id: string,
|
|
@Query('proposed') proposed?: string,
|
|
) {
|
|
const exported = await this.s.skills.exportAll(r.actor, id, proposed === '1');
|
|
res.type('application/zip').setHeader('Content-Disposition', `attachment; filename="${exported.filename}"`);
|
|
res.send(exported.content);
|
|
}
|
|
@Patch('skills/:id') async updateSkill(@Req() r: AuthRequest, @Param('id') id: string, @Body() b: unknown) {
|
|
return ok(await this.s.skills.update(r.actor, id, b));
|
|
}
|
|
@Delete('skills/:id') async deleteSkill(@Req() r: AuthRequest, @Param('id') id: string) {
|
|
return ok(await this.s.skills.remove(r.actor, id));
|
|
}
|
|
@Get('skills/:id/export') async exportSkill(@Req() r: AuthRequest, @Res() res: Response, @Param('id') id: string) {
|
|
const exported = await this.s.skills.exportOne(r.actor, id);
|
|
res
|
|
.type('text/markdown; charset=utf-8')
|
|
.setHeader('Content-Disposition', `attachment; filename="${exported.filename}"`);
|
|
res.send(exported.content);
|
|
}
|
|
@Post('runs/:id/skill-suggestions') @HttpCode(200) async suggestSkills(
|
|
@Req() r: AuthRequest,
|
|
@Param('id') id: string,
|
|
) {
|
|
return ok(await this.s.skills.suggest(r.actor, id));
|
|
}
|
|
/** Every run of a wish, its stages and the AI's work, as Markdown. */
|
|
@Get('wishes/:id/report') async wishReport(@Req() r: AuthRequest, @Res() res: Response, @Param('id') id: string) {
|
|
const report = await this.s.reports.markdown(r.actor, id);
|
|
res
|
|
.type('text/markdown; charset=utf-8')
|
|
.setHeader('Content-Disposition', `attachment; filename="${report.filename}"`);
|
|
res.send(report.content);
|
|
}
|
|
@Post('projects/:id/wish-refinements') @HttpCode(200) async refineWish(
|
|
@Req() r: AuthRequest,
|
|
@Param('id') id: string,
|
|
@Body() b: unknown,
|
|
) {
|
|
return ok(await this.s.refiner.refine(r.actor, id, b));
|
|
}
|
|
@Post('projects/:id/wishes') @HttpCode(202) async submit(
|
|
@Req() r: AuthRequest,
|
|
@Param('id') id: string,
|
|
@Body() b: unknown,
|
|
) {
|
|
return ok(await this.s.control.submit(r.actor, id, b, key(r)));
|
|
}
|
|
@Get('runs') async runs(
|
|
@Req() r: AuthRequest,
|
|
@Query('project') projectId?: string,
|
|
@Query('limit') limit?: string,
|
|
@Query('before') before?: string,
|
|
) {
|
|
const query = z
|
|
.object({
|
|
projectId: z.string().min(1).max(128).optional(),
|
|
limit: z.coerce.number().int().min(1).max(500).optional(),
|
|
before: z.string().datetime().optional(),
|
|
})
|
|
.parse({ projectId, limit, before });
|
|
return ok(await this.s.control.runs(r.actor, query));
|
|
}
|
|
@Get('runs/:id') async run(@Req() r: AuthRequest, @Param('id') id: string) {
|
|
return ok(await this.s.control.run(r.actor, id));
|
|
}
|
|
@Patch('runs/:id/budget') async updateBudget(@Req() r: AuthRequest, @Param('id') id: string, @Body() b: unknown) {
|
|
return ok(await this.s.control.updateBudget(r.actor, id, b, key(r)));
|
|
}
|
|
@Get('runs/:id/events') async events(@Req() r: AuthRequest, @Param('id') id: string, @Query('after') after?: string) {
|
|
return ok(await this.s.control.events(r.actor, id, Math.max(0, Number(after) || 0)));
|
|
}
|
|
@Get('runs/:id/events/stream') async stream(
|
|
@Req() r: AuthRequest,
|
|
@Res() res: Response,
|
|
@Param('id') id: string,
|
|
@Query('after') after?: string,
|
|
) {
|
|
await this.s.control.run(r.actor, id);
|
|
res.set({
|
|
'Content-Type': 'text/event-stream',
|
|
'Cache-Control': 'no-store',
|
|
Connection: 'keep-alive',
|
|
'X-Accel-Buffering': 'no',
|
|
});
|
|
res.flushHeaders();
|
|
let cursor = Math.max(0, Number(r.header('Last-Event-ID') ?? after) || 0),
|
|
busy = false;
|
|
const pump = async () => {
|
|
if (busy || res.writableEnded) return;
|
|
busy = true;
|
|
try {
|
|
const actor = await this.s.auth.authenticate(
|
|
r.header('Authorization'),
|
|
localUser(name => r.header(name)),
|
|
);
|
|
for (const e of await this.s.control.events(actor, id, cursor)) {
|
|
res.write(`id: ${e.seq}\nevent: run\ndata: ${JSON.stringify(e)}\n\n`);
|
|
cursor = e.seq;
|
|
}
|
|
res.write(': heartbeat\n\n');
|
|
} catch {
|
|
res.end();
|
|
} finally {
|
|
busy = false;
|
|
}
|
|
};
|
|
const timer = setInterval(() => void pump(), 2000);
|
|
r.on('close', () => clearInterval(timer));
|
|
await pump();
|
|
}
|
|
@Post('runs/:id/revert') @HttpCode(202) async revert(@Req() r: AuthRequest, @Param('id') id: string) {
|
|
return ok(await this.s.control.revert(r.actor, id, key(r)));
|
|
}
|
|
@Get('runs/:id/code-review') async codeReview(@Req() r: AuthRequest, @Param('id') id: string) {
|
|
return ok(await this.s.control.codeReview(r.actor, id));
|
|
}
|
|
@Post('runs/:id/code-review') async decideCodeReview(
|
|
@Req() r: AuthRequest,
|
|
@Param('id') id: string,
|
|
@Body() b: unknown,
|
|
) {
|
|
return ok(await this.s.control.decideCodeReview(r.actor, id, b, key(r)));
|
|
}
|
|
@Post('runs/:id/commands') async command(@Req() r: AuthRequest, @Param('id') id: string, @Body() b: unknown) {
|
|
return ok(await this.s.control.command(r.actor, id, b, key(r)));
|
|
}
|
|
@Get('runs/:id/artifacts') async artifacts(@Req() r: AuthRequest, @Param('id') id: string) {
|
|
const { evidence, checkpoint, release } = await this.s.releases.delivery(r.actor, id);
|
|
return ok({ evidence, checkpoint, release });
|
|
}
|
|
@Get('runs/:id/delivery') async delivery(@Req() r: AuthRequest, @Param('id') id: string) {
|
|
return ok(await this.s.releases.delivery(r.actor, id));
|
|
}
|
|
@Get('runs/:id/provider-requests') async providerRequests(@Req() r: AuthRequest, @Param('id') id: string) {
|
|
return ok(await new ProviderProxy(this.s.control.store, this.s.control.env).requests(r.actor, id));
|
|
}
|
|
@Post('runs/:id/provider-requests/reconcile') async reconcileProviderRequest(
|
|
@Req() r: AuthRequest,
|
|
@Param('id') id: string,
|
|
@Body() b: unknown,
|
|
) {
|
|
return ok(await new ProviderProxy(this.s.control.store, this.s.control.env).reconcile(r.actor, id, b));
|
|
}
|
|
@Get('providers') async providers(@Req() r: AuthRequest) {
|
|
return ok(await this.s.control.providers(r.actor));
|
|
}
|
|
@Get('artifacts/:id') async artifactMetadata(@Req() r: AuthRequest, @Param('id') id: string) {
|
|
return ok(await this.s.control.artifacts.metadata(r.actor, id));
|
|
}
|
|
@Get('artifacts/:id/download') async artifactDownload(
|
|
@Req() r: AuthRequest,
|
|
@Param('id') id: string,
|
|
@Res() res: Response,
|
|
) {
|
|
const { metadata, body } = await this.s.control.artifacts.download(r.actor, id);
|
|
res.set({
|
|
'Content-Type': metadata.contentType,
|
|
'Content-Length': String(body.length),
|
|
'Content-Disposition': `attachment; filename="${metadata.sha256}.bundle"`,
|
|
'X-Content-Type-Options': 'nosniff',
|
|
'Cache-Control': 'no-store',
|
|
});
|
|
res.send(body);
|
|
}
|
|
@Get('provider-connections') async connections(@Req() r: AuthRequest) {
|
|
return ok(await this.s.connections.list(r.actor));
|
|
}
|
|
@Post('provider-connections') async connect(@Req() r: AuthRequest, @Body() b: unknown) {
|
|
return ok(await this.s.connections.create(r.actor, b));
|
|
}
|
|
@Delete('provider-connections/:id') async revoke(@Req() r: AuthRequest, @Param('id') id: string) {
|
|
return ok(await this.s.connections.revoke(r.actor, id));
|
|
}
|
|
@Get('environments') async envs(@Req() r: AuthRequest) {
|
|
return ok(await this.s.releases.environments(r.actor));
|
|
}
|
|
@Patch('environments/:id/application-url') async environmentApplicationUrl(
|
|
@Req() r: AuthRequest,
|
|
@Param('id') id: string,
|
|
@Body() body: unknown,
|
|
) {
|
|
const input = z
|
|
.object({ applicationUrl: z.string().max(2048).nullable() })
|
|
.strict()
|
|
.parse(body);
|
|
return ok(await this.s.releases.updateApplicationUrl(r.actor, id, input));
|
|
}
|
|
@Patch('environments/:id/deployment-secrets') async environmentSecrets(
|
|
@Req() r: AuthRequest,
|
|
@Param('id') id: string,
|
|
@Body() body: unknown,
|
|
) {
|
|
const input = z
|
|
.object({
|
|
secretVersionRefs: z.array(z.string().min(1).max(256)).max(32),
|
|
deploymentSecretPolicyDigest: z
|
|
.string()
|
|
.regex(/^sha256:[a-f0-9]{64}$/)
|
|
.nullable(),
|
|
})
|
|
.strict()
|
|
.parse(body);
|
|
return ok(await this.s.releases.updateDeploymentSecrets(r.actor, id, input));
|
|
}
|
|
@Patch('environments/:id/release-policy') async environmentReleasePolicy(
|
|
@Req() r: AuthRequest,
|
|
@Param('id') id: string,
|
|
@Body() b: unknown,
|
|
) {
|
|
return ok(await this.s.releases.updateReleasePolicy(r.actor, id, b));
|
|
}
|
|
@Post('environments/:id/unlock') async unlockEnvironment(
|
|
@Req() r: AuthRequest,
|
|
@Param('id') id: string,
|
|
@Body() b: unknown,
|
|
) {
|
|
return ok(await this.s.releases.unlock(r.actor, id, b));
|
|
}
|
|
@Post('environments') async env(@Req() r: AuthRequest, @Body() b: unknown) {
|
|
return ok(await this.s.releases.createEnvironment(r.actor, b));
|
|
}
|
|
@Post('environments/:id/runners') async runner(@Req() r: AuthRequest, @Param('id') id: string) {
|
|
return ok(await this.s.runners.register(r.actor, id));
|
|
}
|
|
@Get('releases') async releases(@Req() r: AuthRequest) {
|
|
return ok(await this.s.releases.list(r.actor));
|
|
}
|
|
@Post('releases') async release(@Req() r: AuthRequest, @Body() b: unknown) {
|
|
return ok(await this.s.releases.request(r.actor, b, key(r)));
|
|
}
|
|
@Get('releases/:id/review') async releaseReview(@Req() r: AuthRequest, @Param('id') id: string) {
|
|
return ok(await this.s.releases.review(r.actor, id));
|
|
}
|
|
@Post('approvals/:id/decision') async decision(
|
|
@Req() r: AuthRequest,
|
|
@Param('id') id: string,
|
|
@Body() b: { decision: string; bindingDigest: string },
|
|
) {
|
|
return ok(await this.s.releases.decide(r.actor, id, b));
|
|
}
|
|
@Post('releases/:id/rollback') async rollback(@Req() r: AuthRequest, @Param('id') id: string) {
|
|
return ok(await this.s.releases.rollback(r.actor, id, key(r)));
|
|
}
|
|
@Get('agent-bundles') async agentBundles(@Req() r: AuthRequest) {
|
|
return ok(await this.s.bundles.list(r.actor));
|
|
}
|
|
@Post('agent-bundles') async createAgentBundle(@Req() r: AuthRequest, @Body() b: unknown) {
|
|
return ok(await this.s.bundles.create(r.actor, b));
|
|
}
|
|
@Post('agent-bundles/rollback') async rollbackAgentBundle(@Req() r: AuthRequest) {
|
|
return ok(await this.s.bundles.rollback(r.actor));
|
|
}
|
|
@Post('agent-bundles/:version/activate') async activateAgentBundle(
|
|
@Req() r: AuthRequest,
|
|
@Param('version') version: string,
|
|
) {
|
|
return ok(await this.s.bundles.activate(r.actor, version));
|
|
}
|
|
@Get('entitlements') async entitlements(@Req() r: AuthRequest) {
|
|
return ok(await new Entitlements(this.s.control.store, this.s.control.env).view(r.actor));
|
|
}
|
|
@Get('plans') async plans(@Req() r: AuthRequest) {
|
|
return ok(await new Entitlements(this.s.control.store, this.s.control.env).plans(r.actor));
|
|
}
|
|
@Post('admin/members') async admitMember(@Req() r: AuthRequest, @Body() b: unknown) {
|
|
return ok(await new Entitlements(this.s.control.store, this.s.control.env).inviteMember(r.actor, b, key(r)));
|
|
}
|
|
@Get('local-accounts') async localAccounts(@Req() r: AuthRequest) {
|
|
return ok(await this.s.accounts.list(r.actor));
|
|
}
|
|
@Post('local-accounts') async createLocalAccount(@Req() r: AuthRequest, @Body() b: unknown) {
|
|
return ok(await this.s.accounts.create(r.actor, b));
|
|
}
|
|
@Patch('local-accounts/:id') async updateLocalAccount(
|
|
@Req() r: AuthRequest,
|
|
@Param('id') id: string,
|
|
@Body() b: unknown,
|
|
) {
|
|
return ok(await this.s.accounts.update(r.actor, id, b));
|
|
}
|
|
@Post('local-accounts/:id/password') async resetLocalPassword(@Req() r: AuthRequest, @Param('id') id: string) {
|
|
return ok(await this.s.accounts.resetPassword(r.actor, id));
|
|
}
|
|
/** Only the web console's own sign-in calls this; its proxy never forwards a browser here. */
|
|
@Post('local-access/login') @HttpCode(200) async localLogin(@Req() r: AuthRequest, @Body() b: unknown) {
|
|
return ok(await this.s.accounts.verify(r.actor, b));
|
|
}
|
|
@Post('admin/executions/:id/reconcile') async reconcileResources(
|
|
@Req() r: AuthRequest,
|
|
@Param('id') id: string,
|
|
@Body() b: unknown,
|
|
) {
|
|
return ok(
|
|
await new Entitlements(this.s.control.store, this.s.control.env).reconcileAllocation(r.actor, id, b, key(r)),
|
|
);
|
|
}
|
|
@Get('usage') async usage(@Req() r: AuthRequest) {
|
|
return ok(await this.s.control.usage(r.actor));
|
|
}
|
|
@Get('usage/lines') async usageLines(@Req() r: AuthRequest, @Query('period') period?: string) {
|
|
return ok(await new Usage(this.s.control.store).report(r.actor, period));
|
|
}
|
|
@Get('usage/export') async exportUsage(
|
|
@Req() r: AuthRequest,
|
|
@Res() res: Response,
|
|
@Query('period') period?: string,
|
|
) {
|
|
const exported = await new Usage(this.s.control.store).exportCsv(r.actor, period);
|
|
res.type('text/csv').setHeader('Content-Disposition', `attachment; filename="${exported.filename}"`);
|
|
res.send(exported.content);
|
|
}
|
|
@Get('projects/:id/branches') async branches(@Req() r: AuthRequest, @Param('id') id: string) {
|
|
const project = await this.s.control.store.read(r.actor.tenantId, tx => projectAccess(tx, r.actor, id));
|
|
return ok(await new GitStorage(this.s.control.env).ideBranches(project));
|
|
}
|
|
@Get('projects/:id/workspaces') async workspaces(@Req() r: AuthRequest, @Param('id') id: string) {
|
|
return ok(
|
|
await this.s.control.store.read(r.actor.tenantId, async tx => {
|
|
await projectAccess(tx, r.actor, id);
|
|
return (await tx.list<Workspace>('workspace', { projectId: id })).map(publicWorkspace);
|
|
}),
|
|
);
|
|
}
|
|
@Post('projects/:id/workspaces') async workspace(@Req() r: AuthRequest, @Param('id') id: string) {
|
|
requireRole(r.actor, ['owner', 'admin', 'developer']);
|
|
return ok(
|
|
await this.s.control.store.transaction(r.actor.tenantId, async tx => {
|
|
await projectAccess(tx, r.actor, id);
|
|
const existing = (await tx.list<Workspace>('workspace', { projectId: id }))[0];
|
|
if (existing) return publicWorkspace(existing);
|
|
await requireCapacity(tx, 'workspace');
|
|
const workspace = {
|
|
...record(r.actor.tenantId),
|
|
projectId: id,
|
|
status: 'unconfigured',
|
|
reason:
|
|
'An isolated Theia workspace provisioner and authenticated gateway must be connected before this workspace can be opened.',
|
|
};
|
|
await tx.put('workspace', workspace);
|
|
await tx.enqueue('workspace.provision', { workspaceId: workspace.id, projectId: id });
|
|
return workspace;
|
|
}),
|
|
);
|
|
}
|
|
}
|
|
|
|
/** A workspace as people see it: its internal upstream addresses are only for the gateway. */
|
|
function publicWorkspace({ upstreamUrl: _, collaborationUpstreamUrl: _collaboration, ...workspace }: Workspace) {
|
|
return workspace;
|
|
}
|
|
|
|
@Controller('internal')
|
|
export class InternalController {
|
|
constructor(@Inject(Services) private s: Services) {}
|
|
@Post('runs/:id/github/state') async githubState(@Req() r: AuthRequest, @Param('id') id: string, @Body() b: unknown) {
|
|
return ok(await this.s.github.workerState(r.actor, id, leaseBody.parse(b).leaseToken));
|
|
}
|
|
@Post('runs/:id/github/create') async githubCreate(
|
|
@Req() r: AuthRequest,
|
|
@Param('id') id: string,
|
|
@Body() b: unknown,
|
|
) {
|
|
return ok(await this.s.github.workerCreate(r.actor, id, b));
|
|
}
|
|
@Post('runs/:id/github/advance') async githubAdvance(
|
|
@Req() r: AuthRequest,
|
|
@Param('id') id: string,
|
|
@Body() b: unknown,
|
|
) {
|
|
return ok(await this.s.github.workerAdvance(r.actor, id, b));
|
|
}
|
|
@Get('runner/tasks') async runnerTask(@Req() r: AuthRequest, @Query('environmentId') environmentId: string) {
|
|
return this.s.runners.poll(r.actor, environmentId);
|
|
}
|
|
@Post('runner/tasks/:id/result') async runnerResult(
|
|
@Req() r: AuthRequest,
|
|
@Param('id') id: string,
|
|
@Body() b: { result: { releaseId: string; status: string; target: string; evidence: Record<string, unknown> } },
|
|
) {
|
|
return this.s.runners.result(r.actor, id, b);
|
|
}
|
|
@Post('runs/:id/lease') async lease(@Req() r: AuthRequest, @Param('id') id: string, @Body() b: unknown) {
|
|
const { workerId, generation } = leaseRequest.parse(b);
|
|
return ok(await this.s.control.lease(r.actor, id, workerId, generation));
|
|
}
|
|
@Post('runs/:id/lease/release') async releaseLease(
|
|
@Req() r: AuthRequest,
|
|
@Param('id') id: string,
|
|
@Body() b: unknown,
|
|
) {
|
|
return ok(await this.s.control.releaseLease(r.actor, id, leaseBody.parse(b).leaseToken));
|
|
}
|
|
@Post('runs/:id/heartbeat') async heartbeat(@Req() r: AuthRequest, @Param('id') id: string, @Body() b: unknown) {
|
|
return ok(await this.s.control.heartbeat(r.actor, id, leaseBody.parse(b).leaseToken));
|
|
}
|
|
@Post('runs/:id/pause') async completePause(@Req() r: AuthRequest, @Param('id') id: string, @Body() b: unknown) {
|
|
return ok(await this.s.control.completePause(r.actor, id, b));
|
|
}
|
|
@Post('runs/:id/wait') async wait(@Req() r: AuthRequest, @Param('id') id: string, @Body() b: unknown) {
|
|
return ok(await this.s.control.waitRun(r.actor, id, b));
|
|
}
|
|
@Post('runs/:id/repair') async repair(@Req() r: AuthRequest, @Param('id') id: string, @Body() b: unknown) {
|
|
return ok(await this.s.control.repair(r.actor, id, b));
|
|
}
|
|
@Get('runs/:id/state') async workflowState(@Req() r: AuthRequest, @Param('id') id: string) {
|
|
if (r.actor.kind !== 'worker' || r.actor.runId)
|
|
throw new DomainError('FORBIDDEN', 'Trusted coordinator identity required', 403);
|
|
return ok(
|
|
await this.s.control.store.read(r.actor.tenantId, async tx => {
|
|
const run = await must<Run>(tx, 'run', id);
|
|
return {
|
|
status: run.status,
|
|
generation: run.executionGeneration,
|
|
waitingReason: run.waitingReason,
|
|
leaseExpiresAt: run.lease?.expiresAt,
|
|
};
|
|
}),
|
|
);
|
|
}
|
|
@Post('runs/:id/transition') async transition(@Req() r: AuthRequest, @Param('id') id: string, @Body() b: unknown) {
|
|
return ok(await this.s.control.transition(r.actor, id, b));
|
|
}
|
|
@Get('runs/:id/context') async context(@Req() r: AuthRequest, @Param('id') id: string) {
|
|
const context = await this.s.control.context(r.actor, id);
|
|
const [providerCredential, gitCredential] = await Promise.all([
|
|
this.s.connections.forRun(r.actor, context.run),
|
|
context.project.repositoryStorage === 'platform'
|
|
? new GitStorage(this.s.control.env).credential(r.actor, context.project, context.run)
|
|
: this.s.github.app.configured()
|
|
? this.s.github.credential(r.actor, context.project, context.run)
|
|
: undefined,
|
|
]);
|
|
return ok({ ...context, providerCredential, gitCredential });
|
|
}
|
|
@Post('runs/:id/checkpoint') async checkpoint(@Req() r: AuthRequest, @Param('id') id: string, @Body() b: unknown) {
|
|
const { leaseToken, checkpoint, workspace } = checkpointBody.parse(b);
|
|
return ok(await this.s.control.checkpoint(r.actor, id, checkpoint, leaseToken, workspace));
|
|
}
|
|
@Post('runs/:id/code-review') async requestCodeReview(
|
|
@Req() r: AuthRequest,
|
|
@Param('id') id: string,
|
|
@Body() b: unknown,
|
|
) {
|
|
const data = z
|
|
.object({
|
|
leaseToken,
|
|
sourceCommit: commitSha,
|
|
baseCommit: commitSha,
|
|
changedPaths: z.array(z.string().min(1).max(4096)).max(10000),
|
|
})
|
|
.strict()
|
|
.parse(b);
|
|
return ok(await this.s.control.requestCodeReview(r.actor, id, data));
|
|
}
|
|
@Post('runs/:id/classification') async classification(
|
|
@Req() r: AuthRequest,
|
|
@Param('id') id: string,
|
|
@Body() b: unknown,
|
|
) {
|
|
return ok(await this.s.control.classify(r.actor, id, classificationBody.parse(b)));
|
|
}
|
|
@Post('runs/:id/events') async events(@Req() r: AuthRequest, @Param('id') id: string, @Body() b: unknown) {
|
|
return ok(await this.s.control.providerEvent(r.actor, id, b));
|
|
}
|
|
@Post('runs/:id/meter') async meter(@Req() r: AuthRequest, @Param('id') id: string, @Body() b: unknown) {
|
|
return ok(await this.s.control.meter(r.actor, id, meterBody.parse(b)));
|
|
}
|
|
@Post('runs/:id/integration-lease/acquire') async acquireIntegration(
|
|
@Req() r: AuthRequest,
|
|
@Param('id') id: string,
|
|
@Body() b: unknown,
|
|
) {
|
|
const { leaseToken } = leaseBody.parse(b);
|
|
return ok(await this.s.control.integration.acquire(r.actor, id, leaseToken));
|
|
}
|
|
@Post('runs/:id/integration-lease/renew') async renewIntegration(
|
|
@Req() r: AuthRequest,
|
|
@Param('id') id: string,
|
|
@Body() b: unknown,
|
|
) {
|
|
const { leaseToken, fence } = fencedBody.parse(b);
|
|
return ok(await this.s.control.integration.renew(r.actor, id, leaseToken, fence));
|
|
}
|
|
@Post('runs/:id/integration-lease/release') async releaseIntegration(
|
|
@Req() r: AuthRequest,
|
|
@Param('id') id: string,
|
|
@Body() b: unknown,
|
|
) {
|
|
const { leaseToken, fence } = fencedBody.parse(b);
|
|
return ok(await this.s.control.integration.release(r.actor, id, leaseToken, fence));
|
|
}
|
|
@Post('evidence') async evidence(@Req() r: AuthRequest, @Body() b: unknown) {
|
|
return ok(await this.s.control.evidence(r.actor, b));
|
|
}
|
|
@Post('releases') async release(@Req() r: AuthRequest, @Body() b: unknown) {
|
|
if (r.actor.kind !== 'deployer') throw new DomainError('FORBIDDEN', 'Deployer required', 403);
|
|
return ok(await this.s.releases.request(r.actor, b, key(r)));
|
|
}
|
|
@Post('workspaces/:id/authorize') async authorizeWorkspace(
|
|
@Req() r: AuthRequest,
|
|
@Param('id') id: string,
|
|
@Body() body: unknown,
|
|
) {
|
|
const b = authorizeBody.parse(body);
|
|
if (r.actor.userId !== 'workspace-gateway')
|
|
throw new DomainError('FORBIDDEN', 'Workspace gateway identity required', 403);
|
|
const user = b.userToken
|
|
? await this.s.auth.authenticate(`Bearer ${b.userToken}`)
|
|
: await this.s.auth.sessionUser(r.actor.tenantId, b.userId!);
|
|
if (user.tenantId !== r.actor.tenantId) throw new DomainError('NOT_FOUND', 'Workspace not found', 404);
|
|
return ok(
|
|
await this.s.control.store.transaction(user.tenantId, async tx => {
|
|
const workspace = await must<Workspace>(tx, 'workspace', id);
|
|
await projectAccess(tx, user, String(workspace.projectId));
|
|
if (['edit', 'terminal', 'debug'].includes(b.operation)) {
|
|
requireHuman(user);
|
|
requireRole(user, ['owner', 'admin', 'developer']);
|
|
}
|
|
if (workspace.status !== 'ready' || !workspace.upstreamUrl)
|
|
throw new DomainError('WORKSPACE_NOT_READY', 'Workspace has not been provisioned', 503);
|
|
if (
|
|
r.actor.userId === 'workspace-gateway' &&
|
|
(!workspace.lastActivityAt || Date.now() - Date.parse(String(workspace.lastActivityAt)) >= 15000)
|
|
) {
|
|
workspace.lastActivityAt = new Date().toISOString();
|
|
await tx.put('workspace', workspace);
|
|
}
|
|
return {
|
|
tenantId: user.tenantId,
|
|
projectId: workspace.projectId,
|
|
workspaceId: id,
|
|
upstreamUrl: workspace.upstreamUrl,
|
|
collaborationUpstreamUrl: workspace.collaborationUpstreamUrl,
|
|
userId: user.userId,
|
|
role: user.role,
|
|
// Known only from a sign-in token: the gateway keeps it for the session's commits.
|
|
...(b.userToken ? { author: commitAuthor(user) } : {}),
|
|
};
|
|
}),
|
|
);
|
|
}
|
|
@Post('workspaces/:id/git-credential') async workspaceGitCredential(
|
|
@Req() r: AuthRequest,
|
|
@Param('id') id: string,
|
|
@Body() body: unknown,
|
|
) {
|
|
if (r.actor.userId !== 'workspace-gateway')
|
|
throw new DomainError('FORBIDDEN', 'Workspace gateway identity required', 403);
|
|
const { userId } = gatewayUserBody.parse(body);
|
|
return ok(
|
|
await new WorkspaceGit(this.s.control.store, this.s.auth, this.s.control.env).credential(
|
|
r.actor.tenantId,
|
|
id,
|
|
userId,
|
|
),
|
|
);
|
|
}
|
|
}
|