takos-control 1.0.0

package/src/server/routes/browser-sessions.ts

@@ -0,0 +1,258 @@
+/**
+ * Edge API routes for browser sessions.
+ *
+ * Each route authenticates the user, verifies session ownership,
+ * and forwards to the BROWSER_HOST service binding (if configured).
+ * Returns 503 when the binding is not available.
+ */
+
+import { Hono } from 'hono';
+import type { Env, User } from '../../shared/types';
+import { bytesToHex } from '../../shared/utils/encoding-utils';
+
+type BrowserSessionVariables = {
+  user?: User;
+};
+
+const browserSessions = new Hono<{
+  Bindings: Env;
+  Variables: BrowserSessionVariables;
+}>();
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function getBrowserHost(env: Env): { fetch(request: Request): Promise<Response> } | null {
+  return env.BROWSER_HOST ?? null;
+}
+
+function generateSessionId(): string {
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  return bytesToHex(bytes);
+}
+
+async function forwardToBrowserHost(
+  browserHost: { fetch(request: Request): Promise<Response> },
+  path: string,
+  init?: RequestInit
+): Promise<Response> {
+  return browserHost.fetch(
+    new Request(`https://browser-host.internal${path}`, init)
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Routes
+// ---------------------------------------------------------------------------
+
+// Create browser session
+browserSessions.post('/spaces/:spaceId/browser-sessions', async (c) => {
+  const user = c.get('user');
+  if (!user) return c.json({ error: 'Unauthorized' }, 401);
+
+  const spaceId = c.req.param('spaceId');
+  const body = await c.req.json<{ url?: string; viewport?: { width: number; height: number } }>();
+  const sessionId = generateSessionId();
+
+  const browserHost = getBrowserHost(c.env);
+  if (!browserHost) return c.json({ error: 'Browser service not available' }, 503);
+
+  const response = await forwardToBrowserHost(browserHost, '/create', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      sessionId,
+      spaceId,
+      userId: user.id,
+      url: body.url,
+      viewport: body.viewport,
+    }),
+  });
+
+  if (!response.ok) {
+    const error = await response.text();
+    return c.json({ error: `Failed to create browser session: ${error}` }, 500);
+  }
+
+  const result = await response.json() as Record<string, unknown>;
+  return c.json({ sessionId, ...result }, 201);
+});
+
+// Get session info
+browserSessions.get('/browser-sessions/:id', async (c) => {
+  const user = c.get('user');
+  if (!user) return c.json({ error: 'Unauthorized' }, 401);
+
+  const sessionId = c.req.param('id');
+  const browserHost = getBrowserHost(c.env);
+  if (!browserHost) return c.json({ error: 'Browser service not available' }, 503);
+
+  const response = await forwardToBrowserHost(browserHost, `/session/${sessionId}`);
+  if (!response.ok) {
+    return c.json({ error: 'Session not found' }, 404);
+  }
+
+  const state = await response.json<{ userId: string }>();
+  // Ownership check
+  if (state.userId !== user.id) {
+    return c.json({ error: 'Forbidden' }, 403);
+  }
+
+  return c.json(state);
+});
+
+// Goto URL
+browserSessions.post('/browser-sessions/:id/goto', async (c) => {
+  const user = c.get('user');
+  if (!user) return c.json({ error: 'Unauthorized' }, 401);
+
+  const sessionId = c.req.param('id');
+  const body = await c.req.json();
+  const browserHost = getBrowserHost(c.env);
+  if (!browserHost) return c.json({ error: 'Browser service not available' }, 503);
+
+  const response = await forwardToBrowserHost(
+    browserHost,
+    `/session/${sessionId}/goto`,
+    {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+    }
+  );
+  const data = await response.json();
+  return c.json(data, response.status as 200);
+});
+
+// Browser action
+browserSessions.post('/browser-sessions/:id/action', async (c) => {
+  const user = c.get('user');
+  if (!user) return c.json({ error: 'Unauthorized' }, 401);
+
+  const sessionId = c.req.param('id');
+  const body = await c.req.json();
+  const browserHost = getBrowserHost(c.env);
+  if (!browserHost) return c.json({ error: 'Browser service not available' }, 503);
+
+  const response = await forwardToBrowserHost(
+    browserHost,
+    `/session/${sessionId}/action`,
+    {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+    }
+  );
+  const data = await response.json();
+  return c.json(data, response.status as 200);
+});
+
+// Extract data
+browserSessions.post('/browser-sessions/:id/extract', async (c) => {
+  const user = c.get('user');
+  if (!user) return c.json({ error: 'Unauthorized' }, 401);
+
+  const sessionId = c.req.param('id');
+  const body = await c.req.json();
+  const browserHost = getBrowserHost(c.env);
+  if (!browserHost) return c.json({ error: 'Browser service not available' }, 503);
+
+  const response = await forwardToBrowserHost(
+    browserHost,
+    `/session/${sessionId}/extract`,
+    {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+    }
+  );
+  const data = await response.json();
+  return c.json(data, response.status as 200);
+});
+
+// Get HTML
+browserSessions.get('/browser-sessions/:id/html', async (c) => {
+  const user = c.get('user');
+  if (!user) return c.json({ error: 'Unauthorized' }, 401);
+
+  const sessionId = c.req.param('id');
+  const browserHost = getBrowserHost(c.env);
+  if (!browserHost) return c.json({ error: 'Browser service not available' }, 503);
+
+  const response = await forwardToBrowserHost(
+    browserHost,
+    `/session/${sessionId}/html`
+  );
+  const data = await response.json();
+  return c.json(data, response.status as 200);
+});
+
+// Screenshot
+browserSessions.get('/browser-sessions/:id/screenshot', async (c) => {
+  const user = c.get('user');
+  if (!user) return c.json({ error: 'Unauthorized' }, 401);
+
+  const sessionId = c.req.param('id');
+  const browserHost = getBrowserHost(c.env);
+  if (!browserHost) return c.json({ error: 'Browser service not available' }, 503);
+
+  const response = await forwardToBrowserHost(
+    browserHost,
+    `/session/${sessionId}/screenshot`
+  );
+
+  const headers = new Headers();
+  headers.set('Content-Type', response.headers.get('Content-Type') ?? 'image/png');
+  if (response.headers.has('Content-Length')) {
+    headers.set('Content-Length', response.headers.get('Content-Length')!);
+  }
+  return new Response(response.body, { status: response.status, headers });
+});
+
+// PDF
+browserSessions.post('/browser-sessions/:id/pdf', async (c) => {
+  const user = c.get('user');
+  if (!user) return c.json({ error: 'Unauthorized' }, 401);
+
+  const sessionId = c.req.param('id');
+  const browserHost = getBrowserHost(c.env);
+  if (!browserHost) return c.json({ error: 'Browser service not available' }, 503);
+
+  const response = await forwardToBrowserHost(
+    browserHost,
+    `/session/${sessionId}/pdf`,
+    {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+    }
+  );
+
+  const headers = new Headers();
+  headers.set('Content-Type', response.headers.get('Content-Type') ?? 'application/pdf');
+  if (response.headers.has('Content-Length')) {
+    headers.set('Content-Length', response.headers.get('Content-Length')!);
+  }
+  return new Response(response.body, { status: response.status, headers });
+});
+
+// Destroy session
+browserSessions.delete('/browser-sessions/:id', async (c) => {
+  const user = c.get('user');
+  if (!user) return c.json({ error: 'Unauthorized' }, 401);
+
+  const sessionId = c.req.param('id');
+  const browserHost = getBrowserHost(c.env);
+  if (!browserHost) return c.json({ error: 'Browser service not available' }, 503);
+
+  const response = await forwardToBrowserHost(
+    browserHost,
+    `/session/${sessionId}`,
+    { method: 'DELETE' }
+  );
+  const data = await response.json();
+  return c.json(data);
+});
+
+export default browserSessions;

package/src/server/routes/common-env/handlers.ts

@@ -0,0 +1,23 @@
+import { hashAuditIp, type CommonEnvAuditActor } from '../../../application/services/common-env/audit';
+import type { Env } from '../../../shared/types';
+
+/**
+ * Build an audit actor from a Hono request context and user ID.
+ * Shared between workspace common-env routes and worker settings routes.
+ */
+export async function buildCommonEnvActor(c: {
+  req: { header: (name: string) => string | undefined };
+  env: Env;
+}, userId: string): Promise<CommonEnvAuditActor> {
+  const requestId = c.req.header('x-request-id') || c.req.header('cf-ray');
+  const userAgent = c.req.header('user-agent') || c.req.header('User-Agent');
+  const forwarded = c.req.header('x-forwarded-for');
+  const ip = c.req.header('cf-connecting-ip') || (forwarded ? forwarded.split(',')[0]?.trim() : undefined);
+  return {
+    type: 'user',
+    userId,
+    requestId,
+    ipHash: await hashAuditIp(c.env, ip),
+    userAgent,
+  };
+}

package/src/server/routes/custom-domains.ts

@@ -0,0 +1,132 @@
+import { Hono } from 'hono';
+import { z } from 'zod';
+import type { Context } from 'hono';
+import type { ContentfulStatusCode } from 'hono/utils/http-status';
+import type { Env } from '../../shared/types';
+import type { BaseVariables } from './shared/route-auth';
+import { zValidator } from './zod-validator';
+import { logError } from '../../shared/utils/logger';
+import { AppError, BadRequestError, InternalError, ErrorCodes } from 'takos-common/errors';
+import {
+  addCustomDomain,
+  CustomDomainError,
+  deleteCustomDomain,
+  getCustomDomainDetails,
+  listCustomDomains,
+  refreshSslStatus,
+  verifyCustomDomain,
+} from '../../application/services/platform/custom-domains';
+
+type AppEnv = { Bindings: Env; Variables: BaseVariables };
+type AppContext = Context<AppEnv>;
+
+function toStatusCode(status: number): ContentfulStatusCode {
+  return status as ContentfulStatusCode;
+}
+
+function handleCustomDomainError(err: unknown, fallbackMessage: string): never {
+  if (err instanceof CustomDomainError) {
+    throw new AppError(err.message, ErrorCodes.INTERNAL_ERROR, err.status, err.details);
+  }
+  logError('[custom-domains]', err, { module: 'custom-domains' });
+  throw new InternalError(fallbackMessage);
+}
+
+async function listCustomDomainsHandler(c: AppContext) {
+  const user = c.get('user');
+  const serviceId = c.req.param('id');
+  if (!serviceId) throw new BadRequestError('Missing serviceId');
+
+  try {
+    const data = await listCustomDomains(c.env, serviceId, user.id);
+    return c.json(data);
+  } catch (err) {
+    handleCustomDomainError(err, 'Failed to list custom domains');
+  }
+}
+
+async function verifyCustomDomainHandler(c: AppContext) {
+  const user = c.get('user');
+  const serviceId = c.req.param('id');
+  const domainId = c.req.param('domainId');
+  if (!serviceId) throw new BadRequestError('Missing serviceId');
+  if (!domainId) throw new BadRequestError('Missing domainId');
+
+  try {
+    const result = await verifyCustomDomain(c.env, serviceId, user.id, domainId);
+    return c.json(result.body, toStatusCode(result.status));
+  } catch (err) {
+    handleCustomDomainError(err, 'Failed to verify custom domain');
+  }
+}
+
+async function getCustomDomainDetailsHandler(c: AppContext) {
+  const user = c.get('user');
+  const serviceId = c.req.param('id');
+  const domainId = c.req.param('domainId');
+  if (!serviceId) throw new BadRequestError('Missing serviceId');
+  if (!domainId) throw new BadRequestError('Missing domainId');
+
+  try {
+    const data = await getCustomDomainDetails(c.env, serviceId, user.id, domainId);
+    return c.json(data);
+  } catch (err) {
+    handleCustomDomainError(err, 'Failed to get custom domain details');
+  }
+}
+
+async function deleteCustomDomainHandler(c: AppContext) {
+  const user = c.get('user');
+  const serviceId = c.req.param('id');
+  const domainId = c.req.param('domainId');
+  if (!serviceId) throw new BadRequestError('Missing serviceId');
+  if (!domainId) throw new BadRequestError('Missing domainId');
+
+  try {
+    const data = await deleteCustomDomain(c.env, serviceId, user.id, domainId);
+    return c.json(data);
+  } catch (err) {
+    handleCustomDomainError(err, 'Failed to delete custom domain');
+  }
+}
+
+async function refreshSslStatusHandler(c: AppContext) {
+  const user = c.get('user');
+  const serviceId = c.req.param('id');
+  const domainId = c.req.param('domainId');
+  if (!serviceId) throw new BadRequestError('Missing serviceId');
+  if (!domainId) throw new BadRequestError('Missing domainId');
+
+  try {
+    const data = await refreshSslStatus(c.env, serviceId, user.id, domainId);
+    return c.json(data);
+  } catch (err) {
+    handleCustomDomainError(err, 'Failed to refresh SSL status');
+  }
+}
+
+const addCustomDomainSchema = z.object({
+  domain: z.string(),
+  verification_method: z.enum(['cname', 'txt']).optional(),
+});
+
+async function addCustomDomainHandler(c: AppContext) {
+  const user = c.get('user');
+  const serviceId = c.req.param('id');
+  if (!serviceId) throw new BadRequestError('Missing serviceId');
+  const body = c.req.valid('json' as never) as z.infer<typeof addCustomDomainSchema>;
+  try {
+    const result = await addCustomDomain(c.env, serviceId, user.id, body);
+    return c.json(result.body, toStatusCode(result.status));
+  } catch (err) {
+    handleCustomDomainError(err, 'Failed to create custom domain');
+  }
+}
+
+export default new Hono<AppEnv>()
+  .get('/services/:id/custom-domains', listCustomDomainsHandler)
+  .post('/services/:id/custom-domains', zValidator('json', addCustomDomainSchema), addCustomDomainHandler)
+  .post('/services/:id/custom-domains/:domainId/verify', verifyCustomDomainHandler)
+  .get('/services/:id/custom-domains/:domainId', getCustomDomainDetailsHandler)
+  .delete('/services/:id/custom-domains/:domainId', deleteCustomDomainHandler)
+  .post('/services/:id/custom-domains/:domainId/refresh-ssl', refreshSslStatusHandler);

package/src/server/routes/explore/explore-filters.ts

@@ -0,0 +1,262 @@
+import { eq, ne, and, or, desc, asc, like, inArray, sql } from 'drizzle-orm';
+import { accounts, repositories, repoReleases, repoReleaseAssets } from '../../../infra/db/schema';
+import type { Database } from '../../../infra/db';
+import { BadRequestError } from 'takos-common/errors';
+
+export interface ReleaseAsset {
+  id: string;
+  name: string;
+  content_type: string;
+  size: number;
+  r2_key: string;
+  download_count: number;
+  bundle_format?: string;
+  bundle_meta?: {
+    name?: string;
+    app_id?: string;
+    version: string;
+    description?: string;
+    icon?: string;
+    category?: 'app' | 'service' | 'library' | 'template' | 'social';
+    tags?: string[];
+    dependencies?: Array<{ repo: string; version: string }>;
+  };
+  created_at: string;
+}
+
+export type RepoByNameLookup = {
+  id: string;
+  name: string;
+  description: string | null;
+  visibility: string;
+  default_branch: string;
+  stars: number;
+  forks: number;
+  created_at: string;
+  updated_at: string;
+  space_id: string;
+  workspace_name: string;
+  owner_id: string;
+  owner_name: string;
+  owner_username: string;
+  owner_avatar_url: string | null;
+};
+
+export interface ExploreFilterParams {
+  category: string | undefined;
+  language: string | undefined;
+  license: string | undefined;
+  since: string | undefined;
+}
+
+export const EXPLORE_CATEGORIES = ['app', 'service', 'library', 'template', 'social'] as const;
+
+export const CATEGORY_FILTER_OPTS = { maxLen: 32, pattern: /^[a-z0-9_-]+$/ } as const;
+export const LANG_LICENSE_FILTER_OPTS = { maxLen: 64, pattern: /^[a-z0-9][a-z0-9+_.-]*$/ } as const;
+
+export function normalizeSimpleFilter(
+  value: string | undefined,
+  opts: { maxLen: number; pattern: RegExp }
+): string | undefined {
+  if (!value) return undefined;
+  const v = value.trim().toLowerCase();
+  if (!v) return undefined;
+  if (v.length > opts.maxLen) return undefined;
+  if (!opts.pattern.test(v)) return undefined;
+  return v;
+}
+
+export function parseSinceDateToIsoStart(value: string | undefined): string | undefined {
+  if (!value) return undefined;
+  const raw = value.trim();
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(raw)) return undefined;
+  const iso = `${raw}T00:00:00.000Z`;
+  if (!Number.isFinite(Date.parse(iso))) return undefined;
+  return iso;
+}
+
+export function parseExploreFilters(c: { req: { query: (key: string) => string | undefined } }): ExploreFilterParams {
+  return {
+    category: normalizeSimpleFilter(c.req.query('category'), CATEGORY_FILTER_OPTS),
+    language: normalizeSimpleFilter(c.req.query('language'), LANG_LICENSE_FILTER_OPTS),
+    license: normalizeSimpleFilter(c.req.query('license'), LANG_LICENSE_FILTER_OPTS),
+    since: parseSinceDateToIsoStart(c.req.query('since')),
+  };
+}
+
+export function validateExploreFilters(
+  c: { req: { query: (key: string) => string | undefined } },
+  filters: ExploreFilterParams,
+): void {
+  if (filters.category && !(EXPLORE_CATEGORIES as ReadonlyArray<string>).includes(filters.category)) {
+    throw new BadRequestError('Invalid category');
+  }
+  if (c.req.query('since') && !filters.since) {
+    throw new BadRequestError('Invalid since (expected YYYY-MM-DD)');
+  }
+}
+
+export function parseTags(
+  tagsRaw: string | undefined,
+): string[] {
+  const tags = (tagsRaw || '')
+    .split(',')
+    .map((value) => value.trim().toLowerCase())
+    .filter(Boolean)
+    .slice(0, 10);
+  for (const tag of tags) {
+    if (tag.length > 64 || !/^[a-z0-9][a-z0-9_-]*$/.test(tag)) {
+      throw new BadRequestError('Invalid tags (expected comma-separated tag slugs)');
+    }
+  }
+  return tags;
+}
+
+export async function findRepoByUsernameAndName(
+  db: Database,
+  username: string,
+  repoName: string
+) {
+  const cleanUsername = username.trim().toLowerCase();
+  const cleanRepoName = repoName.trim().toLowerCase();
+
+  const results = await db.all<RepoByNameLookup>(sql`
+    SELECT
+      r.id AS id,
+      r.name AS name,
+      r.description AS description,
+      r.visibility AS visibility,
+      r.default_branch AS default_branch,
+      r.stars AS stars,
+      r.forks AS forks,
+      r.created_at AS created_at,
+      r.updated_at AS updated_at,
+      a.id AS space_id,
+      a.name AS workspace_name,
+      a.id AS owner_id,
+      a.name AS owner_name,
+      a.slug AS owner_username,
+      a.picture AS owner_avatar_url
+    FROM repositories r
+    JOIN accounts a ON a.id = r.account_id
+    WHERE lower(r.name) = ${cleanRepoName}
+      AND lower(a.slug) = ${cleanUsername}
+    LIMIT 1
+  `);
+
+  return results[0] ?? null;
+}
+
+export async function buildCatalogSuggestions(
+  db: Database,
+  q: string,
+  limit: number,
+) {
+  const [userRows, repoRows] = await Promise.all([
+    db.select({
+      slug: accounts.slug,
+      name: accounts.name,
+      picture: accounts.picture,
+    }).from(accounts).where(
+      and(
+        ne(accounts.slug, ''),
+        or(like(accounts.slug, `%${q}%`), like(accounts.name, `%${q}%`)),
+      )
+    ).orderBy(asc(accounts.slug)).limit(limit).all(),
+    db.select({
+      id: repositories.id,
+      name: repositories.name,
+      description: repositories.description,
+      stars: repositories.stars,
+      updatedAt: repositories.updatedAt,
+      accountId: repositories.accountId,
+      accountSlug: accounts.slug,
+      accountName: accounts.name,
+      accountPicture: accounts.picture,
+    }).from(repositories)
+      .leftJoin(accounts, eq(repositories.accountId, accounts.id))
+      .where(
+        and(
+          eq(repositories.visibility, 'public'),
+          or(like(repositories.name, `%${q}%`), like(repositories.description, `%${q}%`)),
+        )
+      )
+      .orderBy(desc(repositories.stars), desc(repositories.updatedAt))
+      .limit(limit)
+      .all(),
+  ]);
+
+  return {
+    users: userRows
+      .filter((user) => !!user.slug)
+      .map((user) => ({
+        username: user.slug as string,
+        name: user.name,
+        avatar_url: user.picture,
+      })),
+    repos: repoRows.flatMap((repo) => {
+      const ownerSlug = repo.accountSlug || repo.accountId;
+      if (!ownerSlug) return [];
+      return [{
+        id: repo.id,
+        name: repo.name,
+        description: repo.description,
+        stars: repo.stars,
+        updated_at: repo.updatedAt,
+        owner: {
+          username: ownerSlug,
+          name: repo.accountName,
+          avatar_url: repo.accountPicture || null,
+        },
+      }];
+    }),
+  };
+}
+
+export async function loadReleasesWithAssets(
+  db: Database,
+  repoId: string,
+  opts: {
+    includePrerelease?: boolean;
+    limit?: number;
+  } = {},
+) {
+  const conditions = [
+    eq(repoReleases.repoId, repoId),
+    eq(repoReleases.isDraft, false),
+  ];
+  if (!opts.includePrerelease) {
+    conditions.push(eq(repoReleases.isPrerelease, false));
+  }
+
+  const releaseRows = await db
+    .select()
+    .from(repoReleases)
+    .where(and(...conditions))
+    .orderBy(desc(repoReleases.publishedAt))
+    .limit(opts.limit ?? 100)
+    .all();
+
+  const releaseIds = releaseRows.map((r) => r.id);
+  const allAssets =
+    releaseIds.length > 0
+      ? await db
+          .select()
+          .from(repoReleaseAssets)
+          .where(inArray(repoReleaseAssets.releaseId, releaseIds))
+          .orderBy(asc(repoReleaseAssets.createdAt))
+          .all()
+      : [];
+
+  const assetsByRelease = new Map<string, typeof allAssets>();
+  for (const asset of allAssets) {
+    const list = assetsByRelease.get(asset.releaseId) ?? [];
+    list.push(asset);
+    assetsByRelease.set(asset.releaseId, list);
+  }
+
+  return releaseRows.map((r) => ({
+    ...r,
+    repoReleaseAssets: assetsByRelease.get(r.id) ?? [],
+  }));
+}

package/src/server/routes/explore/index.ts

@@ -0,0 +1 @@
+export { default } from './routes';