mirror of
https://github.com/harivansh-afk/sandbox-agent.git
synced 2026-04-20 05:04:49 +00:00
381 lines
13 KiB
TypeScript
381 lines
13 KiB
TypeScript
import { Hono } from "hono";
|
|
import { cors } from "hono/cors";
|
|
import { initActorRuntimeContext } from "./actors/context.js";
|
|
import { registry, resolveManagerPort } from "./actors/index.js";
|
|
import { workspaceKey } from "./actors/keys.js";
|
|
import { loadConfig } from "./config/backend.js";
|
|
import { applyDevelopmentEnvDefaults, loadDevelopmentEnvFiles } from "./config/env.js";
|
|
import { createBackends, createNotificationService } from "./notifications/index.js";
|
|
import { createDefaultDriver } from "./driver.js";
|
|
import { createProviderRegistry } from "./providers/index.js";
|
|
import { createClient } from "rivetkit/client";
|
|
import type { FoundryBillingPlanId } from "@sandbox-agent/foundry-shared";
|
|
import { createDefaultAppShellServices } from "./services/app-shell-runtime.js";
|
|
import { APP_SHELL_WORKSPACE_ID } from "./actors/workspace/app-shell.js";
|
|
|
|
export interface BackendStartOptions {
|
|
host?: string;
|
|
port?: number;
|
|
}
|
|
|
|
export async function startBackend(options: BackendStartOptions = {}): Promise<void> {
|
|
process.env.NODE_ENV ||= "development";
|
|
loadDevelopmentEnvFiles();
|
|
applyDevelopmentEnvDefaults();
|
|
|
|
// sandbox-agent agent plugins vary on which env var they read for OpenAI/Codex auth.
|
|
// Normalize to keep local dev + docker-compose simple.
|
|
if (!process.env.CODEX_API_KEY && process.env.OPENAI_API_KEY) {
|
|
process.env.CODEX_API_KEY = process.env.OPENAI_API_KEY;
|
|
}
|
|
|
|
const config = loadConfig();
|
|
config.backend.host = options.host ?? config.backend.host;
|
|
config.backend.port = options.port ?? config.backend.port;
|
|
|
|
// Allow docker-compose/dev environments to supply provider config via env vars
|
|
// instead of writing into the container's config.toml.
|
|
const envFirst = (...keys: string[]): string | undefined => {
|
|
for (const key of keys) {
|
|
const raw = process.env[key];
|
|
if (raw && raw.trim().length > 0) return raw.trim();
|
|
}
|
|
return undefined;
|
|
};
|
|
|
|
config.providers.daytona.endpoint =
|
|
envFirst("HF_DAYTONA_ENDPOINT", "DAYTONA_ENDPOINT") ?? config.providers.daytona.endpoint;
|
|
config.providers.daytona.apiKey =
|
|
envFirst("HF_DAYTONA_API_KEY", "DAYTONA_API_KEY") ?? config.providers.daytona.apiKey;
|
|
|
|
const driver = createDefaultDriver();
|
|
const providers = createProviderRegistry(config, driver);
|
|
const backends = await createBackends(config.notify);
|
|
const notifications = createNotificationService(backends);
|
|
initActorRuntimeContext(config, providers, notifications, driver, createDefaultAppShellServices());
|
|
|
|
registry.startRunner();
|
|
const inner = registry.serve();
|
|
const actorClient = createClient({
|
|
endpoint: `http://127.0.0.1:${resolveManagerPort()}`,
|
|
disableMetadataLookup: true,
|
|
}) as any;
|
|
|
|
const managerOrigin = `http://127.0.0.1:${resolveManagerPort()}`;
|
|
|
|
// Wrap in a Hono app mounted at /api/rivet to serve on the backend port.
|
|
// Uses Bun.serve — cannot use @hono/node-server because it conflicts with
|
|
// RivetKit's internal Bun.serve manager server (Bun bug: mixing Node HTTP
|
|
// server and Bun.serve in the same process breaks Bun.serve's fetch handler).
|
|
const app = new Hono();
|
|
const allowHeaders = [
|
|
"Content-Type",
|
|
"Authorization",
|
|
"x-rivet-token",
|
|
"x-rivet-encoding",
|
|
"x-rivet-query",
|
|
"x-rivet-conn-params",
|
|
"x-rivet-actor",
|
|
"x-rivet-target",
|
|
"x-rivet-namespace",
|
|
"x-rivet-endpoint",
|
|
"x-rivet-total-slots",
|
|
"x-rivet-runner-name",
|
|
"x-rivet-namespace-name",
|
|
"x-foundry-session",
|
|
];
|
|
const exposeHeaders = ["Content-Type", "x-foundry-session", "x-rivet-ray-id"];
|
|
app.use(
|
|
"/api/rivet/*",
|
|
cors({
|
|
origin: (origin) => origin ?? "*",
|
|
credentials: true,
|
|
allowHeaders,
|
|
allowMethods: ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"],
|
|
exposeHeaders,
|
|
})
|
|
);
|
|
app.use(
|
|
"/api/rivet",
|
|
cors({
|
|
origin: (origin) => origin ?? "*",
|
|
credentials: true,
|
|
allowHeaders,
|
|
allowMethods: ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"],
|
|
exposeHeaders,
|
|
})
|
|
);
|
|
const appWorkspace = async () =>
|
|
await actorClient.workspace.getOrCreate(workspaceKey(APP_SHELL_WORKSPACE_ID), {
|
|
createWithInput: APP_SHELL_WORKSPACE_ID,
|
|
});
|
|
|
|
const resolveSessionId = async (c: any): Promise<string> => {
|
|
const requested = c.req.header("x-foundry-session");
|
|
const { sessionId } = await (await appWorkspace()).ensureAppSession({
|
|
requestedSessionId: requested ?? null,
|
|
});
|
|
c.header("x-foundry-session", sessionId);
|
|
return sessionId;
|
|
};
|
|
|
|
app.get("/api/rivet/app/snapshot", async (c) => {
|
|
const sessionId = await resolveSessionId(c);
|
|
return c.json(await (await appWorkspace()).getAppSnapshot({ sessionId }));
|
|
});
|
|
|
|
app.get("/api/rivet/app/auth/github/start", async (c) => {
|
|
const sessionId = await resolveSessionId(c);
|
|
const result = await (await appWorkspace()).startAppGithubAuth({ sessionId });
|
|
return Response.redirect(result.url, 302);
|
|
});
|
|
|
|
app.get("/api/rivet/app/auth/github/callback", async (c) => {
|
|
const code = c.req.query("code");
|
|
const state = c.req.query("state");
|
|
if (!code || !state) {
|
|
return c.text("Missing GitHub OAuth callback parameters", 400);
|
|
}
|
|
const result = await (await appWorkspace()).completeAppGithubAuth({ code, state });
|
|
c.header("x-foundry-session", result.sessionId);
|
|
return Response.redirect(result.redirectTo, 302);
|
|
});
|
|
|
|
app.post("/api/rivet/app/sign-out", async (c) => {
|
|
const sessionId = await resolveSessionId(c);
|
|
return c.json(await (await appWorkspace()).signOutApp({ sessionId }));
|
|
});
|
|
|
|
app.post("/api/rivet/app/organizations/:organizationId/select", async (c) => {
|
|
const sessionId = await resolveSessionId(c);
|
|
return c.json(
|
|
await (await appWorkspace()).selectAppOrganization({
|
|
sessionId,
|
|
organizationId: c.req.param("organizationId"),
|
|
}),
|
|
);
|
|
});
|
|
|
|
app.patch("/api/rivet/app/organizations/:organizationId/profile", async (c) => {
|
|
const sessionId = await resolveSessionId(c);
|
|
const body = await c.req.json();
|
|
return c.json(
|
|
await (await appWorkspace()).updateAppOrganizationProfile({
|
|
sessionId,
|
|
organizationId: c.req.param("organizationId"),
|
|
displayName: typeof body?.displayName === "string" ? body.displayName : "",
|
|
slug: typeof body?.slug === "string" ? body.slug : "",
|
|
primaryDomain: typeof body?.primaryDomain === "string" ? body.primaryDomain : "",
|
|
}),
|
|
);
|
|
});
|
|
|
|
app.post("/api/rivet/app/organizations/:organizationId/import", async (c) => {
|
|
const sessionId = await resolveSessionId(c);
|
|
return c.json(
|
|
await (await appWorkspace()).triggerAppRepoImport({
|
|
sessionId,
|
|
organizationId: c.req.param("organizationId"),
|
|
}),
|
|
);
|
|
});
|
|
|
|
app.post("/api/rivet/app/organizations/:organizationId/reconnect", async (c) => {
|
|
const sessionId = await resolveSessionId(c);
|
|
return c.json(
|
|
await (await appWorkspace()).beginAppGithubInstall({
|
|
sessionId,
|
|
organizationId: c.req.param("organizationId"),
|
|
}),
|
|
);
|
|
});
|
|
|
|
app.post("/api/rivet/app/organizations/:organizationId/billing/checkout", async (c) => {
|
|
const sessionId = await resolveSessionId(c);
|
|
const body = await c.req.json().catch(() => ({}));
|
|
const planId = body?.planId === "free" || body?.planId === "team" ? (body.planId as FoundryBillingPlanId) : "team";
|
|
return c.json(
|
|
await (await appWorkspace()).createAppCheckoutSession({
|
|
sessionId,
|
|
organizationId: c.req.param("organizationId"),
|
|
planId,
|
|
}),
|
|
);
|
|
});
|
|
|
|
app.get("/api/rivet/app/billing/checkout/complete", async (c) => {
|
|
const organizationId = c.req.query("organizationId");
|
|
const sessionId = c.req.query("foundrySession");
|
|
const checkoutSessionId = c.req.query("session_id");
|
|
if (!organizationId || !sessionId || !checkoutSessionId) {
|
|
return c.text("Missing Stripe checkout completion parameters", 400);
|
|
}
|
|
const result = await (await appWorkspace()).finalizeAppCheckoutSession({
|
|
organizationId,
|
|
sessionId,
|
|
checkoutSessionId,
|
|
});
|
|
return Response.redirect(result.redirectTo, 302);
|
|
});
|
|
|
|
app.post("/api/rivet/app/organizations/:organizationId/billing/portal", async (c) => {
|
|
const sessionId = await resolveSessionId(c);
|
|
return c.json(
|
|
await (await appWorkspace()).createAppBillingPortalSession({
|
|
sessionId,
|
|
organizationId: c.req.param("organizationId"),
|
|
}),
|
|
);
|
|
});
|
|
|
|
app.post("/api/rivet/app/organizations/:organizationId/billing/cancel", async (c) => {
|
|
const sessionId = await resolveSessionId(c);
|
|
return c.json(
|
|
await (await appWorkspace()).cancelAppScheduledRenewal({
|
|
sessionId,
|
|
organizationId: c.req.param("organizationId"),
|
|
}),
|
|
);
|
|
});
|
|
|
|
app.post("/api/rivet/app/organizations/:organizationId/billing/resume", async (c) => {
|
|
const sessionId = await resolveSessionId(c);
|
|
return c.json(
|
|
await (await appWorkspace()).resumeAppSubscription({
|
|
sessionId,
|
|
organizationId: c.req.param("organizationId"),
|
|
}),
|
|
);
|
|
});
|
|
|
|
const handleStripeWebhook = async (c: any) => {
|
|
const payload = await c.req.text();
|
|
await (await appWorkspace()).handleAppStripeWebhook({
|
|
payload,
|
|
signatureHeader: c.req.header("stripe-signature") ?? null,
|
|
});
|
|
return c.json({ ok: true });
|
|
};
|
|
|
|
app.post("/api/rivet/app/webhooks/stripe", handleStripeWebhook);
|
|
app.post("/api/rivet/app/stripe/webhook", handleStripeWebhook);
|
|
|
|
const handleGithubWebhook = async (c: any) => {
|
|
const payload = await c.req.text();
|
|
await (await appWorkspace()).handleAppGithubWebhook({
|
|
payload,
|
|
signatureHeader: c.req.header("x-hub-signature-256") ?? null,
|
|
eventHeader: c.req.header("x-github-event") ?? null,
|
|
});
|
|
return c.json({ ok: true });
|
|
};
|
|
|
|
app.post("/api/rivet/app/webhooks/github", handleGithubWebhook);
|
|
|
|
app.post("/api/rivet/app/workspaces/:workspaceId/seat-usage", async (c) => {
|
|
const sessionId = await resolveSessionId(c);
|
|
const workspaceId = c.req.param("workspaceId");
|
|
return c.json(
|
|
await (await appWorkspace()).recordAppSeatUsage({
|
|
sessionId,
|
|
workspaceId,
|
|
}),
|
|
);
|
|
});
|
|
|
|
const proxyManagerRequest = async (c: any) => {
|
|
const source = new URL(c.req.url);
|
|
const target = new URL(source.pathname.replace(/^\/api\/rivet/, "") + source.search, managerOrigin);
|
|
return await fetch(new Request(target.toString(), c.req.raw));
|
|
};
|
|
|
|
const forward = async (c: any) => {
|
|
try {
|
|
const pathname = new URL(c.req.url).pathname;
|
|
if (pathname === "/api/rivet/app/webhooks/stripe" || pathname === "/api/rivet/app/stripe/webhook") {
|
|
return await handleStripeWebhook(c);
|
|
}
|
|
if (pathname === "/api/rivet/app/webhooks/github") {
|
|
return await handleGithubWebhook(c);
|
|
}
|
|
if (pathname.startsWith("/api/rivet/app/")) {
|
|
return c.text("Not Found", 404);
|
|
}
|
|
if (
|
|
pathname === "/api/rivet/metadata" ||
|
|
pathname === "/api/rivet/actors" ||
|
|
pathname.startsWith("/api/rivet/actors/") ||
|
|
pathname.startsWith("/api/rivet/gateway/")
|
|
) {
|
|
return await proxyManagerRequest(c);
|
|
}
|
|
// RivetKit serverless handler is configured with basePath `/api/rivet` by default.
|
|
return await inner.fetch(c.req.raw);
|
|
} catch (err) {
|
|
if (err instanceof URIError) {
|
|
return c.text("Bad Request: Malformed URI", 400);
|
|
}
|
|
throw err;
|
|
}
|
|
};
|
|
app.all("/api/rivet", forward);
|
|
app.all("/api/rivet/*", forward);
|
|
|
|
const server = Bun.serve({
|
|
fetch: app.fetch,
|
|
hostname: config.backend.host,
|
|
port: config.backend.port
|
|
});
|
|
|
|
process.on("SIGINT", async () => {
|
|
server.stop();
|
|
process.exit(0);
|
|
});
|
|
|
|
process.on("SIGTERM", async () => {
|
|
server.stop();
|
|
process.exit(0);
|
|
});
|
|
|
|
// Keep process alive.
|
|
await new Promise<void>(() => undefined);
|
|
}
|
|
|
|
function parseArg(flag: string): string | undefined {
|
|
const idx = process.argv.indexOf(flag);
|
|
if (idx < 0) return undefined;
|
|
return process.argv[idx + 1];
|
|
}
|
|
|
|
function parseEnvPort(value: string | undefined): number | undefined {
|
|
if (!value) {
|
|
return undefined;
|
|
}
|
|
const port = Number(value);
|
|
if (!Number.isInteger(port) || port <= 0 || port > 65535) {
|
|
return undefined;
|
|
}
|
|
return port;
|
|
}
|
|
|
|
async function main(): Promise<void> {
|
|
const cmd = process.argv[2] ?? "start";
|
|
if (cmd !== "start") {
|
|
throw new Error(`Unsupported backend command: ${cmd}`);
|
|
}
|
|
|
|
const host = parseArg("--host") ?? process.env.HOST ?? process.env.HF_BACKEND_HOST;
|
|
const port = parseArg("--port") ?? process.env.PORT ?? process.env.HF_BACKEND_PORT;
|
|
await startBackend({
|
|
host,
|
|
port: parseEnvPort(port)
|
|
});
|
|
}
|
|
|
|
if (import.meta.url === `file://${process.argv[1]}`) {
|
|
main().catch((err: unknown) => {
|
|
const message = err instanceof Error ? err.stack ?? err.message : String(err);
|
|
console.error(message);
|
|
process.exit(1);
|
|
});
|
|
}
|