dsh-edge 0.1.0

package/scripts/legal-files.mjs

@@ -0,0 +1,24 @@
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+
+const legalFiles = ['LICENSE', 'THIRD_PARTY_NOTICES.md']
+
+function paths(name) {
+  return {
+    source: fileURLToPath(new URL(`../../../${name}`, import.meta.url)),
+    target: fileURLToPath(new URL(`../${name}`, import.meta.url)),
+  }
+}
+
+function verify() {
+  for (const name of legalFiles) {
+    const { source, target } = paths(name)
+    if (!readFileSync(target).equals(readFileSync(source))) {
+      throw new Error(`${name} differs from the repository-root authority`)
+    }
+  }
+}
+
+const action = process.argv[2]
+if (action === 'verify') verify()
+else throw new Error('Usage: node scripts/legal-files.mjs verify')

package/scripts/verify-packed.mjs

@@ -0,0 +1,32 @@
+import { execFileSync } from 'node:child_process'
+import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { isAbsolute, join, resolve } from 'node:path'
+
+const input = process.argv[2]
+if (input === undefined) throw new Error('Usage: node scripts/verify-packed.mjs <tarball>')
+const tarball = isAbsolute(input) ? input : resolve(process.cwd(), input)
+const directory = mkdtempSync(join(tmpdir(), 'dsh-edge-packed-'))
+
+function run(command, args) {
+  execFileSync(command, args, { cwd: directory, stdio: 'inherit' })
+}
+
+try {
+  run('npm', ['install', '--ignore-scripts', '--no-audit', '--no-fund', tarball])
+  const packageDirectory = join(directory, 'node_modules', 'dsh-edge')
+  const license = join(packageDirectory, 'LICENSE')
+  const notices = join(packageDirectory, 'THIRD_PARTY_NOTICES.md')
+  if (!existsSync(license) || !readFileSync(license, 'utf8').startsWith('MIT License')) {
+    throw new Error('packed dsh-edge is missing its MIT license')
+  }
+  if (!existsSync(notices) || !readFileSync(notices, 'utf8').includes('# Third-Party Notices')) {
+    throw new Error('packed dsh-edge is missing third-party notices')
+  }
+  run(process.execPath, [join(packageDirectory, 'scripts', 'cli.mjs'), '--version'])
+  run(process.execPath, [join(packageDirectory, 'scripts', 'cli.mjs'), '--help'])
+  run(process.execPath, [join(packageDirectory, 'scripts', 'bundle.mjs'), 'direct'])
+  run(process.execPath, [join(packageDirectory, 'scripts', 'bundle.mjs'), 'isolated'])
+} finally {
+  rmSync(directory, { recursive: true, force: true })
+}

package/scripts/wrangler-config.d.mts

@@ -0,0 +1,18 @@
+import type { RuntimeMode } from './install.mjs'
+
+export interface WranglerConfigOptions {
+  appDirectory?: string
+  sourceConfigPath?: string
+}
+
+export function renderModeWranglerConfig(
+  mode: RuntimeMode,
+  source: string,
+  options?: WranglerConfigOptions,
+): string
+
+export function writeModeWranglerConfig(
+  mode: RuntimeMode,
+  destination: string,
+  options?: WranglerConfigOptions,
+): Promise<void>

package/scripts/wrangler-config.mjs

@@ -0,0 +1,84 @@
+import { readFile, writeFile } from 'node:fs/promises'
+import { resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { parse, printParseErrorCode } from 'jsonc-parser'
+
+const appDirectory = fileURLToPath(new URL('..', import.meta.url))
+const sourceConfigPath = fileURLToPath(new URL('../wrangler.jsonc', import.meta.url))
+const DIRECT_SHELL_CORE = '@cloudflare/computer/shell/core'
+const DIRECT_SHELL_CORE_REPLACEMENT = 'src/direct-shell-core-empty.ts'
+const ISOLATED_DIRECT_SHELL = './direct-shell.ts'
+const ISOLATED_DIRECT_SHELL_REPLACEMENT = 'src/isolated-direct-shell-unavailable.ts'
+const RESERVED_ALIASES = new Set([DIRECT_SHELL_CORE, ISOLATED_DIRECT_SHELL])
+
+/** Render one absolute-path Wrangler configuration from the repository source. */
+export function renderModeWranglerConfig(mode, source, options = {}) {
+  requireRuntimeMode(mode)
+  const root = options.appDirectory ?? appDirectory
+  const errors = []
+  const parsed = parse(source, errors, {
+    allowEmptyContent: false,
+    allowTrailingComma: true,
+    disallowComments: false,
+  })
+  if (errors.length > 0) {
+    const detail = errors.map(error => printParseErrorCode(error.error)).join(', ')
+    throw new Error(`Could not parse wrangler.jsonc: ${detail}.`)
+  }
+  if (!isRecord(parsed)) throw new Error('wrangler.jsonc must contain one object.')
+  if (typeof parsed.main !== 'string' || parsed.main === '') {
+    throw new Error('wrangler.jsonc must declare a main entry point.')
+  }
+  if (!isRecord(parsed.assets) || typeof parsed.assets.directory !== 'string'
+    || parsed.assets.directory === '') {
+    throw new Error('wrangler.jsonc must declare an assets directory.')
+  }
+  if (parsed.alias !== undefined && !isStringRecord(parsed.alias)) {
+    throw new Error('wrangler.jsonc aliases must map module names to paths.')
+  }
+  const reservedAlias = parsed.alias === undefined
+    ? undefined
+    : Object.keys(parsed.alias).find(alias => RESERVED_ALIASES.has(alias))
+  if (reservedAlias !== undefined) {
+    throw new Error(`wrangler.jsonc reserves the ${reservedAlias} alias for mode builds.`)
+  }
+
+  const config = structuredClone(parsed)
+  delete config.$schema
+  config.main = resolve(root, parsed.main)
+  config.assets.directory = resolve(root, parsed.assets.directory)
+  config.minify = true
+  if (mode === 'direct') {
+    config.alias = {
+      ...config.alias,
+      [DIRECT_SHELL_CORE]: resolve(root, DIRECT_SHELL_CORE_REPLACEMENT),
+    }
+  } else {
+    config.alias = {
+      ...config.alias,
+      [ISOLATED_DIRECT_SHELL]: resolve(root, ISOLATED_DIRECT_SHELL_REPLACEMENT),
+    }
+  }
+  return `${JSON.stringify(config, undefined, 2)}\n`
+}
+
+/** Write the private Wrangler configuration used by one installation attempt. */
+export async function writeModeWranglerConfig(mode, destination, options = {}) {
+  const source = await readFile(options.sourceConfigPath ?? sourceConfigPath, 'utf8')
+  const rendered = renderModeWranglerConfig(mode, source, options)
+  await writeFile(destination, rendered, { encoding: 'utf8', mode: 0o600, flag: 'wx' })
+}
+
+function requireRuntimeMode(mode) {
+  if (mode !== 'direct' && mode !== 'isolated') {
+    throw new Error(`Unsupported runtime mode: ${String(mode)}`)
+  }
+}
+
+function isRecord(value) {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function isStringRecord(value) {
+  return isRecord(value) && Object.values(value).every(entry => typeof entry === 'string')
+}

package/src/agent.ts

@@ -0,0 +1,119 @@
+/** Cloudflare-specific runtime bindings exposed through upstream DSH tool seams. */
+
+import type { SessionId } from '@deepseek-ai/dsh-session'
+import { defineTool, type ToolDefinition } from '@deepseek-ai/dsh-tools'
+import { EDGE_SHELL_OUTPUT_LIMIT_BYTES } from './direct-shell-protocol.ts'
+import type { EdgeExecutionId } from './protocol.ts'
+
+export const EDGE_SYSTEM_PROMPT = 'You are dsh-edge, a coding agent running in a Cloudflare Worker. '
+  + 'Your persistent working directory is /workspace. Use the bash tool when '
+  + 'you need to inspect or modify workspace files, then answer with the result. '
+  + 'The shell is just-bash, not Linux: native binaries and background processes are unavailable.'
+
+export interface EdgeShellResult {
+  executionId: EdgeExecutionId
+  status: 'completed' | 'failed' | 'cancelled'
+  timedOut: boolean
+  exitCode: number
+  stdout: string
+  stderr: string
+  outputTruncated: boolean
+}
+
+export interface EdgeShell {
+  exec(command: string, options: {
+    cwd: string
+    timeoutMs?: number
+    signal?: AbortSignal
+  }): Promise<EdgeShellResult>
+}
+
+/** Request-scoped Computer workspaces keyed by the upstream agent/session identity. */
+export class EdgeShellBindings {
+  private readonly shells = new Map<SessionId, EdgeShell>()
+
+  bind(sessionId: SessionId, shell: EdgeShell): () => void {
+    if (this.shells.has(sessionId)) {
+      throw new Error(`dsh-edge: shell is already bound for session "${sessionId}"`)
+    }
+    this.shells.set(sessionId, shell)
+    return () => {
+      if (this.shells.get(sessionId) === shell) this.shells.delete(sessionId)
+    }
+  }
+
+  require(sessionId: SessionId): EdgeShell {
+    const shell = this.shells.get(sessionId)
+    if (shell === undefined) {
+      throw new Error(`dsh-edge: no active Computer workspace for session "${sessionId}"`)
+    }
+    return shell
+  }
+}
+
+/** Native DSH tool definition whose body is the Cloudflare Computer adapter. */
+export function createEdgeBashTool(bindings: EdgeShellBindings): ToolDefinition {
+  return defineTool({
+    name: 'bash',
+    description: 'Execute a just-bash command against the persistent /workspace virtual filesystem. Each call starts in /workspace unless workdir is supplied.',
+    parameters: {
+      command: {
+        type: 'string',
+        required: true,
+        description: 'The shell command to execute.',
+      },
+      description: {
+        type: 'string',
+        required: true,
+        description: 'A short explanation of what the command does.',
+      },
+      workdir: {
+        type: 'string',
+        description: 'An absolute directory below /workspace.',
+      },
+      timeoutMs: {
+        type: 'number',
+        description: 'Optional execution timeout in milliseconds.',
+      },
+    },
+    output: {
+      schema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          executionId: { type: 'string', required: true },
+          status: {
+            type: 'string',
+            enum: ['completed', 'failed', 'cancelled'],
+            required: true,
+          },
+          timedOut: { type: 'boolean', required: true },
+          exitCode: { type: 'number', required: true },
+          stdout: { type: 'string', required: true },
+          stderr: { type: 'string', required: true },
+          outputTruncated: { type: 'boolean', required: true },
+        },
+      },
+      render: (_args, result) => [{ type: 'text', text: formatExecution(result) }],
+    },
+    async execute(args, exec) {
+      const agent = exec.agent
+      if (agent === undefined) throw new Error('dsh-edge: bash requires an initiating agent')
+      return bindings.require(agent.id).exec(args.command, {
+        cwd: args.workdir ?? '/workspace',
+        ...args.timeoutMs === undefined ? {} : { timeoutMs: args.timeoutMs },
+        signal: exec.signal,
+      })
+    },
+  })
+}
+
+function formatExecution(result: Omit<EdgeShellResult, 'executionId'>): string {
+  const output = `${result.stdout}${result.stderr}`
+  const truncated = result.outputTruncated
+    ? `\n[output truncated after ${EDGE_SHELL_OUTPUT_LIMIT_BYTES} UTF-8 bytes]`
+    : ''
+  const timedOut = result.timedOut ? '\n[command timed out]' : ''
+  const suffix = result.exitCode === 0 ? '' : `\n[exit code: ${result.exitCode}]`
+  return output + truncated + timedOut + suffix || '(no output)'
+}

package/src/auth.ts

@@ -0,0 +1,352 @@
+import {
+  EdgeHttpError,
+  readBoundedText,
+} from './http.ts'
+
+const LOCAL_COOKIE_NAME = 'dsh_edge_owner'
+const SECURE_COOKIE_NAME = '__Host-dsh_edge_owner'
+const COOKIE_VERSION = 'v1'
+const SESSION_TTL_SECONDS = 30 * 24 * 60 * 60
+const MAX_LOGIN_BODY_BYTES = 4_096
+const MIN_ACCESS_KEY_BYTES = 32
+const MAX_ACCESS_KEY_BYTES = 512
+const SESSION_SIGNING_CONTEXT = 'dsh-edge-owner-session\0'
+const OWNER_AUTH_CHALLENGE = 'DshEdgeOwner'
+const textEncoder = new TextEncoder()
+
+/** Trusted Worker-to-Durable-Object metadata; callers cannot select its value. */
+export const OWNER_SESSION_EXPIRY_HEADER = 'x-dsh-edge-owner-session-expires-at'
+
+/** Validated single-owner authentication configuration. */
+export interface OwnerAuthConfig {
+  accessKey: string
+}
+
+/** Claims recovered from a valid owner cookie. */
+export interface OwnerSession {
+  expiresAt: number
+}
+
+/** Fail closed unless the deployment has one suitably strong owner key. */
+export function resolveOwnerAuthConfig(accessKey: string | undefined): OwnerAuthConfig {
+  const byteLength = accessKey === undefined ? 0 : textEncoder.encode(accessKey).byteLength
+  if (accessKey === undefined
+    || byteLength < MIN_ACCESS_KEY_BYTES
+    || byteLength > MAX_ACCESS_KEY_BYTES
+    || accessKey.trim() !== accessKey
+    || /[\u0000-\u001f\u007f]/u.test(accessKey)) {
+    throw new EdgeHttpError(
+      503,
+      'Owner authentication is not configured safely. Set DSH_EDGE_ACCESS_KEY to a random value of at least 32 bytes.',
+    )
+  }
+  return { accessKey }
+}
+
+/** Handle the small login/session/logout surface owned by the Edge adapter. */
+export async function handleOwnerAuthRoute(
+  request: Request,
+  config: OwnerAuthConfig,
+): Promise<Response | undefined> {
+  const url = new URL(request.url)
+
+  if (request.method === 'GET' && url.pathname === '/login') {
+    return loginPageResponse(await isOwnerAuthenticated(request, config))
+  }
+
+  if (request.method === 'GET' && url.pathname === '/api/auth/session') {
+    return noStoreJson({ authenticated: await isOwnerAuthenticated(request, config) })
+  }
+
+  if (request.method === 'POST' && url.pathname === '/api/auth/login') {
+    requireSameOrigin(request)
+    const contentType = request.headers.get('content-type') ?? ''
+    if (!contentType.toLowerCase().startsWith('application/x-www-form-urlencoded')) {
+      throw new EdgeHttpError(415, 'Login requires a form-encoded request.')
+    }
+    const source = await readBoundedText(
+      request,
+      MAX_LOGIN_BODY_BYTES,
+      `Login requests are limited to ${MAX_LOGIN_BODY_BYTES} bytes.`,
+    )
+    const candidate = new URLSearchParams(source).get('accessKey') ?? ''
+    if (!await accessKeysMatch(candidate, config.accessKey)) {
+      return loginPageResponse(false, 'The access key is not valid.', 401)
+    }
+
+    const expiresAt = Math.floor(Date.now() / 1_000) + SESSION_TTL_SECONDS
+    const cookie = await createSessionCookie(config, expiresAt, url.protocol === 'https:')
+    return new Response(null, {
+      status: 303,
+      headers: {
+        'cache-control': 'no-store',
+        location: '/',
+        'set-cookie': cookie,
+      },
+    })
+  }
+
+  if (request.method === 'POST' && url.pathname === '/api/auth/logout') {
+    requireSameOrigin(request)
+    return new Response(null, {
+      status: 303,
+      headers: {
+        'cache-control': 'no-store',
+        location: '/login',
+        'set-cookie': expiredSessionCookie(url.protocol === 'https:'),
+      },
+    })
+  }
+
+  return undefined
+}
+
+/** Validate the opaque, signed owner session carried by an HttpOnly cookie. */
+export async function isOwnerAuthenticated(
+  request: Request,
+  config: OwnerAuthConfig,
+  nowSeconds = Math.floor(Date.now() / 1_000),
+): Promise<boolean> {
+  return await resolveOwnerSession(request, config, nowSeconds) !== undefined
+}
+
+/** Validate the owner cookie and expose its bounded lifetime to trusted adapters. */
+export async function resolveOwnerSession(
+  request: Request,
+  config: OwnerAuthConfig,
+  nowSeconds = Math.floor(Date.now() / 1_000),
+): Promise<OwnerSession | undefined> {
+  const secure = new URL(request.url).protocol === 'https:'
+  const cookies = readCookies(request.headers.get('cookie'), sessionCookieName(secure))
+  if (cookies.length === 0) return undefined
+
+  const key = await importSigningKey(config.accessKey)
+  for (const cookie of cookies) {
+    const parts = cookie.split('.')
+    const version = parts[0]
+    const expiresSource = parts[1]
+    const signatureSource = parts[2]
+    if (parts.length !== 3
+      || version !== COOKIE_VERSION
+      || expiresSource === undefined
+      || signatureSource === undefined
+      || !/^\d{10}$/u.test(expiresSource)) {
+      continue
+    }
+    const expiresAt = Number(expiresSource)
+    if (!Number.isSafeInteger(expiresAt) || expiresAt <= nowSeconds) continue
+    if (expiresAt > nowSeconds + SESSION_TTL_SECONDS) continue
+
+    const signature = decodeBase64Url(signatureSource)
+    if (signature === undefined) continue
+    const valid = await crypto.subtle.verify(
+      'HMAC',
+      key,
+      signature,
+      textEncoder.encode(`${SESSION_SIGNING_CONTEXT}${expiresSource}`),
+    )
+    if (valid) return { expiresAt }
+  }
+  return undefined
+}
+
+/** Redirect unauthenticated document requests to the local login shell. */
+export function loginRedirect(): Response {
+  return new Response(null, {
+    status: 302,
+    headers: {
+      'cache-control': 'no-store',
+      location: '/login',
+    },
+  })
+}
+
+/** Return a credential-safe API rejection. */
+export function unauthorizedResponse(): Response {
+  const response = noStoreJson({ ok: false, error: 'Owner authentication required.' }, 401)
+  response.headers.set('www-authenticate', OWNER_AUTH_CHALLENGE)
+  return response
+}
+
+async function createSessionCookie(
+  config: OwnerAuthConfig,
+  expiresAt: number,
+  secure: boolean,
+): Promise<string> {
+  const key = await importSigningKey(config.accessKey)
+  const signature = await crypto.subtle.sign(
+    'HMAC',
+    key,
+    textEncoder.encode(`${SESSION_SIGNING_CONTEXT}${String(expiresAt)}`),
+  )
+  const value = `${COOKIE_VERSION}.${String(expiresAt)}.${encodeBase64Url(signature)}`
+  const expires = new Date(expiresAt * 1_000).toUTCString()
+  return `${sessionCookieName(secure)}=${value}; Path=/; HttpOnly; SameSite=Strict; Max-Age=${String(SESSION_TTL_SECONDS)}; Expires=${expires}${secure ? '; Secure' : ''}`
+}
+
+function expiredSessionCookie(secure: boolean): string {
+  return `${sessionCookieName(secure)}=; Path=/; HttpOnly; SameSite=Strict; Max-Age=0; Expires=Thu, 01 Jan 1970 00:00:00 GMT${secure ? '; Secure' : ''}`
+}
+
+function sessionCookieName(secure: boolean): string {
+  return secure ? SECURE_COOKIE_NAME : LOCAL_COOKIE_NAME
+}
+
+async function accessKeysMatch(candidate: string, configured: string): Promise<boolean> {
+  const candidateBytes = textEncoder.encode(candidate)
+  if (candidateBytes.byteLength > MAX_ACCESS_KEY_BYTES) return false
+  const [candidateDigest, configuredDigest] = await Promise.all([
+    crypto.subtle.digest('SHA-256', candidateBytes),
+    crypto.subtle.digest('SHA-256', textEncoder.encode(configured)),
+  ])
+  const left = new Uint8Array(candidateDigest)
+  const right = new Uint8Array(configuredDigest)
+  let difference = candidateBytes.byteLength < MIN_ACCESS_KEY_BYTES ? 1 : 0
+  for (let index = 0; index < left.byteLength; index += 1) {
+    difference |= (left[index] ?? 0) ^ (right[index] ?? 0)
+  }
+  return difference === 0
+}
+
+async function importSigningKey(accessKey: string): Promise<CryptoKey> {
+  return crypto.subtle.importKey(
+    'raw',
+    textEncoder.encode(accessKey),
+    { name: 'HMAC', hash: 'SHA-256' },
+    false,
+    ['sign', 'verify'],
+  )
+}
+
+function requireSameOrigin(request: Request): void {
+  const fetchSite = request.headers.get('sec-fetch-site')
+  if (fetchSite === 'same-origin') return
+  if (fetchSite !== null) {
+    throw new EdgeHttpError(403, 'Cross-origin authentication requests are not allowed.')
+  }
+  const origin = request.headers.get('origin')
+  if (origin !== null && origin !== new URL(request.url).origin) {
+    throw new EdgeHttpError(403, 'Cross-origin authentication requests are not allowed.')
+  }
+}
+
+function readCookies(header: string | null, name: string): string[] {
+  if (header === null) return []
+  const values: string[] = []
+  for (const part of header.split(';')) {
+    const separator = part.indexOf('=')
+    if (separator === -1 || part.slice(0, separator).trim() !== name) continue
+    const value = part.slice(separator + 1).trim()
+    if (value.length > 0) values.push(value)
+  }
+  return values
+}
+
+function encodeBase64Url(value: ArrayBuffer): string {
+  let binary = ''
+  for (const byte of new Uint8Array(value)) binary += String.fromCharCode(byte)
+  return btoa(binary).replaceAll('+', '-').replaceAll('/', '_').replace(/=+$/u, '')
+}
+
+function decodeBase64Url(value: string): ArrayBuffer | undefined {
+  if (!/^[A-Za-z0-9_-]{43}$/u.test(value)) return undefined
+  try {
+    const base64 = value.replaceAll('-', '+').replaceAll('_', '/')
+    const binary = atob(`${base64}${'='.repeat((4 - base64.length % 4) % 4)}`)
+    const bytes = new Uint8Array(binary.length)
+    for (let index = 0; index < binary.length; index += 1) {
+      bytes[index] = binary.charCodeAt(index)
+    }
+    return bytes.buffer
+  } catch {
+    return undefined
+  }
+}
+
+function loginPageResponse(authenticated: boolean, error?: string, status = 200): Response {
+  const body = authenticated ? authenticatedPage() : loginPage(error)
+  return new Response(body, {
+    status,
+    headers: {
+      'cache-control': 'no-store',
+      'content-security-policy': "default-src 'none'; style-src 'unsafe-inline'; form-action 'self'; base-uri 'none'; frame-ancestors 'none'",
+      'content-type': 'text/html; charset=utf-8',
+      'referrer-policy': 'no-referrer',
+      'x-content-type-options': 'nosniff',
+    },
+  })
+}
+
+function noStoreJson(value: unknown, status = 200): Response {
+  return Response.json(value, {
+    status,
+    headers: {
+      'cache-control': 'no-store',
+      'content-type': 'application/json; charset=utf-8',
+    },
+  })
+}
+
+function loginPage(error?: string): string {
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>Unlock dsh-edge</title>
+  <style>${pageStyles()}</style>
+</head>
+<body>
+  <main>
+    <p class="eyebrow">dsh-edge</p>
+    <h1>Unlock this deployment</h1>
+    <p>Enter the owner access key configured for this Cloudflare deployment.</p>
+    ${error === undefined ? '' : `<p class="error" role="alert">${error}</p>`}
+    <form method="post" action="/api/auth/login">
+      <label for="access-key">Owner access key</label>
+      <input id="access-key" name="accessKey" type="password" autocomplete="current-password" required autofocus>
+      <button type="submit">Unlock</button>
+    </form>
+  </main>
+</body>
+</html>`
+}
+
+function authenticatedPage(): string {
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>dsh-edge owner session</title>
+  <style>${pageStyles()}</style>
+</head>
+<body>
+  <main>
+    <p class="eyebrow">dsh-edge</p>
+    <h1>This browser is unlocked</h1>
+    <p>The owner session is stored in an HttpOnly cookie on this device.</p>
+    <a class="button" href="/">Continue to DeepSeek Harness</a>
+    <form method="post" action="/api/auth/logout">
+      <button class="secondary" type="submit">Sign out</button>
+    </form>
+  </main>
+</body>
+</html>`
+}
+
+function pageStyles(): string {
+  return `
+    :root { color-scheme: light dark; font-family: ui-sans-serif, system-ui, sans-serif; }
+    body { min-height: 100vh; margin: 0; display: grid; place-items: center; background: #0b1020; color: #edf2ff; }
+    main { box-sizing: border-box; width: min(30rem, calc(100% - 2rem)); padding: 2rem; border: 1px solid #29314b; border-radius: 1rem; background: #141a2d; box-shadow: 0 1.5rem 5rem #0008; }
+    h1 { margin: .35rem 0 .75rem; font-size: 1.75rem; }
+    p { color: #b7c0d9; line-height: 1.55; }
+    .eyebrow { margin: 0; color: #7fa8ff; font-size: .8rem; font-weight: 700; letter-spacing: .12em; text-transform: uppercase; }
+    label { display: block; margin: 1.5rem 0 .5rem; font-weight: 650; }
+    input { box-sizing: border-box; width: 100%; padding: .8rem .9rem; border: 1px solid #3a4565; border-radius: .6rem; background: #0c1222; color: inherit; font: inherit; }
+    button, .button { display: inline-block; box-sizing: border-box; margin-top: 1rem; padding: .75rem 1rem; border: 0; border-radius: .6rem; background: #5a87ff; color: #071022; font: inherit; font-weight: 750; text-decoration: none; cursor: pointer; }
+    .secondary { background: #29314b; color: #edf2ff; }
+    .error { padding: .75rem; border-radius: .5rem; background: #461d2b; color: #ffd6df; }
+  `
+}