Skip to content

armgit / alook

Public Imported from GitHub
0

Multi-Agent Collaboration for Team and Friends

feat(web): add dormant native oauth server bridge (#720)

Genera85afca6cbbc
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 920637b73..fdbfd8ee6 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -27,7 +27,7 @@ on:
type: string
required: false
expected_class:
- description: Expected non-full classifier class (blog, package, or shared)
+ description: Expected non-full classifier class (auth, blog, package, or shared)
type: string
required: false
@@ -52,7 +52,9 @@ jobs:
full: ${{ steps.scope.outputs.full }}
base_sha: ${{ steps.scope.outputs.base_sha }}
head_sha: ${{ steps.scope.outputs.head_sha }}
+ auth_only: ${{ steps.scope.outputs.auth_only }}
blog_only: ${{ steps.scope.outputs.blog_only }}
+ run_auth_build: ${{ steps.scope.outputs.run_auth_build }}
run_blog_build: ${{ steps.scope.outputs.run_blog_build }}
run_code_checks: ${{ steps.scope.outputs.run_code_checks }}
run_static_checks: ${{ steps.scope.outputs.run_static_checks }}
@@ -128,6 +130,35 @@ jobs:
if-no-files-found: error
retention-days: 14
+ auth-build:
+ name: Auth Worker build
+ needs: scope
+ if: needs.scope.outputs.run_auth_build == 'true'
+ runs-on: ubuntu-latest
+ timeout-minutes: 10
+ steps:
+ - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
+ - name: Validate execution plan
+ env:
+ CI_EXECUTION_PLAN: ${{ needs.scope.outputs.execution_plan }}
+ CI_PLAN_HASH: ${{ needs.scope.outputs.plan_hash }}
+ CI_PROJECTION_NAME: run_auth_build
+ CI_PROJECTION_VALUE: ${{ needs.scope.outputs.run_auth_build }}
+ run: node scripts/ci/validate-execution-plan.mjs
+ - uses: pnpm/action-setup@0977fd99725f1db4007ccb2928dbb4e90d06cc86 # v6
+ - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 # v7
+ with:
+ node-version: 22
+ cache: pnpm
+ - uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
+ with:
+ path: .turbo/cache
+ key: turbo-${{ runner.os }}-${{ runner.arch }}-${{ github.job }}-${{ github.sha }}
+ restore-keys: |
+ turbo-${{ runner.os }}-${{ runner.arch }}-${{ github.job }}-
+ - run: pnpm install --frozen-lockfile
+ - run: pnpm --filter @alook/web build:auth
+
blog-build:
name: Blog build
needs: scope
@@ -311,7 +342,7 @@ jobs:
scripts/ci) projects=(ci-scripts) ;;
src/email-worker) projects=(email-worker-node email-worker-runtime) ;;
src/wake-worker) projects=(wake-worker-node wake-worker-runtime) ;;
- src/web) projects=(web-node web-runtime) ;;
+ src/web) projects=(web-node web-runtime auth-node auth-runtime) ;;
src/ws-do) projects=(ws-do-node ws-do-runtime) ;;
*) projects=("$(node -e 'console.log(require("./" + process.argv[1] + "/package.json").name)' "$root")") ;;
esac
@@ -751,6 +782,7 @@ jobs:
if: always()
needs:
- scope
+ - auth-build
- blog-build
- static-checks
- test-linux
@@ -765,6 +797,7 @@ jobs:
CI_GATE_RESULTS: >-
[
{"name":"scope","expected":true,"result":"${{ needs.scope.result }}"},
+ {"name":"auth-build","expected":${{ needs.scope.outputs.run_auth_build == 'true' }},"result":"${{ needs.auth-build.result }}"},
{"name":"blog-build","expected":${{ needs.scope.outputs.run_blog_build == 'true' }},"result":"${{ needs.blog-build.result }}"},
{"name":"static-checks","expected":${{ needs.scope.outputs.run_static_checks == 'true' }},"result":"${{ needs.static-checks.result }}"},
{"name":"test-linux","expected":${{ needs.scope.outputs.run_linux == 'true' }},"result":"${{ needs.test-linux.result }}"},
diff --git a/scripts/ci/changed-scopes.mjs b/scripts/ci/changed-scopes.mjs
index 78b629a4b..ec75b225e 100644
--- a/scripts/ci/changed-scopes.mjs
+++ b/scripts/ci/changed-scopes.mjs
@@ -12,6 +12,7 @@ import { createE2eMatrix, discoverE2eSpecs } from "./e2e-shards.mjs"
const ROOT = resolve(fileURLToPath(new URL("../..", import.meta.url)))
const MANIFEST_URL = new URL("./change-scope-manifest.json", import.meta.url)
const BLOG_ROOT = /^src\/web\/blog(?:\/|$)/
+const AUTH_ROOT = /^src\/web\/auth(?:\/|$)/
const BLOG_CONTENT = /^src\/web\/blog\/src\/content\/[^/]+\.mdx$/
const BLOG_ASSET = /^src\/web\/blog\/public\/blog(?:\/|$)/
const MARKDOWN = /(?:^|\/)\w[^/]*\.md$/i
@@ -28,6 +29,9 @@ const GLOBAL_PATHS = new Set([
const KNOWN_PREFIXES = [".claude/", ".openai/", "docs/"]
const COVERAGE_EXCLUDES = [
/(?:^|\/)\w[^/]*\.(?:test|spec)\.[cm]?[jt]sx?$/,
+ // Project/workspace configs execute before coverage instrumentation and are
+ // excluded by Vitest itself; their behavior is enforced by contract tests.
+ /(?:^|\/)vitest(?:\.[^/]+)?\.config\.[cm]?[jt]sx?$/,
/(?:^|\/)node_modules\//,
/(?:^|\/)(?:\.next|\.open-next|\.wrangler|dist|bundled|__mocks__)\//,
/(?:^|\/)test-runtime\//,
@@ -306,6 +310,7 @@ function fullReason(paths, { forceFull, fallbackReason }) {
function emptyJobs() {
return {
app_packed_artifact: false,
+ auth_build: false,
blog_build: false,
e2e: false,
lighthouse: false,
@@ -345,10 +350,11 @@ function requiredCoverageFiles(changes, coverageRoots) {
}))
}
-function planClass({ full, docsOnly, blogPathsOnly, direct }) {
+function planClass({ full, docsOnly, blogPathsOnly, authPathsOnly, direct }) {
if (full) return "full"
if (docsOnly) return "docs"
if (blogPathsOnly) return "blog"
+ if (authPathsOnly) return "auth"
if (direct.length === 1 && direct[0] === "@alook/shared") return "shared"
if (direct.length === 1) return "package"
return "mixed"
@@ -361,6 +367,7 @@ export function buildExecutionPlan(inputChanges, options = {}) {
const docsOnly = paths.length > 0 && paths.every(isMarkdown)
const blogContentOnly = paths.length > 0 && paths.every(isBlogContent)
const blogPathsOnly = paths.length > 0 && paths.every((path) => BLOG_ROOT.test(path))
+ const authPathsOnly = paths.length > 0 && paths.every((path) => AUTH_ROOT.test(path))
const unknown = paths.some((path) => !isKnownPath(path, manifest))
const reason = fullReason(paths, options) || (unknown ? "unknown_path" : null)
const full = reason !== null
@@ -394,6 +401,8 @@ export function buildExecutionPlan(inputChanges, options = {}) {
} else if (blogContentOnly || blogPathsOnly) {
uiSpecs = [...manifest.ui.contracts.blog]
suites.integration = blogPathsOnly && !blogContentOnly ? [] : suites.integration
+ } else if (authPathsOnly) {
+ suites.integration = []
} else if (affectedPackages.some((entry) => entry.ui)) {
uiSpecs = [manifest.ui.all]
}
@@ -404,15 +413,19 @@ export function buildExecutionPlan(inputChanges, options = {}) {
suites.linux = []
}
+ const authBuild = full || paths.some((path) => AUTH_ROOT.test(path))
const blogBuild = full || paths.some((path) => isBlogBuildInput(path, sharedInputs))
- const directWebRuntime = paths.some((path) => pathWithin(path, "src/web") && !BLOG_ROOT.test(path))
+ const directWebRuntime = paths.some((path) => (
+ pathWithin(path, "src/web") && !BLOG_ROOT.test(path) && !AUTH_ROOT.test(path)
+ ))
const lighthouse = full || (blogPathsOnly && !blogContentOnly) || directWebRuntime
const rust = full || affectedPackages.some((entry) => entry.rust)
const directPackages = direct.map((name) => byName.get(name))
- const appArtifact = full || (!blogPathsOnly && [...affectedPackages, ...directPackages]
+ const appArtifact = full || (!blogPathsOnly && !authPathsOnly && [...affectedPackages, ...directPackages]
.some((entry) => entry.app_artifact))
const requiredChangedFiles = requiredCoverageFiles(changes, coverage.include_roots)
+ jobs.auth_build = authBuild
jobs.blog_build = blogBuild
jobs.static_checks = suites.static.length > 0
jobs.test_linux = suites.unit.length > 0 || suites.linux.length > 0
@@ -432,10 +445,11 @@ export function buildExecutionPlan(inputChanges, options = {}) {
diagnostic_only: options.diagnosticOnly === true,
changes,
paths,
- change_class: planClass({ full, docsOnly, blogPathsOnly, direct }),
+ change_class: planClass({ full, docsOnly, blogPathsOnly, authPathsOnly, direct }),
full,
full_reason: reason,
docs_only: docsOnly && !full,
+ auth_only: authPathsOnly && !full,
blog_only: blogContentOnly && !full,
workflow_changed: paths.some((path) => WORKFLOW.test(path)),
packages: {
@@ -498,7 +512,9 @@ export function projectPlan(plan) {
full: String(plan.full),
base_sha: plan.base_sha,
head_sha: plan.head_sha,
+ auth_only: String(plan.auth_only),
blog_only: String(plan.blog_only),
+ run_auth_build: String(plan.jobs.auth_build),
run_blog_build: String(plan.jobs.blog_build),
run_code_checks: String(plan.jobs.static_checks || plan.jobs.test_linux),
run_static_checks: String(plan.jobs.static_checks),
diff --git a/scripts/ci/changed-scopes.test.ts b/scripts/ci/changed-scopes.test.ts
index a5aefe08f..51d8de5d2 100644
--- a/scripts/ci/changed-scopes.test.ts
+++ b/scripts/ci/changed-scopes.test.ts
@@ -133,6 +133,23 @@ describe("canonical execution plan", () => {
expect(result.jobs.blog_build).toBe(true)
})
+ it("routes the standalone auth Worker through Web checks and its own dry-run only", () => {
+ const result = plan(["src/web/auth/index.ts"])
+
+ expect(result.change_class).toBe("auth")
+ expect(result.auth_only).toBe(true)
+ expect(result.packages.direct).toEqual(["@alook/web"])
+ expect(result.packages.affected).toEqual(["@alook/web"])
+ expect(result.suites.static).toEqual(["@alook/web"])
+ expect(result.suites.unit).toEqual(["src/web"])
+ expect(result.suites.integration).toEqual([])
+ expect(result.ui.specs).toEqual([])
+ expect(result.jobs.auth_build).toBe(true)
+ expect(result.jobs.blog_build).toBe(false)
+ expect(result.jobs.lighthouse).toBe(false)
+ expect(result.jobs.app_packed_artifact).toBe(false)
+ })
+
it("selects only the CLI package and its explicit platform suites", () => {
const result = plan(["src/cli/src/commands/inbox.ts"])
@@ -263,6 +280,10 @@ describe("canonical execution plan", () => {
expect(JSON.parse(projection.static_packages)).toEqual(first.suites.static)
expect(JSON.parse(projection.integration_suites)).toEqual(first.suites.integration)
+ const auth = projectPlan(plan(["src/web/auth/wrangler.toml"]))
+ expect(auth.auth_only).toBe("true")
+ expect(auth.run_auth_build).toBe("true")
+
expect(() => validateExecutionPlan({ ...first, head_sha: sha("c") })).toThrow("hash")
})
@@ -311,7 +332,10 @@ describe("coverage name-status contract", () => {
"src/app/scripts/app-packed-artifact.mjs",
"src/cli/scripts/prepare-dist.mjs",
"src/shared/src/index.ts",
+ "src/web/auth/vitest.config.ts",
+ "src/web/vitest.config.ts",
"src/web/vitest.runtime.config.mts",
+ "src/web/vitest.workspace.config.ts",
]) {
expect(plan([path]).coverage.required_changed_files).toEqual([])
}
diff --git a/scripts/ci/characterization-guard.mjs b/scripts/ci/characterization-guard.mjs
index cd7990d74..51b5d4d16 100644
--- a/scripts/ci/characterization-guard.mjs
+++ b/scripts/ci/characterization-guard.mjs
@@ -11,7 +11,7 @@ import {
const ROOT = resolve(fileURLToPath(new URL("../..", import.meta.url)))
const FULL_SHA = /^[0-9a-f]{40}$/
-const CLASSES = new Set(["blog", "package", "shared"])
+const CLASSES = new Set(["auth", "blog", "package", "shared"])
export function validateCharacterization(input) {
const {
diff --git a/scripts/ci/characterization-guard.test.ts b/scripts/ci/characterization-guard.test.ts
index 7a15991df..b3443e4af 100644
--- a/scripts/ci/characterization-guard.test.ts
+++ b/scripts/ci/characterization-guard.test.ts
@@ -175,6 +175,7 @@ describe("validateCharacterization", () => {
describe("characterization guard CLI", () => {
it.each([
["package", "src/cli/src/commands/inbox.ts"],
+ ["auth", "src/web/auth/index.ts"],
["blog", "src/web/blog/src/lib/posts.ts"],
["shared", "src/shared/src/semver.ts"],
])("emits locked %s evidence from the full command path", (expectedClass, sourcePath) => {
diff --git a/scripts/ci/fixtures/d1-dynamic-bind-sites.json b/scripts/ci/fixtures/d1-dynamic-bind-sites.json
index 6101275c3..71f4252f3 100644
--- a/scripts/ci/fixtures/d1-dynamic-bind-sites.json
+++ b/scripts/ci/fixtures/d1-dynamic-bind-sites.json
@@ -527,6 +527,18 @@
"key": "src/shared/src/db/queries/meeting-session.ts:claimMeetingSessions:inArray:1",
"strategy": "json-set"
},
+ {
+ "key": "src/shared/src/db/queries/native-oauth.ts:cancelAttempt:inArray:1",
+ "strategy": "fixed-literal"
+ },
+ {
+ "key": "src/shared/src/db/queries/native-oauth.ts:registerAttempt:inArray:1",
+ "strategy": "fixed-literal"
+ },
+ {
+ "key": "src/shared/src/db/queries/native-oauth.ts:registerAttempt:inArray:2",
+ "strategy": "fixed-literal"
+ },
{
"key": "src/shared/src/db/queries/overview.ts:getConversationCountsByAgent:inArray:1",
"strategy": "json-set"
diff --git a/scripts/ci/workflow-contract.test.ts b/scripts/ci/workflow-contract.test.ts
index c1acaeec9..43d52b088 100644
--- a/scripts/ci/workflow-contract.test.ts
+++ b/scripts/ci/workflow-contract.test.ts
@@ -114,6 +114,34 @@ const iosProject = readFileSync(
resolve(import.meta.dirname, "../../src/desktop/src-tauri/gen/apple/project.yml"),
"utf8",
)
+const nativeOauthMainAasaRoute = readFileSync(
+ resolve(import.meta.dirname, "../../src/web/src/app/.well-known/apple-app-site-association/route.ts"),
+ "utf8",
+)
+const nativeOauthMainAssetLinksRoute = readFileSync(
+ resolve(import.meta.dirname, "../../src/web/src/app/.well-known/assetlinks.json/route.ts"),
+ "utf8",
+)
+const nativeOauthAuthWorker = readFileSync(
+ resolve(import.meta.dirname, "../../src/web/auth/index.ts"),
+ "utf8",
+)
+const nativeOauthAuthConfig = readFileSync(
+ resolve(import.meta.dirname, "../../src/web/auth/wrangler.toml"),
+ "utf8",
+)
+const nativeOauthWebConfig = readFileSync(
+ resolve(import.meta.dirname, "../../src/web/wrangler.toml"),
+ "utf8",
+)
+const nativeOauthContract = readFileSync(
+ resolve(import.meta.dirname, "../../src/web/src/lib/native-oauth.ts"),
+ "utf8",
+)
+const nativeOauthWebRuntime = readFileSync(
+ resolve(import.meta.dirname, "../../src/web/src/lib/worker-runtime.ts"),
+ "utf8",
+)
const desktopEntitlementsPath = resolve(
import.meta.dirname,
"../../src/desktop/src-tauri/entitlements.plist",
@@ -320,7 +348,7 @@ describe("CI workflow graph", () => {
expect(scope).toContain("--plan-file .ci/execution-plan.json")
expect(scope).toContain("name: execution-plan-${{ github.run_id }}-${{ github.run_attempt }}")
for (const job of [
- "blog-build", "static-checks", "test-linux", "test-windows", "app-packed-artifact",
+ "auth-build", "blog-build", "static-checks", "test-linux", "test-windows", "app-packed-artifact",
"e2e", "desktop-rust", "lighthouse", "e2e-ui", "merge-reports", "ci-gate", "ui-e2e-gate",
]) {
const definition = ciJob(job)
@@ -376,7 +404,7 @@ describe("CI workflow graph", () => {
it("gates the consolidated jobs under the stable CI Gate", () => {
const gate = ciJob("ci-gate")
- for (const job of ["static-checks", "test-linux", "test-windows", "app-packed-artifact"]) {
+ for (const job of ["auth-build", "static-checks", "test-linux", "test-windows", "app-packed-artifact"]) {
expect(gate).toContain(`- ${job}`)
expect(gate).toContain(`"name":"${job}"`)
}
@@ -632,7 +660,7 @@ describe("Native message external-link opener", () => {
})
describe("Turbo CI execution", () => {
- const cachedJobs = ["blog-build", "static-checks", "test-linux", "test-windows"]
+ const cachedJobs = ["auth-build", "blog-build", "static-checks", "test-linux", "test-windows"]
it("persists a task cache isolated by operating system, architecture, and job", () => {
expect(ciWorkflow.match(/actions\/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9/g))
@@ -715,8 +743,9 @@ describe("Turbo CI execution", () => {
expect(module.packageJson.scripts.test).toBe("vitest run --config vitest.workspace.config.ts")
expect(module.packageJson.scripts).not.toHaveProperty("test:workers")
expect(module.packageJson.devDependencies["@cloudflare/vitest-plugin"]).toBe("1.0.0")
- expect(module.workspaceConfig.match(/vitest\.config\.ts/g)).toHaveLength(1)
- expect(module.workspaceConfig.match(/vitest\.runtime\.config\.mts/g)).toHaveLength(1)
+ const expectedProjects = module.name === "web" ? 2 : 1
+ expect(module.workspaceConfig.match(/vitest\.config\.ts/g)).toHaveLength(expectedProjects)
+ expect(module.workspaceConfig.match(/vitest\.runtime\.config\.mts/g)).toHaveLength(expectedProjects)
const nodeProject = `${module.name}-node`
const runtimeProject = `${module.name}-runtime`
@@ -728,7 +757,7 @@ describe("Turbo CI execution", () => {
projectNames.push(nodeProject, runtimeProject)
}
expect(new Set(projectNames).size).toBe(projectNames.length)
- expect(ciJob("test-linux")).toContain("projects=(web-node web-runtime)")
+ expect(ciJob("test-linux")).toContain("projects=(web-node web-runtime auth-node auth-runtime)")
})
it("collects Node and workerd projects in one Istanbul report", () => {
@@ -741,6 +770,8 @@ describe("Turbo CI execution", () => {
for (const project of [
"src/shared",
"src/web",
+ "src/web/auth/vitest.config.ts",
+ "src/web/auth/vitest.runtime.config.mts",
"src/cli",
"src/daemon",
"src/daemon/agent-driver",
@@ -781,7 +812,7 @@ describe("Turbo CI execution", () => {
"projects=(ci-scripts)",
"projects=(email-worker-node email-worker-runtime)",
"projects=(wake-worker-node wake-worker-runtime)",
- "projects=(web-node web-runtime)",
+ "projects=(web-node web-runtime auth-node auth-runtime)",
"projects=(ws-do-node ws-do-runtime)",
]) expect(linux).toContain(projects)
expect(linux).toContain('project_args+=("--project=$project")')
@@ -1071,3 +1102,64 @@ describe("Mobile release availability", () => {
expect(mobileReleaseWorkflow).not.toContain("Google Play")
})
})
+
+describe("Native OAuth association contract", () => {
+ it("keeps the return domain, mobile identities, and standalone Worker route aligned", () => {
+ expect(nativeOauthContract).toContain(
+ 'NATIVE_OAUTH_RETURN_ORIGIN = "https://auth.alook.ai"',
+ )
+ expect(nativeOauthContract).toContain(
+ 'NATIVE_OAUTH_RETURN_PATH = "/auth/native/return"',
+ )
+ expect(nativeOauthAuthWorker).toContain('AUTH_WORKER_HOST = "auth.alook.ai"')
+ expect(nativeOauthAuthWorker).toContain('AUTH_WORKER_RETURN_PATH = "/auth/native/return"')
+ expect(nativeOauthAuthConfig).toContain('name = "alook-auth"')
+ expect(nativeOauthAuthConfig).toMatch(
+ /\[\[routes\]\][\s\S]*pattern = "auth\.alook\.ai"[\s\S]*custom_domain = true/,
+ )
+ expect(nativeOauthWebConfig).not.toContain("auth.alook.ai")
+ expect(nativeOauthWebRuntime).not.toContain("auth.alook.ai")
+
+ expect(desktopIosConfig.identifier).toBe("ai.alook.ios")
+ expect(iosProject).toContain("DEVELOPMENT_TEAM: 5RF24VHDQB")
+ expect(nativeOauthAuthWorker).toContain("5RF24VHDQB.ai.alook.ios")
+ expect(nativeOauthAuthWorker).toContain('"/": AUTH_WORKER_RETURN_PATH')
+
+ expect(desktopAndroidConfig.identifier).toBe("ai.alook.android")
+ expect(nativeOauthAuthWorker).toContain('package_name: "ai.alook.android"')
+ expect(nativeOauthAuthWorker).toContain(
+ "9D:C6:ED:E9:4B:A6:63:EE:C9:EC:98:FF:7B:AF:D5:5E:24:8B:6C:4B:C2:15:7F:CF:04:2D:F5:9B:0E:41:08:06",
+ )
+ })
+
+ it("restores the main Web association behavior and excludes the auth host from OpenNext", () => {
+ expect(nativeOauthMainAasaRoute).toContain('appIDs: ["TEAM_ID.ai.alook.app"]')
+ expect(nativeOauthMainAasaRoute).toContain('paths: ["*"]')
+ expect(nativeOauthMainAssetLinksRoute).toContain('package_name: "ai.alook.app"')
+ expect(nativeOauthMainAssetLinksRoute).toContain('sha256_cert_fingerprints: ["__PLACEHOLDER__"]')
+ expect(nativeOauthWebConfig).not.toContain('pattern = "auth.alook.ai"')
+ expect(nativeOauthWebRuntime).not.toContain("NATIVE_OAUTH")
+ })
+
+ it("keeps the auth Worker telemetry-free, binding-free, and in its own CI dry-run", () => {
+ expect(nativeOauthAuthConfig).toMatch(/\[observability\]\nenabled = false\nhead_sampling_rate = 0/)
+ expect(nativeOauthAuthConfig).toMatch(/\[observability\.logs\]\nenabled = false\ninvocation_logs = false/)
+ expect(nativeOauthAuthConfig).toMatch(/\[observability\.traces\]\nenabled = false\nhead_sampling_rate = 0/)
+ expect(nativeOauthAuthConfig).not.toMatch(/\[(?:assets|vars|d1_databases|r2_buckets|kv_namespaces|services|queues|durable_objects)/)
+ expect(nativeOauthAuthWorker).not.toMatch(/(?:console\.|@opennextjs|next\/server|cloudflare:workers)/)
+
+ const authBuild = ciJob("auth-build")
+ expect(authBuild).toContain("if: needs.scope.outputs.run_auth_build == 'true'")
+ expect(authBuild).toContain("CI_PROJECTION_NAME: run_auth_build")
+ expect(authBuild).toContain("pnpm --filter @alook/web build:auth")
+ expect(authBuild).not.toContain("deploy:auth")
+ expect(directWorkerModules[3].packageJson.scripts["build:auth"])
+ .toContain("wrangler deploy --dry-run --config auth/wrangler.toml")
+ expect(directWorkerModules[3].packageJson.scripts["build:auth"])
+ .toContain("--outdir dist")
+ expect(directWorkerModules[3].packageJson.scripts["build:auth"])
+ .not.toContain("--outdir auth/dist")
+ expect(directWorkerModules[3].workspaceConfig).toContain("./auth/vitest.config.ts")
+ expect(directWorkerModules[3].workspaceConfig).toContain("./auth/vitest.runtime.config.mts")
+ })
+})
diff --git a/src/shared/src/db/queries-index.test.ts b/src/shared/src/db/queries-index.test.ts
new file mode 100644
index 000000000..e6a8b30d4
--- /dev/null
+++ b/src/shared/src/db/queries-index.test.ts
@@ -0,0 +1,12 @@
+import { describe, expect, it } from "vitest";
+import * as queries from "./queries-index";
+import * as nativeOauth from "./queries/native-oauth";
+
+describe("query barrel", () => {
+ it("exposes the canonical native OAuth query module", () => {
+ expect(queries.nativeOauth.registerAttempt).toBe(nativeOauth.registerAttempt);
+ expect(queries.nativeOauth.claimExchange).toBe(nativeOauth.claimExchange);
+ expect(queries.nativeOauth.finishExchange).toBe(nativeOauth.finishExchange);
+ expect(queries.nativeOauth.getAttemptStatus).toBe(nativeOauth.getAttemptStatus);
+ });
+});
diff --git a/src/shared/src/db/queries-index.ts b/src/shared/src/db/queries-index.ts
index e14b07e4c..50cc553ec 100644
--- a/src/shared/src/db/queries-index.ts
+++ b/src/shared/src/db/queries-index.ts
@@ -1,3 +1,5 @@
+import * as nativeOauthQueries from "./queries/native-oauth";
+
export * as user from "./queries/user";
export * as workspace from "./queries/workspace";
export * as member from "./queries/member";
@@ -62,3 +64,4 @@ export * as communityAgentInbox from "./queries/community/agent-inbox";
export * as communityBotAuditLog from "./queries/community/bot-audit-log";
export * as communityMessageTag from "./queries/community/message-tag";
export * as communityDiagnosticReport from "./queries/community/diagnostic-report";
+export const nativeOauth = nativeOauthQueries;
diff --git a/src/shared/src/db/queries/native-oauth.test.ts b/src/shared/src/db/queries/native-oauth.test.ts
new file mode 100644
index 000000000..062cc9e87
--- /dev/null
+++ b/src/shared/src/db/queries/native-oauth.test.ts
@@ -0,0 +1,332 @@
+import Sqlite from "better-sqlite3";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import * as schema from "../schema";
+import type { Database } from "../index";
+import {
+ attachHandoff,
+ cancelAttempt,
+ claimExchange,
+ claimStart,
+ failExchange,
+ failOpenedAttempt,
+ finishExchange,
+ getAttemptStatus,
+ getOpenedAttempt,
+ registerAttempt,
+} from "./native-oauth";
+
+const migrationPath = resolve(
+ import.meta.dirname,
+ "../../../../web/migrations/0095_native_oauth_attempt.sql",
+);
+
+const NOW = 1_788_531_200_000;
+const STATE_HASH = "a".repeat(64);
+const INSTANCE_HASH = "b".repeat(64);
+const CHALLENGE = "c".repeat(43);
+const CODE_HASH = "d".repeat(64);
+
+type BatchStatement = { all(): unknown; run(): unknown };
+
+function createTestDb(sqlite: Sqlite.Database): Database {
+ const db = drizzle(sqlite, { schema });
+ Object.assign(db, {
+ batch: async (statements: BatchStatement[]) =>
+ sqlite.transaction(() =>
+ statements.map((statement, index) =>
+ index === statements.length - 1 ? statement.all() : statement.run(),
+ ),
+ )(),
+ });
+ return db as unknown as Database;
+}
+
+function registration(id: string, instanceKeyHash = INSTANCE_HASH) {
+ return {
+ id,
+ instanceKeyHash,
+ stateHash: STATE_HASH,
+ pkceChallenge: CHALLENGE,
+ provider: "github" as const,
+ platform: "macos" as const,
+ redirectPath: "/c/me",
+ };
+}
+
+describe("native oauth attempt queries", () => {
+ let sqlite: Sqlite.Database;
+ let db: Database;
+
+ beforeEach(() => {
+ sqlite = new Sqlite(":memory:");
+ sqlite.exec(readFileSync(migrationPath, "utf8"));
+ db = createTestDb(sqlite);
+ });
+
+ afterEach(() => sqlite.close());
+
+ it("atomically replaces the prior live attempt for an installation", async () => {
+ const oldId = "old_attempt_123456789012";
+ const newId = "new_attempt_123456789012";
+ await registerAttempt(db, registration(oldId), NOW);
+ await registerAttempt(db, registration(newId), NOW + 1);
+
+ expect(sqlite.prepare(
+ "SELECT id, status FROM native_oauth_attempt ORDER BY created_at",
+ ).all()).toEqual([
+ { id: oldId, status: "replaced" },
+ { id: newId, status: "pending" },
+ ]);
+ });
+
+ it("fails closed when registration does not return the inserted row", async () => {
+ const statement = {
+ where: vi.fn(() => statement),
+ set: vi.fn(() => statement),
+ values: vi.fn(() => statement),
+ returning: vi.fn(() => statement),
+ };
+ const emptyDb = {
+ delete: vi.fn(() => statement),
+ update: vi.fn(() => statement),
+ insert: vi.fn(() => statement),
+ batch: vi.fn(async () => [[], [], []]),
+ } as unknown as Database;
+
+ await expect(
+ registerAttempt(
+ emptyDb,
+ registration("missing_attempt_123456789"),
+ NOW,
+ ),
+ ).rejects.toThrow("native oauth registration did not return a row");
+ });
+
+ it("reads and fails only a live opened attempt", async () => {
+ const id = "opened_attempt_1234567890";
+ await registerAttempt(db, registration(id), NOW);
+ await claimStart(db, id, NOW + 1);
+
+ await expect(getOpenedAttempt(db, id, NOW + 2)).resolves.toMatchObject({
+ id,
+ status: "opened",
+ });
+ await expect(
+ failOpenedAttempt(db, id, "provider_error", NOW + 3),
+ ).resolves.toMatchObject({ status: "failed", failureCode: "provider_error" });
+ await expect(getOpenedAttempt(db, id, NOW + 4)).resolves.toBeNull();
+ await expect(
+ failOpenedAttempt(db, id, "provider_error", NOW + 4),
+ ).resolves.toBeNull();
+ });
+
+ it("does not mutate ready state for a wrong handoff hash", async () => {
+ const id = "exchange_attempt_12345678";
+ await registerAttempt(db, registration(id), NOW);
+ await claimStart(db, id, NOW + 1);
+ await attachHandoff(db, {
+ attemptId: id,
+ handoffCodeHash: CODE_HASH,
+ authKind: "signin",
+ }, NOW + 2);
+
+ await expect(claimExchange(db, {
+ attemptId: id,
+ stateHash: STATE_HASH,
+ pkceChallenge: CHALLENGE,
+ handoffCodeHash: "e".repeat(64),
+ }, NOW + 3)).resolves.toBeNull();
+ expect(sqlite.prepare(
+ "SELECT status, updated_at FROM native_oauth_attempt WHERE id = ?",
+ ).get(id)).toEqual({ status: "ready", updated_at: NOW + 2 });
+ });
+
+ it("claims and consumes a handoff exactly once", async () => {
+ const id = "replay_attempt_1234567890";
+ await registerAttempt(db, registration(id), NOW);
+ await claimStart(db, id, NOW + 1);
+ await attachHandoff(db, {
+ attemptId: id,
+ handoffCodeHash: CODE_HASH,
+ authKind: "signin",
+ }, NOW + 2);
+ const proof = {
+ attemptId: id,
+ stateHash: STATE_HASH,
+ pkceChallenge: CHALLENGE,
+ handoffCodeHash: CODE_HASH,
+ };
+
+ await expect(claimExchange(db, proof, NOW + 3)).resolves.toMatchObject({
+ status: "exchanging",
+ });
+ await expect(claimExchange(db, proof, NOW + 3)).resolves.toBeNull();
+ await expect(finishExchange(db, proof, NOW + 4)).resolves.toMatchObject({
+ status: "consumed",
+ });
+ await expect(finishExchange(db, proof, NOW + 4)).resolves.toBeNull();
+ });
+
+ it("fails only a claimed exchange", async () => {
+ const id = "failed_exchange_123456789";
+ await registerAttempt(db, registration(id), NOW);
+ await claimStart(db, id, NOW + 1);
+ await attachHandoff(db, {
+ attemptId: id,
+ handoffCodeHash: CODE_HASH,
+ authKind: "signin",
+ }, NOW + 2);
+ await claimExchange(db, {
+ attemptId: id,
+ stateHash: STATE_HASH,
+ pkceChallenge: CHALLENGE,
+ handoffCodeHash: CODE_HASH,
+ }, NOW + 3);
+
+ await expect(failExchange(db, id, NOW + 4)).resolves.toMatchObject({
+ status: "failed",
+ failureCode: "invalid_handoff",
+ });
+ await expect(failExchange(db, id, NOW + 5)).resolves.toBeNull();
+ });
+
+ it("rejects expired starts and handoffs that cannot retain a full two minutes", async () => {
+ const expiredId = "expired_attempt_123456789";
+ await registerAttempt(db, registration(expiredId), NOW);
+ await expect(
+ claimStart(db, expiredId, NOW + 10 * 60 * 1000),
+ ).resolves.toBeNull();
+
+ const shortId = "short_attempt_12345678901";
+ await registerAttempt(db, registration(shortId, "f".repeat(64)), NOW);
+ await claimStart(db, shortId, NOW + 1);
+ await expect(attachHandoff(db, {
+ attemptId: shortId,
+ handoffCodeHash: CODE_HASH,
+ authKind: "signin",
+ }, NOW + 8 * 60 * 1000 + 1)).resolves.toBeNull();
+ await expect(getAttemptStatus(db, {
+ attemptId: shortId,
+ stateHash: STATE_HASH,
+ pkceChallenge: CHALLENGE,
+ })).resolves.toMatchObject({ status: "opened" });
+ });
+
+ it("lets cancellation beat a claimed exchange and withholds consumption", async () => {
+ const id = "cancel_attempt_1234567890";
+ await registerAttempt(db, registration(id), NOW);
+ await claimStart(db, id, NOW + 1);
+ await attachHandoff(db, {
+ attemptId: id,
+ handoffCodeHash: CODE_HASH,
+ authKind: "signup",
+ }, NOW + 2);
+ await claimExchange(db, {
+ attemptId: id,
+ stateHash: STATE_HASH,
+ pkceChallenge: CHALLENGE,
+ handoffCodeHash: CODE_HASH,
+ }, NOW + 3);
+
+ await expect(cancelAttempt(db, {
+ attemptId: id,
+ stateHash: STATE_HASH,
+ pkceChallenge: CHALLENGE,
+ }, NOW + 4)).resolves.toMatchObject({ status: "cancelled" });
+ await expect(finishExchange(db, {
+ attemptId: id,
+ stateHash: STATE_HASH,
+ pkceChallenge: CHALLENGE,
+ handoffCodeHash: CODE_HASH,
+ }, NOW + 5)).resolves.toBeNull();
+ });
+
+ it("rejects stale proof after a newer registration", async () => {
+ const oldId = "stale_attempt_12345678901";
+ const newId = "fresh_attempt_12345678901";
+ await registerAttempt(db, registration(oldId), NOW);
+ await registerAttempt(db, registration(newId), NOW + 1);
+
+ await expect(cancelAttempt(db, {
+ attemptId: oldId,
+ stateHash: STATE_HASH,
+ pkceChallenge: CHALLENGE,
+ }, NOW + 2)).resolves.toBeNull();
+ await expect(getAttemptStatus(db, {
+ attemptId: newId,
+ stateHash: STATE_HASH,
+ pkceChallenge: CHALLENGE,
+ })).resolves.toMatchObject({ status: "pending" });
+ });
+
+ it("uses the current time when timestamp arguments are omitted", async () => {
+ const dateNow = vi.spyOn(Date, "now").mockReturnValue(NOW);
+
+ try {
+ const consumedId = "default_consumed_123456789";
+ await registerAttempt(db, registration(consumedId, "1".repeat(64)));
+ await expect(claimStart(db, consumedId)).resolves.toMatchObject({
+ status: "opened",
+ });
+ await expect(getOpenedAttempt(db, consumedId)).resolves.toMatchObject({
+ status: "opened",
+ });
+ await expect(attachHandoff(db, {
+ attemptId: consumedId,
+ handoffCodeHash: CODE_HASH,
+ authKind: "signin",
+ })).resolves.toMatchObject({ status: "ready" });
+ const consumedProof = {
+ attemptId: consumedId,
+ stateHash: STATE_HASH,
+ pkceChallenge: CHALLENGE,
+ handoffCodeHash: CODE_HASH,
+ };
+ await expect(claimExchange(db, consumedProof)).resolves.toMatchObject({
+ status: "exchanging",
+ });
+ await expect(finishExchange(db, consumedProof)).resolves.toMatchObject({
+ status: "consumed",
+ });
+
+ const openedId = "default_opened_12345678901";
+ await registerAttempt(db, registration(openedId, "2".repeat(64)));
+ await claimStart(db, openedId);
+ await expect(
+ failOpenedAttempt(db, openedId, "provider_error"),
+ ).resolves.toMatchObject({ status: "failed" });
+
+ const exchangeId = "default_exchange_123456789";
+ const exchangeCodeHash = "e".repeat(64);
+ await registerAttempt(db, registration(exchangeId, "3".repeat(64)));
+ await claimStart(db, exchangeId);
+ await attachHandoff(db, {
+ attemptId: exchangeId,
+ handoffCodeHash: exchangeCodeHash,
+ authKind: "signin",
+ });
+ await claimExchange(db, {
+ attemptId: exchangeId,
+ stateHash: STATE_HASH,
+ pkceChallenge: CHALLENGE,
+ handoffCodeHash: exchangeCodeHash,
+ });
+ await expect(failExchange(db, exchangeId)).resolves.toMatchObject({
+ status: "failed",
+ });
+
+ const cancelledId = "default_cancelled_123456789";
+ await registerAttempt(db, registration(cancelledId, "4".repeat(64)));
+ await expect(cancelAttempt(db, {
+ attemptId: cancelledId,
+ stateHash: STATE_HASH,
+ pkceChallenge: CHALLENGE,
+ })).resolves.toMatchObject({ status: "cancelled" });
+ } finally {
+ dateNow.mockRestore();
+ }
+ });
+});
diff --git a/src/shared/src/db/queries/native-oauth.ts b/src/shared/src/db/queries/native-oauth.ts
new file mode 100644
index 000000000..80f3e1b7d
--- /dev/null
+++ b/src/shared/src/db/queries/native-oauth.ts
@@ -0,0 +1,305 @@
+import { and, eq, gt, inArray, lt, or } from "drizzle-orm";
+import {
+ nativeOauthAttempt,
+ type NativeOauthFailureCode,
+ type NativeOauthPlatform,
+ type NativeOauthProvider,
+} from "../schema";
+import type { Database } from "../index";
+
+const ATTEMPT_TTL_MS = 10 * 60 * 1000;
+const HANDOFF_TTL_MS = 2 * 60 * 1000;
+const RETENTION_MS = 24 * 60 * 60 * 1000;
+
+export type NativeOauthAttempt = typeof nativeOauthAttempt.$inferSelect;
+
+export type NativeOauthRegistration = {
+ id: string;
+ instanceKeyHash: string;
+ stateHash: string;
+ pkceChallenge: string;
+ provider: NativeOauthProvider;
+ platform: NativeOauthPlatform;
+ redirectPath: string;
+};
+
+export async function registerAttempt(
+ db: Database,
+ data: NativeOauthRegistration,
+ now = Date.now(),
+): Promise<NativeOauthAttempt> {
+ const cleanupBefore = now - RETENTION_MS;
+ const cleanup = db
+ .delete(nativeOauthAttempt)
+ .where(
+ or(
+ and(
+ inArray(nativeOauthAttempt.status, [
+ "consumed",
+ "failed",
+ "cancelled",
+ "replaced",
+ ]),
+ lt(nativeOauthAttempt.updatedAt, cleanupBefore),
+ ),
+ lt(nativeOauthAttempt.attemptExpiresAt, cleanupBefore),
+ ),
+ );
+ const replace = db
+ .update(nativeOauthAttempt)
+ .set({ status: "replaced", replacedAt: now, updatedAt: now })
+ .where(
+ and(
+ eq(nativeOauthAttempt.instanceKeyHash, data.instanceKeyHash),
+ inArray(nativeOauthAttempt.status, [
+ "pending",
+ "opened",
+ "ready",
+ "exchanging",
+ ]),
+ ),
+ );
+ const insert = db
+ .insert(nativeOauthAttempt)
+ .values({
+ ...data,
+ status: "pending",
+ attemptExpiresAt: now + ATTEMPT_TTL_MS,
+ createdAt: now,
+ updatedAt: now,
+ })
+ .returning();
+
+ const results = await db.batch([cleanup, replace, insert]);
+ const rows = results[2] as NativeOauthAttempt[];
+ const row = rows[0];
+ if (!row) throw new Error("native oauth registration did not return a row");
+ return row;
+}
+
+export async function claimStart(
+ db: Database,
+ attemptId: string,
+ now = Date.now(),
+): Promise<NativeOauthAttempt | null> {
+ const rows = await db
+ .update(nativeOauthAttempt)
+ .set({ status: "opened", openedAt: now, updatedAt: now })
+ .where(
+ and(
+ eq(nativeOauthAttempt.id, attemptId),
+ eq(nativeOauthAttempt.status, "pending"),
+ gt(nativeOauthAttempt.attemptExpiresAt, now),
+ ),
+ )
+ .returning();
+ return rows[0] ?? null;
+}
+
+export async function getOpenedAttempt(
+ db: Database,
+ attemptId: string,
+ now = Date.now(),
+): Promise<NativeOauthAttempt | null> {
+ const rows = await db
+ .select()
+ .from(nativeOauthAttempt)
+ .where(
+ and(
+ eq(nativeOauthAttempt.id, attemptId),
+ eq(nativeOauthAttempt.status, "opened"),
+ gt(nativeOauthAttempt.attemptExpiresAt, now),
+ ),
+ )
+ .limit(1);
+ return rows[0] ?? null;
+}
+
+export async function attachHandoff(
+ db: Database,
+ data: {
+ attemptId: string;
+ handoffCodeHash: string;
+ authKind: "signin" | "signup";
+ },
+ now = Date.now(),
+): Promise<NativeOauthAttempt | null> {
+ const rows = await db
+ .update(nativeOauthAttempt)
+ .set({
+ status: "ready",
+ handoffCodeHash: data.handoffCodeHash,
+ handoffExpiresAt: now + HANDOFF_TTL_MS,
+ authKind: data.authKind,
+ readyAt: now,
+ updatedAt: now,
+ })
+ .where(
+ and(
+ eq(nativeOauthAttempt.id, data.attemptId),
+ eq(nativeOauthAttempt.status, "opened"),
+ gt(nativeOauthAttempt.attemptExpiresAt, now + HANDOFF_TTL_MS),
+ ),
+ )
+ .returning();
+ return rows[0] ?? null;
+}
+
+export async function failOpenedAttempt(
+ db: Database,
+ attemptId: string,
+ failureCode: Extract<
+ NativeOauthFailureCode,
+ "access_denied" | "provider_error" | "oauth_callback_failed" | "start_failed"
+ >,
+ now = Date.now(),
+): Promise<NativeOauthAttempt | null> {
+ const rows = await db
+ .update(nativeOauthAttempt)
+ .set({ status: "failed", failureCode, failedAt: now, updatedAt: now })
+ .where(
+ and(
+ eq(nativeOauthAttempt.id, attemptId),
+ eq(nativeOauthAttempt.status, "opened"),
+ ),
+ )
+ .returning();
+ return rows[0] ?? null;
+}
+
+export async function claimExchange(
+ db: Database,
+ data: {
+ attemptId: string;
+ stateHash: string;
+ pkceChallenge: string;
+ handoffCodeHash: string;
+ },
+ now = Date.now(),
+): Promise<NativeOauthAttempt | null> {
+ const rows = await db
+ .update(nativeOauthAttempt)
+ .set({ status: "exchanging", updatedAt: now })
+ .where(
+ and(
+ eq(nativeOauthAttempt.id, data.attemptId),
+ eq(nativeOauthAttempt.stateHash, data.stateHash),
+ eq(nativeOauthAttempt.pkceChallenge, data.pkceChallenge),
+ eq(nativeOauthAttempt.handoffCodeHash, data.handoffCodeHash),
+ eq(nativeOauthAttempt.status, "ready"),
+ gt(nativeOauthAttempt.attemptExpiresAt, now),
+ gt(nativeOauthAttempt.handoffExpiresAt, now),
+ ),
+ )
+ .returning();
+ return rows[0] ?? null;
+}
+
+export async function finishExchange(
+ db: Database,
+ data: {
+ attemptId: string;
+ stateHash: string;
+ pkceChallenge: string;
+ handoffCodeHash: string;
+ },
+ now = Date.now(),
+): Promise<NativeOauthAttempt | null> {
+ const rows = await db
+ .update(nativeOauthAttempt)
+ .set({ status: "consumed", consumedAt: now, updatedAt: now })
+ .where(
+ and(
+ eq(nativeOauthAttempt.id, data.attemptId),
+ eq(nativeOauthAttempt.stateHash, data.stateHash),
+ eq(nativeOauthAttempt.pkceChallenge, data.pkceChallenge),
+ eq(nativeOauthAttempt.handoffCodeHash, data.handoffCodeHash),
+ eq(nativeOauthAttempt.status, "exchanging"),
+ gt(nativeOauthAttempt.attemptExpiresAt, now),
+ gt(nativeOauthAttempt.handoffExpiresAt, now),
+ ),
+ )
+ .returning();
+ return rows[0] ?? null;
+}
+
+export async function failExchange(
+ db: Database,
+ attemptId: string,
+ now = Date.now(),
+): Promise<NativeOauthAttempt | null> {
+ const rows = await db
+ .update(nativeOauthAttempt)
+ .set({
+ status: "failed",
+ failureCode: "invalid_handoff",
+ failedAt: now,
+ updatedAt: now,
+ })
+ .where(
+ and(
+ eq(nativeOauthAttempt.id, attemptId),
+ eq(nativeOauthAttempt.status, "exchanging"),
+ ),
+ )
+ .returning();
+ return rows[0] ?? null;
+}
+
+export async function cancelAttempt(
+ db: Database,
+ data: {
+ attemptId: string;
+ stateHash: string;
+ pkceChallenge: string;
+ },
+ now = Date.now(),
+): Promise<NativeOauthAttempt | null> {
+ const rows = await db
+ .update(nativeOauthAttempt)
+ .set({ status: "cancelled", cancelledAt: now, updatedAt: now })
+ .where(
+ and(
+ eq(nativeOauthAttempt.id, data.attemptId),
+ eq(nativeOauthAttempt.stateHash, data.stateHash),
+ eq(nativeOauthAttempt.pkceChallenge, data.pkceChallenge),
+ inArray(nativeOauthAttempt.status, [
+ "pending",
+ "opened",
+ "ready",
+ "exchanging",
+ ]),
+ gt(nativeOauthAttempt.attemptExpiresAt, now),
+ ),
+ )
+ .returning();
+ return rows[0] ?? null;
+}
+
+export async function getAttemptStatus(
+ db: Database,
+ data: {
+ attemptId: string;
+ stateHash: string;
+ pkceChallenge: string;
+ },
+): Promise<NativeOauthAttempt | null> {
+ const rows = await db
+ .select()
+ .from(nativeOauthAttempt)
+ .where(
+ and(
+ eq(nativeOauthAttempt.id, data.attemptId),
+ eq(nativeOauthAttempt.stateHash, data.stateHash),
+ eq(nativeOauthAttempt.pkceChallenge, data.pkceChallenge),
+ ),
+ )
+ .limit(1);
+ return rows[0] ?? null;
+}
+
+export const nativeOauthDurations = {
+ attemptTtlMs: ATTEMPT_TTL_MS,
+ handoffTtlMs: HANDOFF_TTL_MS,
+ retentionMs: RETENTION_MS,
+} as const;
diff --git a/src/shared/src/db/schema.ts b/src/shared/src/db/schema.ts
index 97dbd87c8..887bf464b 100644
--- a/src/shared/src/db/schema.ts
+++ b/src/shared/src/db/schema.ts
@@ -3,9 +3,11 @@ import {
text,
integer,
index,
+ uniqueIndex,
unique,
primaryKey,
foreignKey,
+ check,
type AnySQLiteColumn,
} from "drizzle-orm/sqlite-core";
import { sql } from "drizzle-orm";
@@ -94,6 +96,165 @@ export const verification = sqliteTable("verification", {
updatedAt: text("updatedAt").notNull().$defaultFn(() => new Date().toISOString()),
});
+export const NATIVE_OAUTH_PROVIDERS = ["github", "google"] as const;
+export type NativeOauthProvider = (typeof NATIVE_OAUTH_PROVIDERS)[number];
+
+export const NATIVE_OAUTH_PLATFORMS = [
+ "macos",
+ "windows",
+ "linux",
+ "ios",
+ "android",
+] as const;
+export type NativeOauthPlatform = (typeof NATIVE_OAUTH_PLATFORMS)[number];
+
+export const NATIVE_OAUTH_STATUSES = [
+ "pending",
+ "opened",
+ "ready",
+ "exchanging",
+ "consumed",
+ "failed",
+ "cancelled",
+ "replaced",
+] as const;
+export type NativeOauthStatus = (typeof NATIVE_OAUTH_STATUSES)[number];
+
+export const NATIVE_OAUTH_FAILURE_CODES = [
+ "access_denied",
+ "provider_error",
+ "oauth_callback_failed",
+ "start_failed",
+ "invalid_handoff",
+] as const;
+export type NativeOauthFailureCode =
+ (typeof NATIVE_OAUTH_FAILURE_CODES)[number];
+
+export const nativeOauthAttempt = sqliteTable(
+ "native_oauth_attempt",
+ {
+ id: text("id").primaryKey(),
+ instanceKeyHash: text("instance_key_hash").notNull(),
+ stateHash: text("state_hash").notNull(),
+ pkceChallenge: text("pkce_challenge").notNull(),
+ provider: text("provider").$type<NativeOauthProvider>().notNull(),
+ platform: text("platform").$type<NativeOauthPlatform>().notNull(),
+ redirectPath: text("redirect_path").notNull(),
+ status: text("status").$type<NativeOauthStatus>().notNull().default("pending"),
+ handoffCodeHash: text("handoff_code_hash"),
+ handoffExpiresAt: integer("handoff_expires_at"),
+ authKind: text("auth_kind").$type<"signin" | "signup">(),
+ failureCode: text("failure_code").$type<NativeOauthFailureCode>(),
+ attemptExpiresAt: integer("attempt_expires_at").notNull(),
+ createdAt: integer("created_at").notNull(),
+ updatedAt: integer("updated_at").notNull(),
+ openedAt: integer("opened_at"),
+ readyAt: integer("ready_at"),
+ consumedAt: integer("consumed_at"),
+ failedAt: integer("failed_at"),
+ cancelledAt: integer("cancelled_at"),
+ replacedAt: integer("replaced_at"),
+ },
+ (t) => [
+ index("idx_native_oauth_attempt_instance_status").on(
+ t.instanceKeyHash,
+ t.status,
+ ),
+ index("idx_native_oauth_attempt_id_status_expiry").on(
+ t.id,
+ t.status,
+ t.attemptExpiresAt,
+ ),
+ index("idx_native_oauth_attempt_terminal_cleanup").on(
+ t.status,
+ t.updatedAt,
+ ),
+ uniqueIndex("uq_native_oauth_attempt_instance_live")
+ .on(t.instanceKeyHash)
+ .where(sql`status IN ('pending', 'opened', 'ready', 'exchanging')`),
+ uniqueIndex("uq_native_oauth_attempt_handoff_hash")
+ .on(t.handoffCodeHash)
+ .where(sql`handoff_code_hash IS NOT NULL`),
+ check(
+ "ck_native_oauth_attempt_id",
+ sql`length(${t.id}) BETWEEN 22 AND 64 AND ${t.id} NOT GLOB '*[^A-Za-z0-9_-]*'`,
+ ),
+ check(
+ "ck_native_oauth_attempt_hashes",
+ sql`length(${t.instanceKeyHash}) = 64 AND ${t.instanceKeyHash} NOT GLOB '*[^0-9a-f]*'
+ AND length(${t.stateHash}) = 64 AND ${t.stateHash} NOT GLOB '*[^0-9a-f]*'
+ AND length(${t.pkceChallenge}) = 43 AND ${t.pkceChallenge} NOT GLOB '*[^A-Za-z0-9_-]*'
+ AND (${t.handoffCodeHash} IS NULL OR (length(${t.handoffCodeHash}) = 64 AND ${t.handoffCodeHash} NOT GLOB '*[^0-9a-f]*'))`,
+ ),
+ check(
+ "ck_native_oauth_attempt_enums",
+ sql`${t.provider} IN ('github', 'google')
+ AND ${t.platform} IN ('macos', 'windows', 'linux', 'ios', 'android')
+ AND ${t.status} IN ('pending', 'opened', 'ready', 'exchanging', 'consumed', 'failed', 'cancelled', 'replaced')
+ AND (${t.authKind} IS NULL OR ${t.authKind} IN ('signin', 'signup'))
+ AND (${t.failureCode} IS NULL OR ${t.failureCode} IN ('access_denied', 'provider_error', 'oauth_callback_failed', 'start_failed', 'invalid_handoff'))`,
+ ),
+ check(
+ "ck_native_oauth_attempt_redirect",
+ sql`length(${t.redirectPath}) BETWEEN 1 AND 2048
+ AND substr(${t.redirectPath}, 1, 1) = '/'
+ AND substr(${t.redirectPath}, 1, 2) <> '//'
+ AND instr(${t.redirectPath}, char(92)) = 0`,
+ ),
+ check(
+ "ck_native_oauth_attempt_epochs",
+ sql`typeof(${t.createdAt}) = 'integer' AND ${t.createdAt} BETWEEN 0 AND 9007199254740991
+ AND typeof(${t.updatedAt}) = 'integer' AND ${t.updatedAt} BETWEEN ${t.createdAt} AND 9007199254740991
+ AND typeof(${t.attemptExpiresAt}) = 'integer' AND ${t.attemptExpiresAt} = ${t.createdAt} + 600000
+ AND (${t.handoffExpiresAt} IS NULL OR (typeof(${t.handoffExpiresAt}) = 'integer' AND ${t.handoffExpiresAt} <= ${t.attemptExpiresAt}))`,
+ ),
+ check(
+ "ck_native_oauth_attempt_state",
+ sql`(
+ ${t.status} = 'pending'
+ AND ${t.openedAt} IS NULL AND ${t.readyAt} IS NULL AND ${t.consumedAt} IS NULL
+ AND ${t.failedAt} IS NULL AND ${t.cancelledAt} IS NULL AND ${t.replacedAt} IS NULL
+ AND ${t.handoffCodeHash} IS NULL AND ${t.handoffExpiresAt} IS NULL
+ AND ${t.authKind} IS NULL AND ${t.failureCode} IS NULL
+ ) OR (
+ ${t.status} = 'opened'
+ AND ${t.openedAt} IS NOT NULL AND ${t.readyAt} IS NULL AND ${t.consumedAt} IS NULL
+ AND ${t.failedAt} IS NULL AND ${t.cancelledAt} IS NULL AND ${t.replacedAt} IS NULL
+ AND ${t.handoffCodeHash} IS NULL AND ${t.handoffExpiresAt} IS NULL
+ AND ${t.authKind} IS NULL AND ${t.failureCode} IS NULL
+ ) OR (
+ ${t.status} IN ('ready', 'exchanging')
+ AND ${t.openedAt} IS NOT NULL AND ${t.readyAt} IS NOT NULL AND ${t.consumedAt} IS NULL
+ AND ${t.failedAt} IS NULL AND ${t.cancelledAt} IS NULL AND ${t.replacedAt} IS NULL
+ AND ${t.handoffCodeHash} IS NOT NULL AND ${t.handoffExpiresAt} IS NOT NULL
+ AND ${t.handoffExpiresAt} = ${t.readyAt} + 120000
+ AND ${t.authKind} IS NOT NULL AND ${t.failureCode} IS NULL
+ ) OR (
+ ${t.status} = 'consumed'
+ AND ${t.openedAt} IS NOT NULL AND ${t.readyAt} IS NOT NULL AND ${t.consumedAt} IS NOT NULL
+ AND ${t.failedAt} IS NULL AND ${t.cancelledAt} IS NULL AND ${t.replacedAt} IS NULL
+ AND ${t.handoffCodeHash} IS NOT NULL AND ${t.handoffExpiresAt} IS NOT NULL
+ AND ${t.authKind} IS NOT NULL AND ${t.failureCode} IS NULL
+ ) OR (
+ ${t.status} = 'failed'
+ AND ${t.consumedAt} IS NULL AND ${t.failedAt} IS NOT NULL
+ AND ${t.cancelledAt} IS NULL AND ${t.replacedAt} IS NULL
+ AND ${t.failureCode} IS NOT NULL
+ ) OR (
+ ${t.status} = 'cancelled'
+ AND ${t.consumedAt} IS NULL AND ${t.cancelledAt} IS NOT NULL
+ AND ${t.failedAt} IS NULL AND ${t.replacedAt} IS NULL
+ AND ${t.failureCode} IS NULL
+ ) OR (
+ ${t.status} = 'replaced'
+ AND ${t.consumedAt} IS NULL AND ${t.replacedAt} IS NOT NULL
+ AND ${t.failedAt} IS NULL AND ${t.cancelledAt} IS NULL
+ AND ${t.failureCode} IS NULL
+ )`,
+ ),
+ ],
+);
+
// ---------------------------------------------------------------------------
// Application tables
// ---------------------------------------------------------------------------
diff --git a/src/shared/src/index.ts b/src/shared/src/index.ts
index 8c1a7127c..1227e42b7 100644
--- a/src/shared/src/index.ts
+++ b/src/shared/src/index.ts
@@ -737,6 +737,8 @@ export {
} from "./utils/day-key";
export { isOnline, formatStatus, isPresenceOnline, isPresenceOffline } from "./utils/status";
export { isUniqueConstraintError } from "./utils/db-errors";
+export * from "./lib/native-oauth-contract";
+export * from "./lib/safe-redirect";
export { generateWorkspaceSlug, sanitizeSlug, slugSuffix } from "./utils/slug";
export { truncateTitle, stripInlineMarkup, deriveThreadName } from "./utils/title";
export {
diff --git a/src/shared/src/lib/native-oauth-contract.test.ts b/src/shared/src/lib/native-oauth-contract.test.ts
new file mode 100644
index 000000000..a21ccdd60
--- /dev/null
+++ b/src/shared/src/lib/native-oauth-contract.test.ts
@@ -0,0 +1,25 @@
+import { describe, expect, it } from "vitest";
+import {
+ NATIVE_OAUTH_FAILURE_CODES,
+ NATIVE_OAUTH_PLATFORMS,
+ NATIVE_OAUTH_PROVIDERS,
+} from "../db/schema";
+import {
+ nativeOauthFailureCodeSchema,
+ nativeOauthPlatformSchema,
+ nativeOauthProviderSchema,
+} from "./native-oauth-contract";
+
+describe("native OAuth contract drift", () => {
+ it("keeps request schemas aligned with persisted enum values", () => {
+ expect(nativeOauthProviderSchema.options).toEqual([
+ ...NATIVE_OAUTH_PROVIDERS,
+ ]);
+ expect(nativeOauthPlatformSchema.options).toEqual([
+ ...NATIVE_OAUTH_PLATFORMS,
+ ]);
+ expect(nativeOauthFailureCodeSchema.options).toEqual([
+ ...NATIVE_OAUTH_FAILURE_CODES,
+ ]);
+ });
+});
diff --git a/src/shared/src/lib/native-oauth-contract.ts b/src/shared/src/lib/native-oauth-contract.ts
new file mode 100644
index 000000000..4b5f5ccea
--- /dev/null
+++ b/src/shared/src/lib/native-oauth-contract.ts
@@ -0,0 +1,52 @@
+import { z } from "zod";
+import { isSafeRedirectPath } from "./safe-redirect";
+
+const ATTEMPT_ID = /^[A-Za-z0-9_-]{22,64}$/;
+const SHA256_HEX = /^[0-9a-f]{64}$/;
+const BASE64URL_32_BYTES = /^[A-Za-z0-9_-]{43}$/;
+const HANDOFF_CODE = /^[A-Za-z0-9_-]{32,128}$/;
+
+export const nativeOauthProviderSchema = z.enum(["github", "google"]);
+export const nativeOauthPlatformSchema = z.enum([
+ "macos",
+ "windows",
+ "linux",
+ "ios",
+ "android",
+]);
+export const nativeOauthAttemptIdSchema = z.string().regex(ATTEMPT_ID);
+export const nativeOauthHandoffCodeSchema = z.string().regex(HANDOFF_CODE);
+export const nativeOauthFailureCodeSchema = z.enum([
+ "access_denied",
+ "provider_error",
+ "oauth_callback_failed",
+ "start_failed",
+ "invalid_handoff",
+]);
+
+export type NativeOauthProvider = z.infer<typeof nativeOauthProviderSchema>;
+export type NativeOauthPlatform = z.infer<typeof nativeOauthPlatformSchema>;
+export type NativeOauthFailureCode = z.infer<
+ typeof nativeOauthFailureCodeSchema
+>;
+
+export const nativeOauthRegistrationSchema = z.object({
+ attemptId: nativeOauthAttemptIdSchema,
+ stateHash: z.string().regex(SHA256_HEX),
+ codeChallenge: z.string().regex(BASE64URL_32_BYTES),
+ instanceKeyHash: z.string().regex(SHA256_HEX),
+ platform: nativeOauthPlatformSchema,
+ provider: nativeOauthProviderSchema,
+ redirectPath: z.string().refine(isSafeRedirectPath),
+}).strict();
+
+export const nativeOauthExchangeSchema = z.object({
+ attemptId: nativeOauthAttemptIdSchema,
+ state: z.string().regex(BASE64URL_32_BYTES),
+ verifier: z.string().regex(BASE64URL_32_BYTES),
+ code: nativeOauthHandoffCodeSchema,
+}).strict();
+
+export const nativeOauthProofSchema = nativeOauthExchangeSchema
+ .omit({ code: true })
+ .strict();
diff --git a/src/shared/src/lib/rate-limits.ts b/src/shared/src/lib/rate-limits.ts
index 4ea0f8d7c..771c39eee 100644
--- a/src/shared/src/lib/rate-limits.ts
+++ b/src/shared/src/lib/rate-limits.ts
@@ -29,6 +29,7 @@ export const RATE_LIMITS = {
* overridable via `AUTH_OTP_RATE_LIMIT_MAX` / `_WINDOW_SEC`.
*/
"auth:otpSend": { windowMs: 60_000, max: 5 },
+ "auth:nativeAttempt": { windowMs: 60_000, max: 10 },
} as const
export type RateLimitName = keyof typeof RATE_LIMITS
diff --git a/src/shared/src/lib/safe-redirect.test.ts b/src/shared/src/lib/safe-redirect.test.ts
new file mode 100644
index 000000000..017cdc7d5
--- /dev/null
+++ b/src/shared/src/lib/safe-redirect.test.ts
@@ -0,0 +1,49 @@
+import { describe, expect, it, vi } from "vitest";
+import { isSafeRedirectPath, safeRedirectPath } from "./safe-redirect";
+
+describe("safe redirect paths", () => {
+ it.each([
+ "/c/me",
+ "/c/me/machines?tab=active",
+ "/sign-in?redirect=%2Fc%2Fme",
+ "/search?q=100%25",
+ ])("accepts a local path: %s", (path) => {
+ expect(isSafeRedirectPath(path)).toBe(true);
+ expect(safeRedirectPath(path)).toBe(path);
+ });
+
+ it.each([
+ "https://evil.example/c",
+ "//evil.example/c",
+ "/\\evil.example/c",
+ "/%5Cevil.example/c",
+ "/%2Fevil.example/c",
+ "/%252Fevil.example/c",
+ "/%255Cevil.example/c",
+ "/c/me#secret",
+ "/c/\nme",
+ "/c/%0ame",
+ "/" + "a".repeat(2048),
+ "%",
+ ])("rejects an unsafe path: %s", (path) => {
+ expect(isSafeRedirectPath(path)).toBe(false);
+ expect(safeRedirectPath(path)).toBe("/c/me");
+ });
+
+ it("uses a caller-provided fallback for a missing value", () => {
+ expect(safeRedirectPath(undefined, "/sign-in")).toBe("/sign-in");
+ });
+
+ it("fails closed when the platform URL parser is unavailable", () => {
+ vi.stubGlobal("URL", class {
+ constructor() {
+ throw new Error("URL parser unavailable");
+ }
+ });
+ try {
+ expect(isSafeRedirectPath("/c/me")).toBe(false);
+ } finally {
+ vi.unstubAllGlobals();
+ }
+ });
+});
diff --git a/src/shared/src/lib/safe-redirect.ts b/src/shared/src/lib/safe-redirect.ts
new file mode 100644
index 000000000..c20af5c54
--- /dev/null
+++ b/src/shared/src/lib/safe-redirect.ts
@@ -0,0 +1,44 @@
+const MAX_REDIRECT_BYTES = 2048;
+const CONTROL_CHARACTERS = /[\u0000-\u001f\u007f]/;
+
+function isSafeCandidate(value: string): boolean {
+ return value.startsWith("/")
+ && !value.startsWith("//")
+ && !value.includes("\\")
+ && !value.includes("#")
+ && !CONTROL_CHARACTERS.test(value);
+}
+
+export function isSafeRedirectPath(value: string): boolean {
+ if (new TextEncoder().encode(value).byteLength > MAX_REDIRECT_BYTES) return false;
+ if (!isSafeCandidate(value)) return false;
+
+ let decoded = value;
+ for (let depth = 0; depth < 8; depth += 1) {
+ let next: string;
+ try {
+ next = decodeURIComponent(decoded);
+ } catch {
+ return depth > 0;
+ }
+ if (next === decoded) break;
+ if (!isSafeCandidate(next)) return false;
+ decoded = next;
+ if (depth === 7) return false;
+ }
+
+ try {
+ const base = new URL("https://alook.invalid");
+ const resolved = new URL(value, base);
+ return resolved.origin === base.origin;
+ } catch {
+ return false;
+ }
+}
+
+export function safeRedirectPath(
+ value: string | null | undefined,
+ fallback = "/c/me",
+): string {
+ return value && isSafeRedirectPath(value) ? value : fallback;
+}
diff --git a/src/web/auth/index.test.ts b/src/web/auth/index.test.ts
new file mode 100644
index 000000000..80528713c
--- /dev/null
+++ b/src/web/auth/index.test.ts
@@ -0,0 +1,169 @@
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { describe, expect, it, vi } from "vitest";
+import { renderFaceSvg } from "../src/lib/avatar/face";
+import handler, {
+ ANDROID_ASSET_LINKS,
+ APPLE_APP_SITE_ASSOCIATION,
+ AUTH_RETURN_AVATAR_SEEDS,
+ AUTH_WORKER_AASA_PATH,
+ AUTH_WORKER_ASSET_LINKS_PATH,
+ AUTH_WORKER_RETURN_PATH,
+} from "./index";
+
+const ATTEMPT = "attempt_1234567890123456";
+const CODE = "c".repeat(32);
+const CANONICAL_LOGO = readFileSync(
+ new URL("../public/alook.svg", import.meta.url),
+ "utf8",
+).trim();
+const DM_SANS_WOFF2 = readFileSync(
+ new URL("../src/app/fonts/dm-sans-latin.woff2", import.meta.url),
+).toString("base64");
+const CAVEAT_WOFF2 = readFileSync(
+ new URL("../src/app/fonts/caveat-latin.woff2", import.meta.url),
+).toString("base64");
+
+function request(path: string, init?: RequestInit): Request {
+ return new Request(`https://auth.alook.ai${path}`, init);
+}
+
+async function fetch(path: string, init?: RequestInit): Promise<Response> {
+ return handler.fetch(request(path, init));
+}
+
+function expectPrivate(response: Response): void {
+ expect(response.headers.get("Cache-Control")).toBe("no-store, max-age=0");
+ expect(response.headers.get("Pragma")).toBe("no-cache");
+ expect(response.headers.get("Referrer-Policy")).toBe("no-referrer");
+ expect(response.headers.get("X-Content-Type-Options")).toBe("nosniff");
+}
+
+describe("alook-auth Worker", () => {
+ it.each([
+ [AUTH_WORKER_AASA_PATH, APPLE_APP_SITE_ASSOCIATION],
+ [AUTH_WORKER_ASSET_LINKS_PATH, ANDROID_ASSET_LINKS],
+ ])("serves the exact association payload at %s", async (path, expected) => {
+ const response = await fetch(path);
+ expect(response.status).toBe(200);
+ expect(response.headers.get("Content-Type")).toBe("application/json; charset=utf-8");
+ expectPrivate(response);
+ await expect(response.json()).resolves.toEqual(expected);
+ });
+
+ it("serves association HEAD responses without a body", async () => {
+ const response = await fetch(AUTH_WORKER_AASA_PATH, { method: "HEAD" });
+ expect(response.status).toBe(200);
+ expect(response.headers.get("Content-Type")).toBe("application/json; charset=utf-8");
+ expectPrivate(response);
+ expect(await response.text()).toBe("");
+ });
+
+ it.each([
+ `?attempt=${ATTEMPT}&code=${CODE}`,
+ `?attempt=${ATTEMPT}&status=access_denied`,
+ ])("renders a static launch control without serializing return values for %s", async (query) => {
+ const response = await fetch(`${AUTH_WORKER_RETURN_PATH}${query}`);
+ const body = await response.text();
+ expect(response.status).toBe(200);
+ expect(response.headers.get("Content-Type")).toBe("text/html; charset=utf-8");
+ expectPrivate(response);
+ expect(body).toContain("data-open-alook");
+ expect(body).toContain("Open Alook");
+ expect(body).not.toContain(ATTEMPT);
+ expect(body).not.toContain(CODE);
+ expect(body).not.toContain("access_denied");
+ expect(body).not.toMatch(/href=["']ai\.alook:/);
+
+ const script = body.match(/<script>([\s\S]+)<\/script>/)?.[1];
+ expect(script).toBeDefined();
+ const digest = createHash("sha256").update(script!).digest("base64");
+ expect(response.headers.get("Content-Security-Policy"))
+ .toContain(`script-src 'sha256-${digest}'`);
+ expect(response.headers.get("Content-Security-Policy"))
+ .toContain("script-src 'sha256-5yRFm/Mu9yL952eR8mqLHHTJZnHDNb5SC5aES535aMk='");
+ });
+
+ it("reuses canonical Alook branding and disables ambient motion on request", async () => {
+ const response = await fetch(`${AUTH_WORKER_RETURN_PATH}?attempt=${ATTEMPT}&code=${CODE}`);
+ const body = await response.text();
+ const csp = response.headers.get("Content-Security-Policy")!;
+
+ expect(body).toContain(CANONICAL_LOGO);
+ expect(body).toContain(`src: url("data:font/woff2;base64,${DM_SANS_WOFF2}")`);
+ expect(body).toContain(`src: url("data:font/woff2;base64,${CAVEAT_WOFF2}")`);
+ expect(body.match(/data:font\/woff2;base64,/g)).toHaveLength(2);
+ expect(body).toContain('font-family: "DM Sans", ui-sans-serif');
+ expect(body).toContain('font-family: "Caveat", cursive; font-size: 30px; font-weight: 700;');
+ expect(body).toContain("button {\n width: 100%;");
+ expect(body).toContain("font: inherit;");
+ expect(csp.split("; ")).toContain("font-src data:");
+ expect(body).toContain('<meta name="color-scheme" content="light dark">');
+ expect(body).toContain('class="avatar-field" aria-hidden="true"');
+ expect(body.match(/class="avatar avatar-\d"/g)).toHaveLength(
+ AUTH_RETURN_AVATAR_SEEDS.length,
+ );
+ for (const seed of AUTH_RETURN_AVATAR_SEEDS) {
+ expect(body).toContain(renderFaceSvg(seed));
+ expect(body).not.toContain(seed);
+ }
+ expect(body).toContain("@media (prefers-color-scheme: dark)");
+ expect(body).toContain("@media (prefers-reduced-motion: reduce)");
+ expect(body).toMatch(/\.avatar-field \{[\s\S]*?pointer-events: none;[\s\S]*?\}/);
+ expect(body).toMatch(/\.avatar \{ animation: none; transform: none; will-change: auto; \}/);
+ expect(body).toContain("min-height: 48px");
+ expect(body).toContain("button:focus-visible");
+ expect(body.match(/<script>/g)).toHaveLength(1);
+ expect(body).not.toMatch(/<(?:img|link)\b/i);
+ });
+
+ it.each([
+ "",
+ `?attempt=bad&code=${CODE}`,
+ `?attempt=${ATTEMPT}&code=bad`,
+ `?attempt=${ATTEMPT}&status=not-a-status`,
+ `?attempt=${ATTEMPT}&code=${CODE}&status=access_denied`,
+ `?attempt=${ATTEMPT}&code=${CODE}&extra=1`,
+ `?attempt=${ATTEMPT}&attempt=${ATTEMPT}&code=${CODE}`,
+ ])("renders no launch control for invalid return query %s", async (query) => {
+ const response = await fetch(`${AUTH_WORKER_RETURN_PATH}${query}`);
+ const body = await response.text();
+ expect(response.status).toBe(200);
+ expectPrivate(response);
+ expect(body).toContain(CANONICAL_LOGO);
+ expect(body).toContain('class="avatar-field" aria-hidden="true"');
+ expect(body).toContain("This sign-in link is invalid.");
+ expect(body).not.toContain("expired");
+ expect(body).not.toContain("data-open-alook");
+ expect(body).not.toContain("<script>");
+ expect(body).not.toContain(CODE);
+ });
+
+ it.each([
+ ["GET", "https://alook.ai/auth/native/return"],
+ ["GET", "http://auth.alook.ai/auth/native/return"],
+ ["GET", "https://auth.alook.ai:444/auth/native/return"],
+ ["GET", "https://auth.alook.ai/"],
+ ["GET", "https://auth.alook.ai/sign-in"],
+ ["GET", `https://auth.alook.ai${AUTH_WORKER_AASA_PATH}?query=1`],
+ ["POST", `https://auth.alook.ai${AUTH_WORKER_RETURN_PATH}`],
+ ["OPTIONS", `https://auth.alook.ai${AUTH_WORKER_ASSET_LINKS_PATH}`],
+ ])("returns private 404 for %s %s", async (method, url) => {
+ const response = await handler.fetch(new Request(url, { method }));
+ expect(response.status).toBe(404);
+ expect(response.headers.get("Location")).toBeNull();
+ expectPrivate(response);
+ });
+
+ it("does not call console APIs while handling a handoff URL", async () => {
+ const spies = ["debug", "info", "log", "warn", "error"].map((method) => (
+ vi.spyOn(console, method as "log").mockImplementation(() => undefined)
+ ));
+ try {
+ await fetch(`${AUTH_WORKER_RETURN_PATH}?attempt=${ATTEMPT}&code=${CODE}`);
+ for (const spy of spies) expect(spy).not.toHaveBeenCalled();
+ } finally {
+ for (const spy of spies) spy.mockRestore();
+ }
+ });
+});
diff --git a/src/web/auth/index.ts b/src/web/auth/index.ts
new file mode 100644
index 000000000..0e4190acc
--- /dev/null
+++ b/src/web/auth/index.ts
@@ -0,0 +1,382 @@
+export const AUTH_WORKER_HOST = "auth.alook.ai";
+export const AUTH_WORKER_RETURN_PATH = "/auth/native/return";
+export const AUTH_WORKER_AASA_PATH = "/.well-known/apple-app-site-association";
+export const AUTH_WORKER_ASSET_LINKS_PATH = "/.well-known/assetlinks.json";
+
+export const APPLE_APP_SITE_ASSOCIATION = {
+ applinks: {
+ apps: [],
+ details: [
+ {
+ appID: "5RF24VHDQB.ai.alook.ios",
+ components: [
+ {
+ "/": AUTH_WORKER_RETURN_PATH,
+ comment: "Native OAuth handoff return",
+ },
+ ],
+ },
+ ],
+ },
+} as const;
+
+export const ANDROID_ASSET_LINKS = [
+ {
+ relation: ["delegate_permission/common.handle_all_urls"],
+ target: {
+ namespace: "android_app",
+ package_name: "ai.alook.android",
+ sha256_cert_fingerprints: [
+ "9D:C6:ED:E9:4B:A6:63:EE:C9:EC:98:FF:7B:AF:D5:5E:24:8B:6C:4B:C2:15:7F:CF:04:2D:F5:9B:0E:41:08:06",
+ ],
+ },
+ },
+] as const;
+
+const ATTEMPT_ID = /^[A-Za-z0-9_-]{22,64}$/;
+const HANDOFF_CODE = /^[A-Za-z0-9_-]{32,128}$/;
+const FAILURE_CODES = new Set([
+ "access_denied",
+ "provider_error",
+ "oauth_callback_failed",
+ "start_failed",
+ "invalid_handoff",
+]);
+const RETURN_QUERY_KEYS = new Set(["attempt", "code", "status"]);
+const RETURN_SCRIPT = 'document.querySelector("[data-open-alook]")?.addEventListener("click",()=>{window.location.assign("ai.alook://auth/native/return"+window.location.search)});';
+const RETURN_SCRIPT_SHA256 = "5yRFm/Mu9yL952eR8mqLHHTJZnHDNb5SC5aES535aMk=";
+const DM_SANS_WOFF2 = "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";
+const CAVEAT_WOFF2 = "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";
+
+export const AUTH_RETURN_AVATAR_SEEDS = [
+ "alook-return-canvas",
+ "alook-return-orbit",
+ "alook-return-signal",
+ "alook-return-thread",
+ "alook-return-cursor",
+ "alook-return-companion",
+ "alook-return-handoff",
+] as const;
+
+const AUTH_RETURN_AVATARS = [
+ `<svg viewBox="0 0 36 36" width="100%" height="100%" xmlns="http://www.w3.org/2000/svg"><rect width="36" height="36" fill="#fff0d9"/><g transform="translate(0.92 0.80) rotate(4 18 23.5) translate(-0.18 -0.24) scale(1.010)"><path d="M2 29V23C2 15.4 7.2 12 12.7 11.6C15.9 11.3 17.2 8.1 22.5 8.1C29.6 8.1 34 14.4 34 23V29C34 34.5 29 37.5 18 37.5C7 37.5 2 34.5 2 29Z" fill="#362a52"/><ellipse cx="14" cy="20" rx="2.2" ry="2" fill="#ffffff"/><circle cx="14" cy="20.55" r="1" fill="#000000"/><ellipse cx="22" cy="20" rx="2.2" ry="2" fill="#ffffff"/><circle cx="22" cy="20.55" r="1" fill="#000000"/><path d="M11.8 19.1h4.4M19.8 19.1h4.4" stroke="#000000" stroke-width="1.35" stroke-linecap="round"/><path d="M16.2 24.5q1.8 1.5 3.6 0" stroke="#ffffff" stroke-width="1.5" fill="none" stroke-linecap="round"/></g></svg>`,
+ `<svg viewBox="0 0 36 36" width="100%" height="100%" xmlns="http://www.w3.org/2000/svg"><rect width="36" height="36" fill="#f3c8ef"/><g transform="translate(1.54 1.60) rotate(2 18 23.5) translate(-0.36 -0.47) scale(1.020)"><path d="M2 29V23C2 16.4 5.7 13 10.4 11.8C11.3 8.8 14.2 7.6 17 9.6C19.8 6.9 24.5 7.8 26.2 11.2C31.1 12.6 34 16.5 34 23V29C34 34.5 29 37.5 18 37.5C7 37.5 2 34.5 2 29Z" fill="#3f477f"/><path d="M12 20q2 2 4 0" fill="none" stroke="#ffffff" stroke-width="1.6" stroke-linecap="round"/><circle cx="22" cy="20" r="1.8" fill="#ffffff"/><path d="M15 25q3.5 0.7 6-1.2" stroke="#ffffff" stroke-width="1.5" fill="none" stroke-linecap="round"/></g></svg>`,
+ `<svg viewBox="0 0 36 36" width="100%" height="100%" xmlns="http://www.w3.org/2000/svg"><rect width="36" height="36" fill="#24372e"/><g transform="translate(-0.46 0.40) rotate(-8 18 23.5) translate(-0.18 -0.24) scale(1.010)"><path d="M2 29V23C2 15.7 6.2 11.2 12.3 10.4C14.5 10.1 15.4 7.1 20.3 7.1C28.5 7.1 34 14.1 34 23V29C34 34.5 29 37.5 18 37.5C7 37.5 2 34.5 2 29Z" fill="#90aa62"/><circle cx="14" cy="20" r="1.7" fill="#000000"/><circle cx="22" cy="20" r="1.7" fill="#000000"/><path d="M14.5 25q2.2-1.6 4 0.1q1.6 1.4 3-0.4" stroke="#000000" stroke-width="1.5" fill="none" stroke-linecap="round"/></g></svg>`,
+ `<svg viewBox="0 0 36 36" width="100%" height="100%" xmlns="http://www.w3.org/2000/svg"><rect width="36" height="36" fill="#493044"/><g transform="translate(-0.92 0.00) rotate(18 18 23.5) translate(-0.18 -0.24) scale(1.010)"><path d="M2 29V23C2 15.1 8 9.2 15.4 9.2H22.6C29.7 9.2 34 15.1 34 23V29C34 34.5 29 37.5 18 37.5C7 37.5 2 34.5 2 29Z" fill="#eb7c8b"/><circle cx="14" cy="20" r="1.8" fill="none" stroke="#000000" stroke-width="1.25"/><circle cx="22" cy="20" r="1.8" fill="none" stroke="#000000" stroke-width="1.25"/><rect x="14.3" y="23.8" width="7.4" height="4.8" rx="2.4" fill="#000000"/><rect x="16.2" y="26.25" width="1.8" height="1.55" rx="0.5" fill="#ffffff"/><rect x="18" y="26.25" width="1.8" height="1.55" rx="0.5" fill="#ffffff"/></g></svg>`,
+ `<svg viewBox="0 0 36 36" width="100%" height="100%" xmlns="http://www.w3.org/2000/svg"><rect width="36" height="36" fill="#edecb3"/><g transform="translate(-0.62 0.00) rotate(15 18 23.5) translate(0.00 0.00) scale(1.000)"><path d="M2 29V23C2 15.7 6.2 11.2 12.3 10.4C14.5 10.1 15.4 7.1 20.3 7.1C28.5 7.1 34 14.1 34 23V29C34 34.5 29 37.5 18 37.5C7 37.5 2 34.5 2 29Z" fill="#32c2b9"/><ellipse cx="14" cy="20" rx="2.15" ry="2.1" fill="#ffffff"/><circle cx="14" cy="20.25" r="1.02" fill="#000000"/><ellipse cx="22" cy="20" rx="2.15" ry="2.1" fill="#ffffff"/><circle cx="22" cy="20.25" r="1.02" fill="#000000"/><path d="M15 24.2q1.5 2 3 0q1.5 2 3 0" stroke="#000000" stroke-width="1.65" fill="none" stroke-linecap="round"/></g></svg>`,
+ `<svg viewBox="0 0 36 36" width="100%" height="100%" xmlns="http://www.w3.org/2000/svg"><rect width="36" height="36" fill="#fff0d9"/><g transform="translate(1.23 0.00) rotate(17 18 23.5) translate(0.00 0.00) scale(1.000)"><path d="M2 29V23C2 15.7 6.2 11.2 12.3 10.4C14.5 10.1 15.4 7.1 20.3 7.1C28.5 7.1 34 14.1 34 23V29C34 34.5 29 37.5 18 37.5C7 37.5 2 34.5 2 29Z" fill="#362a52"/><circle cx="14" cy="20" r="2.8" fill="#ffffff"/><circle cx="14" cy="20.35" r="1.25" fill="#000000"/><circle cx="22" cy="20" r="1.65" fill="#ffffff"/><circle cx="22" cy="20.2" r="0.8" fill="#000000"/><path d="M13.8 26.4q4.2-3.8 8.4 0" stroke="#ffffff" stroke-width="1.65" fill="none" stroke-linecap="round"/></g></svg>`,
+ `<svg viewBox="0 0 36 36" width="100%" height="100%" xmlns="http://www.w3.org/2000/svg"><rect width="36" height="36" fill="#c7f464"/><g transform="translate(-1.23 1.20) rotate(-8 18 23.5) translate(-0.36 -0.47) scale(1.020)"><path d="M2 29V23C2 16.4 5.8 13.8 10 12.4C9.1 9.1 11.5 7.3 14.2 9.4C16.4 11 19.8 11 22 9.3C24.8 7.1 27.7 9.1 26.8 12.5C31 13.9 34 16.7 34 23V29C34 34.5 29 37.5 18 37.5C7 37.5 2 34.5 2 29Z" fill="#ff6b6b"/><circle cx="14" cy="20" r="1.8" fill="none" stroke="#000000" stroke-width="1.25"/><circle cx="22" cy="20" r="1.8" fill="none" stroke="#000000" stroke-width="1.25"/><ellipse cx="18" cy="25" rx="1.55" ry="2.3" fill="none" stroke="#000000" stroke-width="1.45"/></g></svg>`,
+] as const;
+
+const ALOOK_LOGO = `
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1024 1024" fill="none" data-state="default">
+ <g clip-path="url(#alook-logo-clip)">
+ <g data-face="red">
+ <path d="M-26.5996 311.221L-39.86 185.057C-55.9935 31.5572 22.3761 -72.3481 148.875 -102.651C194.472 -113.822 206.766 -178.893 309.8 -189.722C482.225 -207.845 613.345 -72.8086 633.015 114.335L646.275 240.499C658.431 356.149 559.924 430.282 328.623 454.592C97.3226 478.903 -14.4443 426.871 -26.5996 311.221Z" fill="#FE4365"/>
+ <g data-part="expression" opacity="0">
+ <path d="M210.59 140.663C225.106 139.137 234.746 117.66 232.122 92.6914C229.498 67.7233 215.603 48.7195 201.086 50.2452C186.57 51.771 176.93 73.2485 179.554 98.2166C182.178 123.185 196.073 142.189 210.59 140.663Z" fill="white"/>
+ <path d="M378.808 122.982C393.325 121.457 402.965 99.979 400.341 75.0109C397.717 50.0428 383.822 31.039 369.305 32.5647C354.789 34.0904 345.148 55.5679 347.773 80.536C350.397 105.504 364.292 124.508 378.808 122.982Z" fill="white"/>
+ <path d="M328.063 167.848C333.26 162.502 341.807 162.382 347.153 167.579C352.499 172.777 352.619 181.324 347.421 186.67C334.382 200.08 319.562 208.689 302.962 210.434C286.361 212.178 270.075 206.839 254.533 196.433C248.337 192.284 246.678 183.899 250.826 177.704C254.974 171.509 263.36 169.849 269.555 173.997C281.456 181.966 291.507 184.489 300.139 183.581C308.771 182.674 318.079 178.117 328.063 167.848Z" fill="white"/>
+ </g>
+ </g>
+ <g data-face="purple">
+ <path d="M523.747 365.154L550.571 58.5595C556.271 -6.59189 611.194 -38.4735 678.261 -32.6059L1015.52 -3.09997C1082.58 2.76768 1131.14 43.7023 1125.44 108.854L1098.61 415.448C1089.89 515.091 998.635 565.034 797.433 547.431C596.23 529.828 515.03 464.797 523.747 365.154Z" fill="#8A5A9E"/>
+ <g data-part="expression" opacity="0">
+ <path d="M746.769 191.001C764.76 192.575 780.621 179.267 782.195 161.276C783.769 143.285 770.46 127.424 752.469 125.85C734.478 124.276 718.618 137.585 717.044 155.576C715.47 173.567 728.778 189.427 746.769 191.001Z" fill="white"/>
+ <path d="M900.067 204.413C918.058 205.987 933.918 192.679 935.492 174.688C937.066 156.697 923.758 140.836 905.767 139.262C887.776 137.688 871.915 150.997 870.341 168.988C868.767 186.979 882.076 202.839 900.067 204.413Z" fill="white"/>
+ <path d="M879.218 239.983C885.568 236.076 893.884 238.055 897.791 244.405C901.699 250.755 899.719 259.07 893.37 262.978C867.707 278.77 841.761 286.237 815.871 283.972C789.981 281.707 765.725 269.847 743.194 249.839C737.62 244.888 737.114 236.355 742.065 230.78C747.016 225.206 755.549 224.7 761.124 229.651C780.399 246.769 799.403 255.428 818.224 257.075C837.045 258.721 857.264 253.493 879.218 239.983Z" fill="white"/>
+ </g>
+ </g>
+ <g data-face="teal">
+ <path d="M-78.815 606.38L-85.9302 504.628C-93.0454 402.877 -38.9437 347.969 34.4882 325.793C26.946 266.675 72.4141 234.525 120.811 268.632C135.789 214.756 212.103 209.42 232.856 262.501C282.701 219.82 339.34 249.943 336.588 308.076C405.846 323.683 449.748 366.625 456.745 466.681L463.86 568.432C470.382 661.705 389.147 718.51 202.602 731.554C16.0577 744.599 -72.2928 699.652 -78.815 606.38Z" fill="#45ADA8"/>
+ <g data-part="expression" opacity="0">
+ <path d="M112.83 422.564C129.98 421.365 145.457 430.644 158.934 444.695C164.133 450.116 163.953 458.725 158.532 463.924C153.111 469.123 144.502 468.944 139.303 463.523C128.271 452.021 120.188 449.315 114.727 449.697C109.266 450.079 101.638 453.884 92.3142 466.809C87.92 472.9 79.4196 474.276 73.3281 469.882C67.2366 465.488 65.8599 456.988 70.254 450.896C81.644 435.107 95.6792 423.763 112.83 422.564ZM248.498 413.077C265.649 411.878 281.126 421.157 294.603 435.208C299.802 440.629 299.621 449.238 294.201 454.437C288.78 459.636 280.171 459.457 274.972 454.036C263.94 442.534 255.857 439.828 250.396 440.21C244.935 440.592 237.307 444.397 227.983 457.322C223.589 463.414 215.088 464.789 208.997 460.395C202.905 456.001 201.529 447.501 205.923 441.409C217.313 425.62 231.348 414.276 248.498 413.077Z" fill="black"/>
+ <path d="M237.886 492.175C243.232 487.591 251.282 488.21 255.865 493.556C260.449 498.901 259.83 506.951 254.484 511.535C234.167 528.953 212.389 539.153 189.261 540.77C166.134 542.387 143.149 535.318 120.604 520.896C114.673 517.102 112.94 509.216 116.734 503.285C120.529 497.353 128.415 495.62 134.346 499.415C153.427 511.621 171.04 516.482 187.483 515.332C203.925 514.182 220.69 506.917 237.886 492.175Z" fill="black"/>
+ </g>
+ </g>
+ <g data-face="blue">
+ <path d="M-109.988 949.35L-99.7556 851.999C-85.7718 718.952 24.7154 635.419 172.106 637.787C331.026 639.726 436.163 747.563 419.451 906.57L409.219 1003.92C399.839 1093.16 313.597 1133.31 135.12 1114.55C-43.357 1095.79 -119.367 1038.59 -109.988 949.35Z" fill="#6A8CAF"/>
+ <g data-part="expression" opacity="0">
+ <path d="M96.9934 852.993C113.123 854.688 127.573 842.987 129.268 826.857C130.964 810.728 119.262 796.278 103.133 794.582C87.0029 792.887 72.5529 804.588 70.8576 820.718C69.1623 836.848 80.8637 851.298 96.9934 852.993Z" fill="black"/>
+ <path d="M254.259 830.894C259.753 826.445 267.814 827.292 272.263 832.786C276.711 838.28 275.864 846.339 270.371 850.788C256.884 861.71 242.205 868.002 226.821 866.385C211.437 864.768 198.388 855.562 187.467 842.075C183.018 836.581 183.865 828.521 189.359 824.072C194.853 819.623 202.913 820.471 207.361 825.964C215.8 836.385 223.247 840.269 229.497 840.926C235.747 841.582 243.839 839.332 254.259 830.894Z" fill="black"/>
+ <path d="M88.7148 884.932C130.907 930.924 177.419 935.813 228.252 899.598C219.15 944.573 193.506 964.844 151.321 960.41C109.135 955.977 88.2666 930.817 88.7148 884.932Z" fill="black"/>
+ </g>
+ </g>
+ <g data-face="orange" data-motion-layer="foreground">
+ <path d="M73.3744 799.986L80.287 602.034C88.6974 361.193 232.448 217.568 434.621 198.202C507.549 190.84 540.698 92.9006 702.358 98.5459C972.892 107.993 1146.28 345.273 1136.03 638.902L1129.12 836.853C1122.78 1018.31 954.364 1111.52 591.453 1098.85C228.541 1086.18 67.0378 981.442 73.3744 799.986Z" fill="#FF9915"/>
+ <path d="M499.787 535.435C538.186 535.435 569.315 505.031 569.315 467.525C569.315 430.019 538.186 399.614 499.787 399.614C461.388 399.614 430.26 430.019 430.26 467.525C430.26 505.031 461.388 535.435 499.787 535.435Z" fill="white"/>
+ <path d="M522.424 513.445C540.641 513.445 555.409 498.677 555.409 480.46C555.409 462.243 540.641 447.475 522.424 447.475C504.207 447.475 489.439 462.243 489.439 480.46C489.439 498.677 504.207 513.445 522.424 513.445Z" fill="black"/>
+ <path d="M758.494 535.435C796.893 535.435 828.021 505.031 828.021 467.525C828.021 430.019 796.893 399.614 758.494 399.614C720.095 399.614 688.966 430.019 688.966 467.525C688.966 505.031 720.095 535.435 758.494 535.435Z" fill="white"/>
+ <path d="M781.131 513.445C799.348 513.445 814.116 498.677 814.116 480.46C814.116 462.243 799.348 447.475 781.131 447.475C762.914 447.475 748.146 462.243 748.146 480.46C748.146 498.677 762.914 513.445 781.131 513.445Z" fill="black"/>
+ <path d="M711.48 571.1C722.145 562.995 737.361 565.07 745.466 575.735C753.571 586.399 751.496 601.615 740.832 609.72C680.61 655.489 608.609 669.247 527.369 652.999C514.235 650.372 505.716 637.594 508.343 624.459C510.971 611.325 523.748 602.806 536.883 605.433C606.555 619.368 663.908 607.255 711.48 571.1Z" fill="black"/>
+ </g>
+ </g>
+ <defs>
+ <clipPath id="alook-logo-clip">
+ <rect width="1024" height="1024" rx="236" fill="white"/>
+ </clipPath>
+ </defs>
+</svg>
+`;
+
+const AVATAR_FIELD = `<div class="avatar-field" aria-hidden="true">${AUTH_RETURN_AVATARS.map((avatar, index) => (
+ `<span class="avatar avatar-${index + 1}">${avatar}</span>`
+)).join("")}</div>`;
+
+const SECURITY_HEADERS = {
+ "Cache-Control": "no-store, max-age=0",
+ Pragma: "no-cache",
+ "Referrer-Policy": "no-referrer",
+ "X-Content-Type-Options": "nosniff",
+ "X-Frame-Options": "DENY",
+ "Cross-Origin-Opener-Policy": "same-origin",
+ "Permissions-Policy": "camera=(), microphone=(), geolocation=()",
+} as const;
+
+const RETURN_CSP = [
+ "default-src 'none'",
+ "base-uri 'none'",
+ "form-action 'none'",
+ "frame-ancestors 'none'",
+ `script-src 'sha256-${RETURN_SCRIPT_SHA256}'`,
+ "style-src 'unsafe-inline'",
+ "font-src data:",
+].join("; ");
+
+const PAGE_STYLE = `
+ @font-face {
+ font-family: "DM Sans";
+ src: url("data:font/woff2;base64,${DM_SANS_WOFF2}") format("woff2");
+ font-style: normal;
+ font-weight: 400 900;
+ font-display: swap;
+ }
+ @font-face {
+ font-family: "Caveat";
+ src: url("data:font/woff2;base64,${CAVEAT_WOFF2}") format("woff2");
+ font-style: normal;
+ font-weight: 400 700;
+ font-display: swap;
+ }
+ :root {
+ color-scheme: light dark;
+ font-family: "DM Sans", ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, sans-serif;
+ --background: oklch(1 0 0);
+ --foreground: oklch(0.18 0.03 230);
+ --card: oklch(1 0.003 80);
+ --muted-foreground: oklch(0.44 0.03 230);
+ --primary: oklch(0.22 0.03 230);
+ --primary-foreground: oklch(0.985 0.005 80);
+ --button-hover: oklch(0.3 0.03 230);
+ --border: oklch(0.86 0.01 80);
+ --ring: oklch(0.55 0.03 230);
+ --e1: 0 1px 2px oklch(0.3 0.02 60 / 6%);
+ --e2: 0 10px 20px -6px oklch(0.3 0.02 60 / 18%);
+ --avatar-shadow: 0 10px 28px oklch(0.3 0.02 60 / 12%);
+ --avatar-opacity: 0.78;
+ --ease: cubic-bezier(0.2, 0.8, 0.2, 1);
+ }
+ * { box-sizing: border-box; }
+ html { min-height: 100%; background: var(--background); }
+ body {
+ margin: 0;
+ min-height: 100vh;
+ min-height: 100svh;
+ display: grid;
+ place-items: center;
+ overflow: hidden;
+ background: var(--background);
+ color: var(--foreground);
+ padding: max(24px, env(safe-area-inset-top)) max(24px, env(safe-area-inset-right)) max(24px, env(safe-area-inset-bottom)) max(24px, env(safe-area-inset-left));
+ }
+ .avatar-field {
+ position: fixed;
+ inset: 0;
+ z-index: 0;
+ overflow: hidden;
+ pointer-events: none;
+ user-select: none;
+ }
+ .avatar {
+ position: absolute;
+ display: block;
+ width: var(--size);
+ height: var(--size);
+ overflow: hidden;
+ border-radius: 999px;
+ opacity: var(--avatar-opacity);
+ box-shadow: var(--avatar-shadow);
+ animation: avatar-drift var(--duration) var(--ease) var(--delay) infinite alternate;
+ will-change: transform;
+ }
+ .avatar svg { display: block; width: 100%; height: 100%; }
+ .avatar-1 { --size: 88px; --duration: 17s; --delay: -8s; --dx: 26px; --dy: 18px; --turn: 7deg; top: 5%; left: -28px; }
+ .avatar-2 { --size: 58px; --duration: 23s; --delay: -13s; --dx: -18px; --dy: 30px; --turn: -9deg; top: 12%; right: 2%; }
+ .avatar-3 { --size: 74px; --duration: 19s; --delay: -4s; --dx: 24px; --dy: -22px; --turn: 10deg; top: 34%; left: 2%; }
+ .avatar-4 { --size: 98px; --duration: 29s; --delay: -19s; --dx: -30px; --dy: 24px; --turn: -6deg; top: 49%; right: -42px; }
+ .avatar-5 { --size: 70px; --duration: 21s; --delay: -11s; --dx: 28px; --dy: -18px; --turn: 8deg; bottom: 12%; left: -24px; }
+ .avatar-6 { --size: 54px; --duration: 25s; --delay: -16s; --dx: -16px; --dy: -28px; --turn: -11deg; right: 5%; bottom: 5%; }
+ .avatar-7 { --size: 46px; --duration: 18s; --delay: -6s; --dx: 18px; --dy: 20px; --turn: 12deg; bottom: 28%; left: 62%; }
+ main { position: relative; z-index: 1; width: min(100%, 400px); }
+ .brand { display: flex; align-items: center; justify-content: center; gap: 12px; margin-bottom: 24px; }
+ .brand-mark { display: block; width: 48px; height: 48px; overflow: hidden; border-radius: 14px; box-shadow: var(--e1); }
+ .brand-mark svg { display: block; width: 100%; height: 100%; }
+ .brand-name { font-family: "Caveat", cursive; font-size: 30px; font-weight: 700; line-height: 1; letter-spacing: -0.025em; }
+ section {
+ padding: 32px;
+ border: 1px solid var(--border);
+ border-radius: 24px;
+ background: var(--card);
+ box-shadow: var(--e2);
+ text-align: center;
+ }
+ h1 { margin: 0 0 16px; font-size: clamp(28px, 8vw, 32px); font-weight: 650; line-height: 1.15; letter-spacing: -0.025em; }
+ p { margin: 0; color: var(--muted-foreground); font-size: 15px; line-height: 1.6; }
+ button {
+ width: 100%;
+ min-height: 48px;
+ margin-top: 24px;
+ border: 0;
+ border-radius: 10px;
+ padding: 0 20px;
+ background: var(--primary);
+ color: var(--primary-foreground);
+ font: inherit;
+ font-weight: 650;
+ cursor: pointer;
+ transition: background-color 150ms var(--ease), transform 150ms var(--ease);
+ }
+ button:hover { background: var(--button-hover); transform: translateY(-1px); }
+ button:active { transform: translateY(0); }
+ button:focus-visible { outline: 3px solid var(--ring); outline-offset: 3px; }
+ @keyframes avatar-drift {
+ from { transform: translate3d(0, 0, 0) rotate(0); }
+ to { transform: translate3d(var(--dx), var(--dy), 0) rotate(var(--turn)); }
+ }
+ @media (prefers-color-scheme: dark) {
+ :root {
+ --background: oklch(0.16 0.008 60);
+ --foreground: oklch(0.93 0.006 80);
+ --card: oklch(0.21 0.008 60);
+ --muted-foreground: oklch(0.65 0.01 70);
+ --primary: oklch(0.9 0.008 80);
+ --primary-foreground: oklch(0.21 0.008 60);
+ --button-hover: oklch(0.82 0.012 80);
+ --border: oklch(1 0.005 80 / 10%);
+ --ring: oklch(0.55 0.01 60);
+ --e1: 0 1px 3px oklch(0 0 0 / 15%);
+ --e2: 0 12px 24px -8px oklch(0 0 0 / 50%);
+ --avatar-shadow: 0 12px 30px oklch(0 0 0 / 35%);
+ --avatar-opacity: 0.66;
+ }
+ }
+ @media (max-width: 639px) {
+ body { padding-right: max(20px, env(safe-area-inset-right)); padding-left: max(20px, env(safe-area-inset-left)); }
+ section { padding: 32px 24px; }
+ .avatar-3 { left: -20px; }
+ .avatar-7 { left: 58%; }
+ }
+ @media (prefers-reduced-motion: reduce) {
+ .avatar { animation: none; transform: none; will-change: auto; }
+ button { transition: none; }
+ }
+`;
+
+function returnPage(valid: boolean): string {
+ const detail = valid
+ ? "Continue in the Alook app to finish this sign-in."
+ : "This sign-in link is invalid.";
+ const control = valid
+ ? `<button type="button" data-open-alook>Open Alook</button><script>${RETURN_SCRIPT}</script>`
+ : "";
+ return `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><meta name="color-scheme" content="light dark"><title>Return to Alook</title><style>${PAGE_STYLE}</style></head><body>${AVATAR_FIELD}<main><div class="brand"><span class="brand-mark" aria-hidden="true">${ALOOK_LOGO}</span><span class="brand-name">Alook</span></div><section aria-labelledby="return-title"><h1 id="return-title">Return to Alook</h1><p>${detail}</p>${control}</section></main></body></html>`;
+}
+
+function response(
+ request: Request,
+ body: BodyInit | null,
+ init: ResponseInit,
+): Response {
+ const headers = new Headers(init.headers);
+ for (const [name, value] of Object.entries(SECURITY_HEADERS)) {
+ headers.set(name, value);
+ }
+ return new Response(request.method === "HEAD" ? null : body, {
+ ...init,
+ headers,
+ });
+}
+
+function notFound(request: Request): Response {
+ return response(request, "Not Found", {
+ status: 404,
+ headers: { "Content-Type": "text/plain; charset=utf-8" },
+ });
+}
+
+function json(request: Request, value: unknown): Response {
+ return response(request, JSON.stringify(value), {
+ status: 200,
+ headers: { "Content-Type": "application/json; charset=utf-8" },
+ });
+}
+
+function hasValidReturnQuery(url: URL): boolean {
+ if (url.search.length > 512) return false;
+ const keys = [...url.searchParams.keys()];
+ if (keys.some((key) => !RETURN_QUERY_KEYS.has(key))) return false;
+
+ const attempts = url.searchParams.getAll("attempt");
+ const codes = url.searchParams.getAll("code");
+ const statuses = url.searchParams.getAll("status");
+ if (attempts.length !== 1 || !ATTEMPT_ID.test(attempts[0]!)) return false;
+
+ const validCode = codes.length === 1
+ && statuses.length === 0
+ && HANDOFF_CODE.test(codes[0]!);
+ const validStatus = statuses.length === 1
+ && codes.length === 0
+ && FAILURE_CODES.has(statuses[0]!);
+ return validCode || validStatus;
+}
+
+function html(request: Request, valid: boolean): Response {
+ return response(request, returnPage(valid), {
+ status: 200,
+ headers: {
+ "Content-Type": "text/html; charset=utf-8",
+ "Content-Security-Policy": RETURN_CSP,
+ },
+ });
+}
+
+export function handleRequest(request: Request): Response {
+ const url = new URL(request.url);
+ if (
+ url.protocol !== "https:"
+ || url.hostname !== AUTH_WORKER_HOST
+ || url.port !== ""
+ || (request.method !== "GET" && request.method !== "HEAD")
+ ) {
+ return notFound(request);
+ }
+
+ if (url.pathname === AUTH_WORKER_AASA_PATH && url.search === "") {
+ return json(request, APPLE_APP_SITE_ASSOCIATION);
+ }
+ if (url.pathname === AUTH_WORKER_ASSET_LINKS_PATH && url.search === "") {
+ return json(request, ANDROID_ASSET_LINKS);
+ }
+ if (url.pathname === AUTH_WORKER_RETURN_PATH) {
+ return html(request, hasValidReturnQuery(url));
+ }
+ return notFound(request);
+}
+
+const authWorker = {
+ fetch(request: Request): Response {
+ return handleRequest(request);
+ },
+};
+
+export default authWorker;
diff --git a/src/web/auth/test-runtime/worker.runtime.test.ts b/src/web/auth/test-runtime/worker.runtime.test.ts
new file mode 100644
index 000000000..3a4fefe61
--- /dev/null
+++ b/src/web/auth/test-runtime/worker.runtime.test.ts
@@ -0,0 +1,71 @@
+/// <reference types="@cloudflare/vitest-plugin/types" />
+
+import { exports } from "cloudflare:workers";
+import { describe, expect, it } from "vitest";
+
+const worker = (exports as unknown as {
+ default: { fetch(request: Request): Promise<Response> };
+}).default;
+
+const ATTEMPT = "attempt_1234567890123456";
+const CODE = "c".repeat(32);
+
+describe("alook-auth workerd runtime", () => {
+ it("serves an exact association resource without bindings", async () => {
+ const response = await worker.fetch(new Request(
+ "https://auth.alook.ai/.well-known/apple-app-site-association",
+ ));
+ expect(response.status).toBe(200);
+ expect(response.headers.get("Cache-Control")).toBe("no-store, max-age=0");
+ await expect(response.json()).resolves.toMatchObject({
+ applinks: { details: [{ appID: "5RF24VHDQB.ai.alook.ios" }] },
+ });
+ });
+
+ it("keeps a real handoff code out of the rendered fallback DOM source", async () => {
+ const response = await worker.fetch(new Request(
+ `https://auth.alook.ai/auth/native/return?attempt=${ATTEMPT}&code=${CODE}`,
+ ));
+ const body = await response.text();
+ expect(response.status).toBe(200);
+ expect(body).toContain("data-open-alook");
+ expect(body).toContain('data-state="default"');
+ expect(body).toContain('class="avatar-field" aria-hidden="true"');
+ expect(body.match(/class="avatar avatar-\d"/g)).toHaveLength(7);
+ expect(body).toContain('font-family: "DM Sans", ui-sans-serif');
+ expect(body).toContain('font-family: "Caveat", cursive; font-size: 30px; font-weight: 700;');
+ expect(body.match(/data:font\/woff2;base64,/g)).toHaveLength(2);
+ expect(response.headers.get("Content-Security-Policy")?.split("; "))
+ .toContain("font-src data:");
+ expect(body).toContain("@media (prefers-color-scheme: dark)");
+ expect(body).toContain("@media (prefers-reduced-motion: reduce)");
+ expect(body).not.toMatch(/<(?:img|link)\b/i);
+ expect(body).not.toContain(ATTEMPT);
+ expect(body).not.toContain(CODE);
+ expect(body).not.toMatch(/href=["']ai\.alook:/);
+ });
+
+ it("keeps the branded frame but no control for an invalid return", async () => {
+ const response = await worker.fetch(new Request(
+ "https://auth.alook.ai/auth/native/return",
+ ));
+ const body = await response.text();
+ expect(response.status).toBe(200);
+ expect(body).toContain('data-state="default"');
+ expect(body).toContain('class="avatar-field" aria-hidden="true"');
+ expect(body).toContain("This sign-in link is invalid.");
+ expect(body).not.toContain("expired");
+ expect(body).not.toContain("data-open-alook");
+ expect(body).not.toContain("<script>");
+ });
+
+ it("returns a bodyless private 404 before any other runtime for a disallowed request", async () => {
+ const response = await worker.fetch(new Request(
+ "https://auth.alook.ai/sign-in?code=secret",
+ { method: "HEAD" },
+ ));
+ expect(response.status).toBe(404);
+ expect(response.headers.get("Cache-Control")).toBe("no-store, max-age=0");
+ expect(await response.text()).toBe("");
+ });
+});
diff --git a/src/web/auth/tsconfig.json b/src/web/auth/tsconfig.json
new file mode 100644
index 000000000..b9128c84b
--- /dev/null
+++ b/src/web/auth/tsconfig.json
@@ -0,0 +1,12 @@
+{
+ "extends": "../tsconfig.json",
+ "compilerOptions": {
+ "allowJs": false,
+ "incremental": false,
+ "lib": ["DOM", "ES2024"],
+ "plugins": [],
+ "types": ["node"]
+ },
+ "include": ["index.ts"],
+ "exclude": ["node_modules", "**/*.test.ts", "test-runtime"]
+}
diff --git a/src/web/auth/vitest.config.ts b/src/web/auth/vitest.config.ts
new file mode 100644
index 000000000..80a895e10
--- /dev/null
+++ b/src/web/auth/vitest.config.ts
@@ -0,0 +1,12 @@
+import { defineConfig, mergeConfig } from "vitest/config";
+import shared from "../../../vitest.shared";
+
+export default mergeConfig(shared, defineConfig({
+ root: import.meta.dirname,
+ test: {
+ name: "auth-node",
+ include: ["**/*.test.ts"],
+ exclude: ["test-runtime/**"],
+ sequence: { groupOrder: 2 },
+ },
+}));
diff --git a/src/web/auth/vitest.runtime.config.mts b/src/web/auth/vitest.runtime.config.mts
new file mode 100644
index 000000000..db79b4545
--- /dev/null
+++ b/src/web/auth/vitest.runtime.config.mts
@@ -0,0 +1,16 @@
+import { cloudflareTest } from "@cloudflare/vitest-plugin";
+import { defineProject } from "vitest/config";
+
+export default defineProject({
+ root: import.meta.dirname,
+ plugins: [
+ cloudflareTest({
+ wrangler: { configPath: "./wrangler.toml" },
+ }),
+ ],
+ test: {
+ name: "auth-runtime",
+ include: ["test-runtime/**/*.runtime.test.ts"],
+ sequence: { groupOrder: 14 },
+ },
+});
diff --git a/src/web/auth/wrangler.test.ts b/src/web/auth/wrangler.test.ts
new file mode 100644
index 000000000..47c2f40c3
--- /dev/null
+++ b/src/web/auth/wrangler.test.ts
@@ -0,0 +1,39 @@
+import { readFileSync } from "node:fs";
+import { describe, expect, it } from "vitest";
+import authVitestConfig from "./vitest.config";
+
+const config = readFileSync(new URL("./wrangler.toml", import.meta.url), "utf8");
+
+describe("alook-auth Wrangler contract", () => {
+ it("keeps the standalone node test project isolated from runtime tests", () => {
+ expect(authVitestConfig).toMatchObject({
+ root: import.meta.dirname,
+ test: {
+ name: "auth-node",
+ include: ["**/*.test.ts"],
+ exclude: ["test-runtime/**"],
+ sequence: { groupOrder: 2 },
+ },
+ });
+ });
+
+ it("locks the standalone worker name and public surface", () => {
+ expect(config).toContain('name = "alook-auth"');
+ expect(config).toContain('main = "index.ts"');
+ expect(config).toContain('pattern = "auth.alook.ai"');
+ expect(config).toContain("custom_domain = true");
+ expect(config).toContain("workers_dev = false");
+ expect(config).toContain("preview_urls = false");
+ });
+
+ it("disables persisted, invocation, custom, and trace telemetry", () => {
+ expect(config).toMatch(/\[observability\]\nenabled = false\nhead_sampling_rate = 0/);
+ expect(config).toMatch(/\[observability\.logs\]\nenabled = false\ninvocation_logs = false\nhead_sampling_rate = 0/);
+ expect(config).toMatch(/\[observability\.traces\]\nenabled = false\nhead_sampling_rate = 0/);
+ expect(config).not.toContain("destinations");
+ });
+
+ it("declares no state, service, asset, queue, or secret bindings", () => {
+ expect(config).not.toMatch(/\[(?:assets|vars|d1_databases|r2_buckets|kv_namespaces|services|queues|durable_objects|secrets)/);
+ });
+});
diff --git a/src/web/auth/wrangler.toml b/src/web/auth/wrangler.toml
new file mode 100644
index 000000000..ec7232494
--- /dev/null
+++ b/src/web/auth/wrangler.toml
@@ -0,0 +1,22 @@
+name = "alook-auth"
+main = "index.ts"
+compatibility_date = "2026-08-27"
+workers_dev = false
+preview_urls = false
+
+[observability]
+enabled = false
+head_sampling_rate = 0
+
+[observability.logs]
+enabled = false
+invocation_logs = false
+head_sampling_rate = 0
+
+[observability.traces]
+enabled = false
+head_sampling_rate = 0
+
+[[routes]]
+pattern = "auth.alook.ai"
+custom_domain = true
diff --git a/src/web/knip.json b/src/web/knip.json
index e23d9ad4d..a195a4856 100644
--- a/src/web/knip.json
+++ b/src/web/knip.json
@@ -21,9 +21,10 @@
"blog/next.config.ts",
"blog/open-next.config.ts",
"blog/scripts/**/*.ts",
+ "auth/index.ts",
"scripts/**/*.{ts,mjs}"
],
- "project": ["src/**/*.{ts,tsx}", "blog/**/*.{ts,tsx}", "scripts/**/*.{ts,mjs}", "test-runtime/**/*.ts"],
+ "project": ["src/**/*.{ts,tsx}", "blog/**/*.{ts,tsx}", "auth/**/*.{ts,tsx,mts}", "scripts/**/*.{ts,mjs}", "test-runtime/**/*.ts"],
"ignoreDependencies": [
"@tailwindcss/node",
"cloudflare",
@@ -41,7 +42,7 @@
"src/app/(app)/workspaces/client.tsx"
],
"vitest": {
- "entry": ["src/**/*.test.{ts,tsx}", "blog/**/*.test.{ts,tsx}", "scripts/**/*.test.ts", "src/test/**/*.{ts,tsx}", "test-runtime/**/*.test.ts"]
+ "entry": ["src/**/*.test.{ts,tsx}", "blog/**/*.test.{ts,tsx}", "auth/**/*.test.ts", "scripts/**/*.test.ts", "src/test/**/*.{ts,tsx}", "test-runtime/**/*.test.ts"]
},
"eslint": {
"entry": ["eslint.config.mjs"]
diff --git a/src/web/migrations/0095_native_oauth_attempt.sql b/src/web/migrations/0095_native_oauth_attempt.sql
new file mode 100644
index 000000000..8eeefe80f
--- /dev/null
+++ b/src/web/migrations/0095_native_oauth_attempt.sql
@@ -0,0 +1,139 @@
+CREATE TABLE native_oauth_attempt (
+ id TEXT PRIMARY KEY NOT NULL,
+ instance_key_hash TEXT NOT NULL,
+ state_hash TEXT NOT NULL,
+ pkce_challenge TEXT NOT NULL,
+ provider TEXT NOT NULL,
+ platform TEXT NOT NULL,
+ redirect_path TEXT NOT NULL,
+ status TEXT NOT NULL DEFAULT 'pending',
+ handoff_code_hash TEXT,
+ handoff_expires_at INTEGER,
+ auth_kind TEXT,
+ failure_code TEXT,
+ attempt_expires_at INTEGER NOT NULL,
+ created_at INTEGER NOT NULL,
+ updated_at INTEGER NOT NULL,
+ opened_at INTEGER,
+ ready_at INTEGER,
+ consumed_at INTEGER,
+ failed_at INTEGER,
+ cancelled_at INTEGER,
+ replaced_at INTEGER,
+ CONSTRAINT ck_native_oauth_attempt_id CHECK (
+ length(id) BETWEEN 22 AND 64
+ AND id NOT GLOB '*[^A-Za-z0-9_-]*'
+ ),
+ CONSTRAINT ck_native_oauth_attempt_hashes CHECK (
+ length(instance_key_hash) = 64
+ AND instance_key_hash NOT GLOB '*[^0-9a-f]*'
+ AND length(state_hash) = 64
+ AND state_hash NOT GLOB '*[^0-9a-f]*'
+ AND length(pkce_challenge) = 43
+ AND pkce_challenge NOT GLOB '*[^A-Za-z0-9_-]*'
+ AND (
+ handoff_code_hash IS NULL
+ OR (
+ length(handoff_code_hash) = 64
+ AND handoff_code_hash NOT GLOB '*[^0-9a-f]*'
+ )
+ )
+ ),
+ CONSTRAINT ck_native_oauth_attempt_enums CHECK (
+ provider IN ('github', 'google')
+ AND platform IN ('macos', 'windows', 'linux', 'ios', 'android')
+ AND status IN (
+ 'pending', 'opened', 'ready', 'exchanging',
+ 'consumed', 'failed', 'cancelled', 'replaced'
+ )
+ AND (auth_kind IS NULL OR auth_kind IN ('signin', 'signup'))
+ AND (
+ failure_code IS NULL
+ OR failure_code IN (
+ 'access_denied', 'provider_error', 'oauth_callback_failed',
+ 'start_failed', 'invalid_handoff'
+ )
+ )
+ ),
+ CONSTRAINT ck_native_oauth_attempt_redirect CHECK (
+ length(redirect_path) BETWEEN 1 AND 2048
+ AND substr(redirect_path, 1, 1) = '/'
+ AND substr(redirect_path, 1, 2) <> '//'
+ AND instr(redirect_path, char(92)) = 0
+ ),
+ CONSTRAINT ck_native_oauth_attempt_epochs CHECK (
+ typeof(created_at) = 'integer'
+ AND created_at BETWEEN 0 AND 9007199254740991
+ AND typeof(updated_at) = 'integer'
+ AND updated_at BETWEEN created_at AND 9007199254740991
+ AND typeof(attempt_expires_at) = 'integer'
+ AND attempt_expires_at = created_at + 600000
+ AND (
+ handoff_expires_at IS NULL
+ OR (
+ typeof(handoff_expires_at) = 'integer'
+ AND handoff_expires_at <= attempt_expires_at
+ )
+ )
+ ),
+ CONSTRAINT ck_native_oauth_attempt_state CHECK (
+ (
+ status = 'pending'
+ AND opened_at IS NULL AND ready_at IS NULL AND consumed_at IS NULL
+ AND failed_at IS NULL AND cancelled_at IS NULL AND replaced_at IS NULL
+ AND handoff_code_hash IS NULL AND handoff_expires_at IS NULL
+ AND auth_kind IS NULL AND failure_code IS NULL
+ ) OR (
+ status = 'opened'
+ AND opened_at IS NOT NULL AND ready_at IS NULL AND consumed_at IS NULL
+ AND failed_at IS NULL AND cancelled_at IS NULL AND replaced_at IS NULL
+ AND handoff_code_hash IS NULL AND handoff_expires_at IS NULL
+ AND auth_kind IS NULL AND failure_code IS NULL
+ ) OR (
+ status IN ('ready', 'exchanging')
+ AND opened_at IS NOT NULL AND ready_at IS NOT NULL AND consumed_at IS NULL
+ AND failed_at IS NULL AND cancelled_at IS NULL AND replaced_at IS NULL
+ AND handoff_code_hash IS NOT NULL AND handoff_expires_at IS NOT NULL
+ AND handoff_expires_at = ready_at + 120000
+ AND auth_kind IS NOT NULL AND failure_code IS NULL
+ ) OR (
+ status = 'consumed'
+ AND opened_at IS NOT NULL AND ready_at IS NOT NULL AND consumed_at IS NOT NULL
+ AND failed_at IS NULL AND cancelled_at IS NULL AND replaced_at IS NULL
+ AND handoff_code_hash IS NOT NULL AND handoff_expires_at IS NOT NULL
+ AND auth_kind IS NOT NULL AND failure_code IS NULL
+ ) OR (
+ status = 'failed'
+ AND consumed_at IS NULL AND failed_at IS NOT NULL
+ AND cancelled_at IS NULL AND replaced_at IS NULL
+ AND failure_code IS NOT NULL
+ ) OR (
+ status = 'cancelled'
+ AND consumed_at IS NULL AND cancelled_at IS NOT NULL
+ AND failed_at IS NULL AND replaced_at IS NULL
+ AND failure_code IS NULL
+ ) OR (
+ status = 'replaced'
+ AND consumed_at IS NULL AND replaced_at IS NOT NULL
+ AND failed_at IS NULL AND cancelled_at IS NULL
+ AND failure_code IS NULL
+ )
+ )
+) WITHOUT ROWID;
+
+CREATE INDEX idx_native_oauth_attempt_instance_status
+ ON native_oauth_attempt(instance_key_hash, status);
+
+CREATE INDEX idx_native_oauth_attempt_id_status_expiry
+ ON native_oauth_attempt(id, status, attempt_expires_at);
+
+CREATE INDEX idx_native_oauth_attempt_terminal_cleanup
+ ON native_oauth_attempt(status, updated_at);
+
+CREATE UNIQUE INDEX uq_native_oauth_attempt_instance_live
+ ON native_oauth_attempt(instance_key_hash)
+ WHERE status IN ('pending', 'opened', 'ready', 'exchanging');
+
+CREATE UNIQUE INDEX uq_native_oauth_attempt_handoff_hash
+ ON native_oauth_attempt(handoff_code_hash)
+ WHERE handoff_code_hash IS NOT NULL;
diff --git a/src/web/package.json b/src/web/package.json
index 97750763e..026b0b81b 100644
--- a/src/web/package.json
+++ b/src/web/package.json
@@ -6,20 +6,24 @@
"dev": "node scripts/dev-zones.mjs",
"dev:main": "node ../../scripts/dev-with-wrangler-registry.mjs ../../.wrangler/registry next dev --hostname 127.0.0.1 --port 3001",
"dev:blog": "node ../../scripts/dev-with-wrangler-registry.mjs ../../.wrangler/registry next dev blog --hostname 127.0.0.1 --port 3002",
+ "dev:auth": "wrangler dev --config auth/wrangler.toml",
"dev:zones:worker": "node scripts/dev-zones.mjs --worker",
"build": "next build",
"build:blog:next": "tsx blog/scripts/stage-shared-assets.ts && next build blog && tsx blog/scripts/prepare-open-next-standalone.ts",
"build:blog": "tsx blog/scripts/stage-shared-assets.ts && opennextjs-cloudflare build --config blog/wrangler.toml --openNextConfigPath blog/open-next.config.ts",
+ "build:auth": "wrangler deploy --dry-run --config auth/wrangler.toml --outdir dist",
"validate:blog": "tsx blog/scripts/validate-blog-assets.ts",
"verify:blog-dry-run": "tsx scripts/verify-blog-dry-run.ts",
"verify:zone-output": "tsx scripts/verify-zone-output.ts",
"preflight:bug-reports": "tsx scripts/preflight-bug-reports.ts",
"start": "next start",
- "lint": "eslint src/ blog/ scripts/",
+ "lint": "eslint src/ blog/ auth/ scripts/",
"deploy": "opennextjs-cloudflare build && opennextjs-cloudflare deploy",
"deploy:blog": "pnpm build:blog && opennextjs-cloudflare deploy --config blog/wrangler.toml",
+ "deploy:auth": "wrangler deploy --config auth/wrangler.toml",
"upload": "opennextjs-cloudflare build && opennextjs-cloudflare upload",
"upload:blog": "pnpm build:blog && opennextjs-cloudflare upload --config blog/wrangler.toml",
+ "upload:auth": "wrangler versions upload --config auth/wrangler.toml",
"preview": "opennextjs-cloudflare build && opennextjs-cloudflare preview",
"cf-typegen": "wrangler types --env-interface CloudflareEnv ./cloudflare-env.d.ts",
"test": "vitest run --config vitest.workspace.config.ts",
@@ -30,7 +34,7 @@
"knip": "knip",
"seed:stress": "tsx scripts/seed-stress.ts",
"perf:switch": "tsx scripts/perf-report.ts --clear && playwright test --config playwright.perf.config.ts && tsx scripts/perf-report.ts",
- "typecheck": "tsc --noEmit && tsc --noEmit -p blog/tsconfig.json",
+ "typecheck": "tsc --noEmit && tsc --noEmit -p blog/tsconfig.json && tsc --noEmit -p auth/tsconfig.json",
"seo:check": "lhci autorun --config=lighthouserc.json && node scripts/print-lighthouse-scores.mjs"
},
"dependencies": {
diff --git a/src/web/src/app/api/auth/[...all]/route.test.ts b/src/web/src/app/api/auth/[...all]/route.test.ts
new file mode 100644
index 000000000..de9efab3a
--- /dev/null
+++ b/src/web/src/app/api/auth/[...all]/route.test.ts
@@ -0,0 +1,51 @@
+import { NextRequest } from "next/server"
+import { beforeEach, describe, expect, it, vi } from "vitest"
+
+const betterAuthGet = vi.fn()
+const betterAuthPost = vi.fn()
+
+vi.mock("@/lib/middleware/env", () => ({
+ withEnv:
+ (route: (request: NextRequest, context: { env: object }) => Promise<Response>) =>
+ (request: NextRequest) => route(request, { env: {} }),
+}))
+vi.mock("@/lib/auth", () => ({ createAuth: () => ({}) }))
+vi.mock("better-auth/next-js", () => ({
+ toNextJsHandler: () => ({ GET: betterAuthGet, POST: betterAuthPost }),
+}))
+
+import { GET, POST } from "./route"
+
+describe("Better Auth server-only endpoints", () => {
+ beforeEach(() => {
+ betterAuthGet.mockReset()
+ betterAuthPost.mockReset()
+ })
+
+ it.each([
+ ["GET", "/api/auth/one-time-token/generate"],
+ ["POST", "/api/auth/one-time-token/verify"],
+ ["POST", "/api/auth/one-time-token/verify/"],
+ ])("blocks public %s %s before Better Auth", async (method, pathname) => {
+ const request = new NextRequest(`https://alook.ai${pathname}`, { method })
+ const response = method === "GET" ? await GET(request) : await POST(request)
+
+ expect(response.status).toBe(404)
+ expect(response.headers.get("Cache-Control")).toContain("no-store")
+ expect(response.headers.get("Referrer-Policy")).toBe("no-referrer")
+ expect(betterAuthGet).not.toHaveBeenCalled()
+ expect(betterAuthPost).not.toHaveBeenCalled()
+ })
+
+ it("keeps ordinary Better Auth routes delegated", async () => {
+ betterAuthPost.mockResolvedValue(new Response(null, { status: 204 }))
+ const request = new NextRequest("https://alook.ai/api/auth/sign-in/email", {
+ method: "POST",
+ })
+
+ const response = await POST(request)
+
+ expect(response.status).toBe(204)
+ expect(betterAuthPost).toHaveBeenCalledOnce()
+ })
+})
diff --git a/src/web/src/app/api/auth/[...all]/route.ts b/src/web/src/app/api/auth/[...all]/route.ts
index 16aa71ba0..40cdaff9f 100644
--- a/src/web/src/app/api/auth/[...all]/route.ts
+++ b/src/web/src/app/api/auth/[...all]/route.ts
@@ -2,11 +2,29 @@ import { NextRequest } from "next/server"
import { toNextJsHandler } from "better-auth/next-js"
import { createAuth } from "@/lib/auth"
import { withEnv } from "@/lib/middleware/env"
+import { nativeOauthSecurityHeaders } from "@/lib/native-oauth"
+
+const SERVER_ONLY_AUTH_PREFIX = "/api/auth/one-time-token"
+
+function isServerOnlyAuthRequest(request: NextRequest): boolean {
+ const pathname = request.nextUrl.pathname.replace(/\/+$/, "")
+ return pathname === SERVER_ONLY_AUTH_PREFIX
+ || pathname.startsWith(`${SERVER_ONLY_AUTH_PREFIX}/`)
+}
+
+function notFound(): Response {
+ return new Response(null, {
+ status: 404,
+ headers: nativeOauthSecurityHeaders,
+ })
+}
export const GET = withEnv(async (req: NextRequest, ctx) => {
+ if (isServerOnlyAuthRequest(req)) return notFound()
return toNextJsHandler(createAuth(ctx.env)).GET(req)
});
export const POST = withEnv(async (req: NextRequest, ctx) => {
+ if (isServerOnlyAuthRequest(req)) return notFound()
return toNextJsHandler(createAuth(ctx.env)).POST(req)
});
diff --git a/src/web/src/app/api/auth/native/attempt/route.ts b/src/web/src/app/api/auth/native/attempt/route.ts
new file mode 100644
index 000000000..4ccd34b0f
--- /dev/null
+++ b/src/web/src/app/api/auth/native/attempt/route.ts
@@ -0,0 +1,67 @@
+import {
+ createLogger,
+ isUniqueConstraintError,
+ queries,
+} from "@alook/shared";
+import { getPrimaryDb } from "@/lib/db";
+import { withEnv } from "@/lib/middleware/env";
+import {
+ nativeOauthJson,
+ nativeOauthRegistrationSchema,
+ nativeOauthStartUrl,
+ parseNativeOauthJson,
+ sha256Hex,
+} from "@/lib/native-oauth";
+import { checkRateLimit } from "@/lib/rate-limit";
+
+const log = createLogger({ service: "native-oauth/attempt" });
+
+export const POST = withEnv(async (request, ctx) => {
+ const parsed = await parseNativeOauthJson(
+ request,
+ ctx.env.BETTER_AUTH_URL,
+ nativeOauthRegistrationSchema,
+ );
+ if (!parsed.ok) return parsed.response;
+
+ const clientKey = await sha256Hex(
+ request.headers.get("CF-Connecting-IP") ?? "unknown",
+ );
+ const rate = await checkRateLimit(ctx.env, "auth:nativeAttempt", clientKey);
+ if (!rate.allowed) {
+ const headers = new Headers();
+ if (rate.retryAfterSec !== undefined) {
+ headers.set("Retry-After", String(rate.retryAfterSec));
+ }
+ return nativeOauthJson({ error: "rate_limited" }, { status: 429, headers });
+ }
+
+ try {
+ await queries.nativeOauth.registerAttempt(getPrimaryDb(ctx.env.DB), {
+ id: parsed.data.attemptId,
+ instanceKeyHash: parsed.data.instanceKeyHash,
+ stateHash: parsed.data.stateHash,
+ pkceChallenge: parsed.data.codeChallenge,
+ provider: parsed.data.provider,
+ platform: parsed.data.platform,
+ redirectPath: parsed.data.redirectPath,
+ });
+ } catch (error) {
+ if (isUniqueConstraintError(error)) {
+ log.warn("native OAuth attempt registration conflict");
+ return nativeOauthJson({ error: "attempt_conflict" }, { status: 409 });
+ }
+ log.error("native OAuth attempt registration failed");
+ return nativeOauthJson(
+ { error: "temporarily_unavailable" },
+ { status: 503 },
+ );
+ }
+
+ return nativeOauthJson({
+ startUrl: nativeOauthStartUrl(
+ ctx.env.BETTER_AUTH_URL,
+ parsed.data.attemptId,
+ ),
+ });
+});
diff --git a/src/web/src/app/api/auth/native/cancel/route.ts b/src/web/src/app/api/auth/native/cancel/route.ts
new file mode 100644
index 000000000..ae09e45d6
--- /dev/null
+++ b/src/web/src/app/api/auth/native/cancel/route.ts
@@ -0,0 +1,40 @@
+import { createLogger, queries } from "@alook/shared";
+import { getPrimaryDb } from "@/lib/db";
+import { withEnv } from "@/lib/middleware/env";
+import {
+ nativeOauthJson,
+ nativeOauthProofSchema,
+ parseNativeOauthJson,
+ pkceChallenge,
+ sha256Hex,
+} from "@/lib/native-oauth";
+
+const log = createLogger({ service: "native-oauth/cancel" });
+
+export const POST = withEnv(async (request, ctx) => {
+ const parsed = await parseNativeOauthJson(
+ request,
+ ctx.env.BETTER_AUTH_URL,
+ nativeOauthProofSchema,
+ );
+ if (!parsed.ok) return parsed.response;
+
+ let cancelled;
+ try {
+ cancelled = await queries.nativeOauth.cancelAttempt(
+ getPrimaryDb(ctx.env.DB),
+ {
+ attemptId: parsed.data.attemptId,
+ stateHash: await sha256Hex(parsed.data.state),
+ pkceChallenge: await pkceChallenge(parsed.data.verifier),
+ },
+ );
+ } catch {
+ log.error("native OAuth cancellation unavailable");
+ return nativeOauthJson(
+ { error: "temporarily_unavailable" },
+ { status: 503 },
+ );
+ }
+ return nativeOauthJson({ status: cancelled ? "cancelled" : "unchanged" });
+});
diff --git a/src/web/src/app/api/auth/native/exchange/route.ts b/src/web/src/app/api/auth/native/exchange/route.ts
new file mode 100644
index 000000000..3b327dc0f
--- /dev/null
+++ b/src/web/src/app/api/auth/native/exchange/route.ts
@@ -0,0 +1,89 @@
+import { createLogger, queries } from "@alook/shared";
+import { createAuth } from "@/lib/auth";
+import { getPrimaryDb } from "@/lib/db";
+import { withEnv } from "@/lib/middleware/env";
+import {
+ copySetCookieHeaders,
+ nativeOauthExchangeSchema,
+ nativeOauthJson,
+ parseNativeOauthJson,
+ pkceChallenge,
+ setWebViewAnalyticsCookie,
+ sha256Hex,
+} from "@/lib/native-oauth";
+
+const log = createLogger({ service: "native-oauth/exchange" });
+
+export const POST = withEnv(async (request, ctx) => {
+ const parsed = await parseNativeOauthJson(
+ request,
+ ctx.env.BETTER_AUTH_URL,
+ nativeOauthExchangeSchema,
+ );
+ if (!parsed.ok) return parsed.response;
+
+ const proof = {
+ attemptId: parsed.data.attemptId,
+ stateHash: await sha256Hex(parsed.data.state),
+ pkceChallenge: await pkceChallenge(parsed.data.verifier),
+ handoffCodeHash: await sha256Hex(parsed.data.code),
+ };
+ const db = getPrimaryDb(ctx.env.DB);
+ let claimed;
+ try {
+ claimed = await queries.nativeOauth.claimExchange(db, proof);
+ } catch {
+ log.error("native OAuth exchange claim unavailable");
+ return nativeOauthJson(
+ { error: "temporarily_unavailable" },
+ { status: 503 },
+ );
+ }
+ if (!claimed) {
+ return nativeOauthJson({ error: "invalid_handoff" }, { status: 400 });
+ }
+
+ let verifiedHeaders: Headers;
+ try {
+ const verified = await createAuth(ctx.env).api.verifyOneTimeToken({
+ body: { token: parsed.data.code },
+ returnHeaders: true,
+ });
+ verifiedHeaders = verified.headers;
+ } catch {
+ try {
+ await queries.nativeOauth.failExchange(db, claimed.id);
+ } catch {
+ log.error("native OAuth exchange failure update unavailable");
+ }
+ log.warn("native OAuth handoff verification failed");
+ return nativeOauthJson({ error: "invalid_handoff" }, { status: 400 });
+ }
+
+ let consumed;
+ try {
+ consumed = await queries.nativeOauth.finishExchange(db, proof);
+ } catch {
+ log.error("native OAuth exchange finalization unavailable");
+ return nativeOauthJson(
+ { error: "temporarily_unavailable" },
+ { status: 503 },
+ );
+ }
+ if (!consumed) {
+ return nativeOauthJson({ error: "invalid_handoff" }, { status: 409 });
+ }
+
+ const responseHeaders = new Headers();
+ copySetCookieHeaders(verifiedHeaders, responseHeaders);
+ setWebViewAnalyticsCookie(
+ responseHeaders,
+ consumed.authKind === "signup" ? "signup" : "signin",
+ consumed.provider,
+ new URL(ctx.env.BETTER_AUTH_URL).protocol === "https:",
+ );
+ return nativeOauthJson(
+ { redirectPath: consumed.redirectPath },
+ { headers: responseHeaders },
+ );
+});
diff --git a/src/web/src/app/api/auth/native/native-routes.test.ts b/src/web/src/app/api/auth/native/native-routes.test.ts
new file mode 100644
index 000000000..627d5280a
--- /dev/null
+++ b/src/web/src/app/api/auth/native/native-routes.test.ts
@@ -0,0 +1,700 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { pkceChallenge, sha256Hex } from "@/lib/native-oauth";
+
+const BASE_URL = "https://app.alook.ai";
+const ATTEMPT = "attempt_1234567890123456";
+const STATE = "s".repeat(43);
+const VERIFIER = "v".repeat(43);
+const CODE = "c".repeat(32);
+
+const queryMocks = {
+ registerAttempt: vi.fn(),
+ claimStart: vi.fn(),
+ getOpenedAttempt: vi.fn(),
+ attachHandoff: vi.fn(),
+ failOpenedAttempt: vi.fn(),
+ claimExchange: vi.fn(),
+ finishExchange: vi.fn(),
+ failExchange: vi.fn(),
+ cancelAttempt: vi.fn(),
+ getAttemptStatus: vi.fn(),
+};
+const authMocks = {
+ signInSocial: vi.fn(),
+ generateOneTimeToken: vi.fn(),
+ verifyOneTimeToken: vi.fn(),
+};
+const rateLimitMock = vi.fn();
+const db = {};
+const env = { BETTER_AUTH_URL: BASE_URL, DB: {} };
+
+const attemptRow = {
+ id: ATTEMPT,
+ provider: "github",
+ platform: "ios",
+ redirectPath: "/c/me",
+ authKind: "signin",
+ status: "opened",
+ attemptExpiresAt: Date.now() + 60_000,
+ handoffExpiresAt: null,
+ failureCode: null,
+};
+
+function installMocks() {
+ vi.doMock("@/lib/middleware/env", () => ({
+ withEnv:
+ (route: (request: Request, context: { env: typeof env }) => Promise<Response>) =>
+ (request: Request) =>
+ route(request, { env }),
+ }));
+ vi.doMock("@/lib/db", () => ({ getPrimaryDb: () => db }));
+ vi.doMock("@/lib/rate-limit", () => ({
+ checkRateLimit: (...args: unknown[]) => rateLimitMock(...args),
+ }));
+ vi.doMock("@/lib/auth", () => ({
+ createAuth: () => ({ api: authMocks }),
+ }));
+ vi.doMock("@alook/shared", async () => {
+ const actual = await vi.importActual<typeof import("@alook/shared")>(
+ "@alook/shared",
+ );
+ return {
+ ...actual,
+ createLogger: () => ({ warn: vi.fn(), error: vi.fn() }),
+ queries: { ...actual.queries, nativeOauth: queryMocks },
+ };
+ });
+}
+
+function post(path: string, body: unknown, origin = BASE_URL): Request {
+ return new Request(`${BASE_URL}${path}`, {
+ method: "POST",
+ headers: {
+ "Content-Type": "application/json",
+ Origin: origin,
+ "CF-Connecting-IP": "203.0.113.7",
+ },
+ body: JSON.stringify(body),
+ });
+}
+
+function proof() {
+ return { attemptId: ATTEMPT, state: STATE, verifier: VERIFIER };
+}
+
+async function loadAttemptRoute() {
+ installMocks();
+ return (await import("./attempt/route")).POST;
+}
+
+async function loadExchangeRoute() {
+ installMocks();
+ return (await import("./exchange/route")).POST;
+}
+
+async function loadStatusRoute() {
+ installMocks();
+ return (await import("./status/route")).POST;
+}
+
+async function loadCancelRoute() {
+ installMocks();
+ return (await import("./cancel/route")).POST;
+}
+
+async function loadStartRoute() {
+ installMocks();
+ return (await import("../../../auth/native/start/route")).GET;
+}
+
+async function loadCallbackRoute() {
+ installMocks();
+ return (await import("../../../auth/native/callback/route")).GET;
+}
+
+describe("native OAuth routes", () => {
+ beforeEach(() => {
+ vi.resetModules();
+ for (const mock of Object.values(queryMocks)) mock.mockReset();
+ for (const mock of Object.values(authMocks)) mock.mockReset();
+ rateLimitMock.mockReset();
+ rateLimitMock.mockResolvedValue({ allowed: true });
+ });
+
+ it("registers a strict same-origin request and returns only the start URL", async () => {
+ queryMocks.registerAttempt.mockResolvedValue(attemptRow);
+ const route = await loadAttemptRoute();
+ const body = {
+ attemptId: ATTEMPT,
+ stateHash: "a".repeat(64),
+ codeChallenge: "p".repeat(43),
+ instanceKeyHash: "b".repeat(64),
+ platform: "ios",
+ provider: "github",
+ redirectPath: "/c/me",
+ };
+ const response = await route(post("/api/auth/native/attempt", body));
+
+ expect(response.status).toBe(200);
+ expect(await response.json()).toEqual({
+ startUrl: `${BASE_URL}/auth/native/start?attempt=${ATTEMPT}`,
+ });
+ expect(queryMocks.registerAttempt).toHaveBeenCalledWith(db, {
+ id: ATTEMPT,
+ instanceKeyHash: body.instanceKeyHash,
+ stateHash: body.stateHash,
+ pkceChallenge: body.codeChallenge,
+ provider: "github",
+ platform: "ios",
+ redirectPath: "/c/me",
+ });
+ expect(response.headers.get("Cache-Control")).toContain("no-store");
+ });
+
+ it("rejects cross-origin registration before rate limit or D1", async () => {
+ const route = await loadAttemptRoute();
+ const response = await route(
+ post("/api/auth/native/attempt", {}, "https://evil.example"),
+ );
+
+ expect(response.status).toBe(403);
+ expect(rateLimitMock).not.toHaveBeenCalled();
+ expect(queryMocks.registerAttempt).not.toHaveBeenCalled();
+ });
+
+ it("rate limits registration by a hashed network key", async () => {
+ rateLimitMock.mockResolvedValue({ allowed: false, retryAfterSec: 9 });
+ const route = await loadAttemptRoute();
+ const response = await route(post("/api/auth/native/attempt", {
+ attemptId: ATTEMPT,
+ stateHash: "a".repeat(64),
+ codeChallenge: "p".repeat(43),
+ instanceKeyHash: "b".repeat(64),
+ platform: "ios",
+ provider: "github",
+ redirectPath: "/c/me",
+ }));
+
+ expect(response.status).toBe(429);
+ expect(response.headers.get("Retry-After")).toBe("9");
+ expect(rateLimitMock).toHaveBeenCalledWith(
+ env,
+ "auth:nativeAttempt",
+ await sha256Hex("203.0.113.7"),
+ );
+ expect(queryMocks.registerAttempt).not.toHaveBeenCalled();
+ });
+
+ it("does not misreport a D1 outage as an attempt collision", async () => {
+ queryMocks.registerAttempt.mockRejectedValue(new Error("D1 unavailable"));
+ const route = await loadAttemptRoute();
+ const response = await route(post("/api/auth/native/attempt", {
+ attemptId: ATTEMPT,
+ stateHash: "a".repeat(64),
+ codeChallenge: "p".repeat(43),
+ instanceKeyHash: "b".repeat(64),
+ platform: "ios",
+ provider: "github",
+ redirectPath: "/c/me",
+ }));
+
+ expect(response.status).toBe(503);
+ expect(await response.json()).toEqual({ error: "temporarily_unavailable" });
+ });
+
+ it("reports a duplicate attempt as a conflict", async () => {
+ const conflict = Object.assign(new Error("duplicate attempt"), {
+ code: "SQLITE_CONSTRAINT_UNIQUE",
+ });
+ queryMocks.registerAttempt.mockRejectedValue(conflict);
+ const route = await loadAttemptRoute();
+ const response = await route(post("/api/auth/native/attempt", {
+ attemptId: ATTEMPT,
+ stateHash: "a".repeat(64),
+ codeChallenge: "p".repeat(43),
+ instanceKeyHash: "b".repeat(64),
+ platform: "ios",
+ provider: "github",
+ redirectPath: "/c/me",
+ }));
+
+ expect(response.status).toBe(409);
+ expect(await response.json()).toEqual({ error: "attempt_conflict" });
+ });
+
+ it("rejects malformed browser start and callback requests before D1", async () => {
+ const start = await loadStartRoute();
+ const invalidStart = await start(
+ new Request(`${BASE_URL}/auth/native/start?attempt=invalid`),
+ );
+ expect(invalidStart.status).toBe(400);
+ expect(queryMocks.claimStart).not.toHaveBeenCalled();
+
+ vi.resetModules();
+ const callback = await loadCallbackRoute();
+ const invalidCallback = await callback(
+ new Request(
+ `${BASE_URL}/auth/native/callback?attempt=${ATTEMPT}&kind=invalid`,
+ ),
+ );
+ expect(invalidCallback.status).toBe(400);
+ expect(queryMocks.getOpenedAttempt).not.toHaveBeenCalled();
+ });
+
+ it("starts OAuth once and forwards every Better Auth cookie", async () => {
+ queryMocks.claimStart
+ .mockResolvedValueOnce(attemptRow)
+ .mockResolvedValueOnce(null);
+ const authHeaders = new Headers();
+ authHeaders.append("Set-Cookie", "oauth_state=one; HttpOnly; Path=/");
+ authHeaders.append("Set-Cookie", "oauth_verifier=two; HttpOnly; Path=/");
+ authMocks.signInSocial.mockResolvedValue({
+ response: { url: "https://github.com/login/oauth/authorize?client_id=x" },
+ headers: authHeaders,
+ });
+ const route = await loadStartRoute();
+ const first = await route(
+ new Request(`${BASE_URL}/auth/native/start?attempt=${ATTEMPT}`),
+ );
+ const second = await route(
+ new Request(`${BASE_URL}/auth/native/start?attempt=${ATTEMPT}`),
+ );
+
+ expect(first.status).toBe(302);
+ expect(first.headers.getSetCookie()).toHaveLength(2);
+ expect(authMocks.signInSocial).toHaveBeenCalledWith(
+ expect.objectContaining({
+ body: expect.objectContaining({
+ provider: "github",
+ disableRedirect: true,
+ callbackURL: `${BASE_URL}/auth/native/callback?attempt=${ATTEMPT}&kind=signin`,
+ }),
+ }),
+ );
+ expect(second.status).toBe(410);
+ expect(authMocks.signInSocial).toHaveBeenCalledOnce();
+ });
+
+ it("fails the opened attempt when the provider start cannot be created", async () => {
+ queryMocks.claimStart.mockResolvedValue(attemptRow);
+ queryMocks.failOpenedAttempt.mockResolvedValue({
+ ...attemptRow,
+ status: "failed",
+ });
+ authMocks.signInSocial.mockResolvedValue({
+ response: { url: null },
+ headers: new Headers(),
+ });
+ const route = await loadStartRoute();
+ const response = await route(
+ new Request(`${BASE_URL}/auth/native/start?attempt=${ATTEMPT}`),
+ );
+
+ expect(response.status).toBe(502);
+ expect(queryMocks.failOpenedAttempt).toHaveBeenCalledWith(
+ db,
+ ATTEMPT,
+ "start_failed",
+ );
+ });
+
+ it("keeps a start D1 outage generic and non-cacheable", async () => {
+ queryMocks.claimStart.mockRejectedValue(new Error("D1 unavailable"));
+ const route = await loadStartRoute();
+ const response = await route(
+ new Request(`${BASE_URL}/auth/native/start?attempt=${ATTEMPT}`),
+ );
+
+ expect(response.status).toBe(503);
+ expect(response.headers.get("Cache-Control")).toContain("no-store");
+ });
+
+ it("hashes the callback handoff and never exposes it in stored form", async () => {
+ queryMocks.getOpenedAttempt.mockResolvedValue(attemptRow);
+ queryMocks.attachHandoff.mockImplementation(async (_db, input) => ({
+ ...attemptRow,
+ ...input,
+ }));
+ authMocks.generateOneTimeToken.mockResolvedValue({
+ response: { token: CODE },
+ headers: new Headers(),
+ });
+ const route = await loadCallbackRoute();
+ const response = await route(
+ new Request(
+ `${BASE_URL}/auth/native/callback?attempt=${ATTEMPT}&kind=signin`,
+ { headers: { Cookie: "better-auth.session_token=browser" } },
+ ),
+ );
+
+ expect(response.status).toBe(302);
+ expect(response.headers.get("Location")).toBe(
+ `https://auth.alook.ai/auth/native/return?attempt=${ATTEMPT}&code=${CODE}`,
+ );
+ expect(queryMocks.attachHandoff).toHaveBeenCalledWith(db, {
+ attemptId: ATTEMPT,
+ handoffCodeHash: await sha256Hex(CODE),
+ authKind: "signin",
+ });
+ expect(response.headers.getSetCookie().join(";")).not.toContain(CODE);
+ });
+
+ it("sanitizes callback errors before storing or returning them", async () => {
+ queryMocks.getOpenedAttempt.mockResolvedValue(attemptRow);
+ const route = await loadCallbackRoute();
+ const response = await route(
+ new Request(
+ `${BASE_URL}/auth/native/callback?attempt=${ATTEMPT}&kind=error&error=raw_provider_secret`,
+ ),
+ );
+
+ expect(queryMocks.failOpenedAttempt).toHaveBeenCalledWith(
+ db,
+ ATTEMPT,
+ "oauth_callback_failed",
+ );
+ expect(response.headers.get("Location")).toContain(
+ "status=oauth_callback_failed",
+ );
+ expect(response.headers.get("Location")).not.toContain("raw_provider_secret");
+ });
+
+ it("returns gone when an opened callback attempt no longer exists", async () => {
+ queryMocks.getOpenedAttempt.mockResolvedValue(null);
+ const route = await loadCallbackRoute();
+ const response = await route(
+ new Request(
+ `${BASE_URL}/auth/native/callback?attempt=${ATTEMPT}&kind=signin`,
+ ),
+ );
+
+ expect(response.status).toBe(410);
+ expect(authMocks.generateOneTimeToken).not.toHaveBeenCalled();
+ });
+
+ it("returns gone when the handoff cannot be attached", async () => {
+ queryMocks.getOpenedAttempt.mockResolvedValue(attemptRow);
+ queryMocks.attachHandoff.mockResolvedValue(null);
+ authMocks.generateOneTimeToken.mockResolvedValue({
+ response: { token: CODE },
+ headers: new Headers(),
+ });
+ const route = await loadCallbackRoute();
+ const response = await route(
+ new Request(
+ `${BASE_URL}/auth/native/callback?attempt=${ATTEMPT}&kind=signin`,
+ ),
+ );
+
+ expect(response.status).toBe(410);
+ });
+
+ it("fails the attempt when callback handoff generation fails", async () => {
+ queryMocks.getOpenedAttempt.mockResolvedValue(attemptRow);
+ queryMocks.failOpenedAttempt.mockResolvedValue({
+ ...attemptRow,
+ status: "failed",
+ });
+ authMocks.generateOneTimeToken.mockRejectedValue(new Error("OTT unavailable"));
+ const route = await loadCallbackRoute();
+ const response = await route(
+ new Request(
+ `${BASE_URL}/auth/native/callback?attempt=${ATTEMPT}&kind=signin`,
+ ),
+ );
+
+ expect(response.status).toBe(302);
+ expect(response.headers.get("Location")).toContain(
+ "status=oauth_callback_failed",
+ );
+ expect(queryMocks.failOpenedAttempt).toHaveBeenCalledWith(
+ db,
+ ATTEMPT,
+ "oauth_callback_failed",
+ );
+ });
+
+ it("keeps a callback D1 outage generic and non-cacheable", async () => {
+ queryMocks.getOpenedAttempt.mockRejectedValue(new Error("D1 unavailable"));
+ const route = await loadCallbackRoute();
+ const response = await route(
+ new Request(
+ `${BASE_URL}/auth/native/callback?attempt=${ATTEMPT}&kind=signin`,
+ ),
+ );
+
+ expect(response.status).toBe(503);
+ expect(response.headers.get("Cache-Control")).toContain("no-store");
+ });
+
+ it("rejects a malformed exchange before D1 or OTT verification", async () => {
+ const route = await loadExchangeRoute();
+ const response = await route(post("/api/auth/native/exchange", {}));
+
+ expect(response.status).toBe(400);
+ expect(queryMocks.claimExchange).not.toHaveBeenCalled();
+ expect(authMocks.verifyOneTimeToken).not.toHaveBeenCalled();
+ });
+
+ it("keeps an exchange claim outage generic and non-cacheable", async () => {
+ queryMocks.claimExchange.mockRejectedValue(new Error("D1 unavailable"));
+ const route = await loadExchangeRoute();
+ const response = await route(
+ post("/api/auth/native/exchange", { ...proof(), code: CODE }),
+ );
+
+ expect(response.status).toBe(503);
+ expect(response.headers.get("Cache-Control")).toContain("no-store");
+ expect(authMocks.verifyOneTimeToken).not.toHaveBeenCalled();
+ });
+
+ it.each([false, true])(
+ "fails a claimed exchange when OTT verification fails (failure update rejects: %s)",
+ async (failureUpdateRejects) => {
+ queryMocks.claimExchange.mockResolvedValue({
+ ...attemptRow,
+ status: "exchanging",
+ });
+ authMocks.verifyOneTimeToken.mockRejectedValue(new Error("invalid OTT"));
+ if (failureUpdateRejects) {
+ queryMocks.failExchange.mockRejectedValue(new Error("D1 unavailable"));
+ } else {
+ queryMocks.failExchange.mockResolvedValue({
+ ...attemptRow,
+ status: "failed",
+ });
+ }
+ const route = await loadExchangeRoute();
+ const response = await route(
+ post("/api/auth/native/exchange", { ...proof(), code: CODE }),
+ );
+
+ expect(response.status).toBe(400);
+ expect(await response.json()).toEqual({ error: "invalid_handoff" });
+ expect(queryMocks.failExchange).toHaveBeenCalledWith(db, ATTEMPT);
+ },
+ );
+
+ it("does not invoke OTT verification or mutate after a wrong exchange proof", async () => {
+ queryMocks.claimExchange.mockResolvedValue(null);
+ const route = await loadExchangeRoute();
+ const response = await route(
+ post("/api/auth/native/exchange", { ...proof(), code: CODE }),
+ );
+
+ expect(response.status).toBe(400);
+ expect(authMocks.verifyOneTimeToken).not.toHaveBeenCalled();
+ expect(queryMocks.finishExchange).not.toHaveBeenCalled();
+ expect(queryMocks.failExchange).not.toHaveBeenCalled();
+ });
+
+ it("releases Better Auth cookies only after the final consume CAS", async () => {
+ const claimed = { ...attemptRow, status: "exchanging" };
+ queryMocks.claimExchange.mockResolvedValue(claimed);
+ queryMocks.finishExchange.mockResolvedValue({
+ ...claimed,
+ status: "consumed",
+ });
+ const headers = new Headers();
+ headers.append("Set-Cookie", "better-auth.session_token=webview; HttpOnly; Path=/");
+ authMocks.verifyOneTimeToken.mockResolvedValue({ headers, response: {} });
+ const route = await loadExchangeRoute();
+ const response = await route(
+ post("/api/auth/native/exchange", { ...proof(), code: CODE }),
+ );
+
+ expect(response.status).toBe(200);
+ expect(await response.json()).toEqual({ redirectPath: "/c/me" });
+ expect(response.headers.getSetCookie().join(";")).toContain(
+ "better-auth.session_token=webview",
+ );
+ expect(response.headers.getSetCookie().join(";")).toContain(
+ "is_sign_in=github",
+ );
+ expect(queryMocks.claimExchange).toHaveBeenCalledWith(db, {
+ attemptId: ATTEMPT,
+ stateHash: await sha256Hex(STATE),
+ pkceChallenge: await pkceChallenge(VERIFIER),
+ handoffCodeHash: await sha256Hex(CODE),
+ });
+ });
+
+ it("lets only one overlapping exchange response release cookies", async () => {
+ const claimed = { ...attemptRow, status: "exchanging" };
+ let releaseClaims!: () => void;
+ const bothClaimsStarted = new Promise<void>((resolve) => {
+ releaseClaims = resolve;
+ });
+ let claimCalls = 0;
+ queryMocks.claimExchange.mockImplementation(async () => {
+ const callIndex = claimCalls;
+ claimCalls += 1;
+ if (claimCalls === 2) releaseClaims();
+ await bothClaimsStarted;
+ return callIndex === 0 ? claimed : null;
+ });
+ queryMocks.finishExchange.mockResolvedValue({
+ ...claimed,
+ status: "consumed",
+ });
+ const headers = new Headers();
+ headers.append("Set-Cookie", "better-auth.session_token=webview; HttpOnly; Path=/");
+ authMocks.verifyOneTimeToken.mockResolvedValue({ headers, response: {} });
+ const route = await loadExchangeRoute();
+
+ const settled = await Promise.allSettled([
+ route(post("/api/auth/native/exchange", { ...proof(), code: CODE })),
+ route(post("/api/auth/native/exchange", { ...proof(), code: CODE })),
+ ]);
+ expect(settled.every((result) => result.status === "fulfilled")).toBe(true);
+ const responses = settled.map((result) => {
+ if (result.status === "rejected") throw result.reason;
+ return result.value;
+ });
+
+ expect(responses.map((response) => response.status).sort()).toEqual([200, 400]);
+ expect(queryMocks.claimExchange).toHaveBeenCalledTimes(2);
+ expect(authMocks.verifyOneTimeToken).toHaveBeenCalledOnce();
+ expect(queryMocks.finishExchange).toHaveBeenCalledOnce();
+ expect(responses.filter((response) =>
+ response.headers.getSetCookie().some((cookie) =>
+ cookie.includes("better-auth.session_token=webview"),
+ ),
+ )).toHaveLength(1);
+ });
+
+ it("drops already-created cookies when cancellation wins the final CAS", async () => {
+ queryMocks.claimExchange.mockResolvedValue({
+ ...attemptRow,
+ status: "exchanging",
+ });
+ queryMocks.finishExchange.mockResolvedValue(null);
+ const headers = new Headers();
+ headers.append("Set-Cookie", "better-auth.session_token=must-not-escape");
+ authMocks.verifyOneTimeToken.mockResolvedValue({ headers, response: {} });
+ const route = await loadExchangeRoute();
+ const response = await route(
+ post("/api/auth/native/exchange", { ...proof(), code: CODE }),
+ );
+
+ expect(response.status).toBe(409);
+ expect(response.headers.getSetCookie()).toEqual([]);
+ });
+
+ it("drops verified cookies when finalization is unavailable", async () => {
+ queryMocks.claimExchange.mockResolvedValue({
+ ...attemptRow,
+ status: "exchanging",
+ });
+ queryMocks.finishExchange.mockRejectedValue(new Error("D1 unavailable"));
+ const headers = new Headers();
+ headers.append("Set-Cookie", "better-auth.session_token=must-not-escape");
+ authMocks.verifyOneTimeToken.mockResolvedValue({ headers, response: {} });
+ const route = await loadExchangeRoute();
+ const response = await route(
+ post("/api/auth/native/exchange", { ...proof(), code: CODE }),
+ );
+
+ expect(response.status).toBe(503);
+ expect(await response.json()).toEqual({ error: "temporarily_unavailable" });
+ expect(response.headers.getSetCookie()).toEqual([]);
+ expect(response.headers.get("Cache-Control")).toContain("no-store");
+ });
+
+ it("reports expiration without mutating the attempt", async () => {
+ queryMocks.getAttemptStatus.mockResolvedValue({
+ ...attemptRow,
+ status: "ready",
+ attemptExpiresAt: Date.now() - 1,
+ });
+ const route = await loadStatusRoute();
+ const response = await route(
+ post("/api/auth/native/status", proof()),
+ );
+
+ expect(await response.json()).toEqual({ status: "expired" });
+ expect(queryMocks.cancelAttempt).not.toHaveBeenCalled();
+ });
+
+ it.each(["ready", "exchanging"])(
+ "reports an expired %s handoff at its shorter deadline",
+ async (status) => {
+ queryMocks.getAttemptStatus.mockResolvedValue({
+ ...attemptRow,
+ status,
+ attemptExpiresAt: Date.now() + 60_000,
+ handoffExpiresAt: Date.now() - 1,
+ });
+ const route = await loadStatusRoute();
+ const response = await route(post("/api/auth/native/status", proof()));
+
+ expect(await response.json()).toEqual({ status: "expired" });
+ expect(queryMocks.cancelAttempt).not.toHaveBeenCalled();
+ },
+ );
+
+ it.each(["consumed", "failed", "cancelled", "replaced"])(
+ "keeps terminal %s authoritative after its deadlines",
+ async (status) => {
+ queryMocks.getAttemptStatus.mockResolvedValue({
+ ...attemptRow,
+ status,
+ attemptExpiresAt: Date.now() - 1,
+ handoffExpiresAt: Date.now() - 1,
+ failureCode: status === "failed" ? "invalid_handoff" : null,
+ });
+ const route = await loadStatusRoute();
+ const response = await route(post("/api/auth/native/status", proof()));
+
+ expect(await response.json()).toEqual({
+ status,
+ ...(status === "failed" ? { failure: "invalid_handoff" } : {}),
+ });
+ },
+ );
+
+ it("keeps a status D1 outage generic and non-cacheable", async () => {
+ queryMocks.getAttemptStatus.mockRejectedValue(new Error("D1 unavailable"));
+ const route = await loadStatusRoute();
+ const response = await route(post("/api/auth/native/status", proof()));
+
+ expect(response.status).toBe(503);
+ expect(await response.json()).toEqual({ error: "temporarily_unavailable" });
+ expect(response.headers.get("Cache-Control")).toContain("no-store");
+ });
+
+ it("makes stale cancellation a proof-bound no-op", async () => {
+ queryMocks.cancelAttempt.mockResolvedValue(null);
+ const route = await loadCancelRoute();
+ const response = await route(
+ post("/api/auth/native/cancel", proof()),
+ );
+
+ expect(await response.json()).toEqual({ status: "unchanged" });
+ expect(queryMocks.cancelAttempt).toHaveBeenCalledWith(db, {
+ attemptId: ATTEMPT,
+ stateHash: await sha256Hex(STATE),
+ pkceChallenge: await pkceChallenge(VERIFIER),
+ });
+ });
+
+ it("rejects malformed cancellation before D1", async () => {
+ const route = await loadCancelRoute();
+ const response = await route(post("/api/auth/native/cancel", {}));
+
+ expect(response.status).toBe(400);
+ expect(queryMocks.cancelAttempt).not.toHaveBeenCalled();
+ });
+
+ it("keeps a cancellation D1 outage generic and non-cacheable", async () => {
+ queryMocks.cancelAttempt.mockRejectedValue(new Error("D1 unavailable"));
+ const route = await loadCancelRoute();
+ const response = await route(
+ post("/api/auth/native/cancel", proof()),
+ );
+
+ expect(response.status).toBe(503);
+ expect(await response.json()).toEqual({ error: "temporarily_unavailable" });
+ expect(response.headers.get("Cache-Control")).toContain("no-store");
+ });
+});
diff --git a/src/web/src/app/api/auth/native/status/route.ts b/src/web/src/app/api/auth/native/status/route.ts
new file mode 100644
index 000000000..dcfd7e881
--- /dev/null
+++ b/src/web/src/app/api/auth/native/status/route.ts
@@ -0,0 +1,54 @@
+import { createLogger, queries } from "@alook/shared";
+import { getPrimaryDb } from "@/lib/db";
+import { withEnv } from "@/lib/middleware/env";
+import {
+ nativeOauthJson,
+ nativeOauthProofSchema,
+ parseNativeOauthJson,
+ pkceChallenge,
+ sha256Hex,
+} from "@/lib/native-oauth";
+
+const log = createLogger({ service: "native-oauth/status" });
+
+export const POST = withEnv(async (request, ctx) => {
+ const parsed = await parseNativeOauthJson(
+ request,
+ ctx.env.BETTER_AUTH_URL,
+ nativeOauthProofSchema,
+ );
+ if (!parsed.ok) return parsed.response;
+
+ let row;
+ try {
+ row = await queries.nativeOauth.getAttemptStatus(
+ getPrimaryDb(ctx.env.DB),
+ {
+ attemptId: parsed.data.attemptId,
+ stateHash: await sha256Hex(parsed.data.state),
+ pkceChallenge: await pkceChallenge(parsed.data.verifier),
+ },
+ );
+ } catch {
+ log.error("native OAuth status unavailable");
+ return nativeOauthJson(
+ { error: "temporarily_unavailable" },
+ { status: 503 },
+ );
+ }
+ if (!row) return nativeOauthJson({ status: "unknown" });
+
+ const now = Date.now();
+ const isLive = ["pending", "opened", "ready", "exchanging"].includes(row.status);
+ const isHandoffLive = row.status === "ready" || row.status === "exchanging";
+ const status = isLive && (
+ row.attemptExpiresAt <= now
+ || (isHandoffLive && (row.handoffExpiresAt ?? 0) <= now)
+ ) ? "expired" : row.status;
+ return nativeOauthJson({
+ status,
+ ...(status === "failed" && row.failureCode
+ ? { failure: row.failureCode }
+ : {}),
+ });
+});
diff --git a/src/web/src/app/auth/native/callback/route.ts b/src/web/src/app/auth/native/callback/route.ts
new file mode 100644
index 000000000..27ce38d6f
--- /dev/null
+++ b/src/web/src/app/auth/native/callback/route.ts
@@ -0,0 +1,95 @@
+import { createLogger, queries } from "@alook/shared";
+import { createAuth } from "@/lib/auth";
+import { getPrimaryDb } from "@/lib/db";
+import { withEnv } from "@/lib/middleware/env";
+import {
+ expireBrowserAnalyticsCookies,
+ isNativeOauthAttemptId,
+ isNativeOauthRequestTarget,
+ nativeOauthHtml,
+ nativeOauthRedirect,
+ nativeOauthReturnUrl,
+ sanitizeOauthFailure,
+ sha256Hex,
+} from "@/lib/native-oauth";
+
+const log = createLogger({ service: "native-oauth/callback" });
+type CallbackKind = "signin" | "signup" | "error";
+
+function isCallbackKind(value: string | null): value is CallbackKind {
+ return value === "signin" || value === "signup" || value === "error";
+}
+
+function errorPage(status: number): Response {
+ return nativeOauthHtml(
+ "<!doctype html><title>Sign-in unavailable</title><p>This sign-in request is unavailable.</p>",
+ { status },
+ );
+}
+
+export const GET = withEnv(async (request, ctx) => {
+ const requestUrl = new URL(request.url);
+ const baseUrl = new URL(ctx.env.BETTER_AUTH_URL);
+ const attemptId = requestUrl.searchParams.get("attempt");
+ const kind = requestUrl.searchParams.get("kind");
+ if (
+ !isNativeOauthRequestTarget(request, ctx.env.BETTER_AUTH_URL) ||
+ !isNativeOauthAttemptId(attemptId) ||
+ !isCallbackKind(kind)
+ ) {
+ return errorPage(400);
+ }
+
+ try {
+ const db = getPrimaryDb(ctx.env.DB);
+ const attempt = await queries.nativeOauth.getOpenedAttempt(db, attemptId);
+ if (!attempt) return errorPage(410);
+
+ if (kind === "error") {
+ const failureCode = sanitizeOauthFailure(requestUrl.searchParams.get("error"));
+ await queries.nativeOauth.failOpenedAttempt(db, attempt.id, failureCode);
+ return nativeOauthRedirect(
+ nativeOauthReturnUrl(attempt.platform, attempt.id, { status: failureCode }),
+ );
+ }
+
+ try {
+ const generated = await createAuth(ctx.env).api.generateOneTimeToken({
+ headers: request.headers,
+ returnHeaders: true,
+ });
+ const handoffCode = generated.response.token;
+ const attached = await queries.nativeOauth.attachHandoff(db, {
+ attemptId: attempt.id,
+ handoffCodeHash: await sha256Hex(handoffCode),
+ authKind: kind,
+ });
+ if (!attached) return errorPage(410);
+
+ const responseHeaders = new Headers(generated.headers);
+ expireBrowserAnalyticsCookies(
+ responseHeaders,
+ baseUrl.protocol === "https:",
+ );
+ return nativeOauthRedirect(
+ nativeOauthReturnUrl(attempt.platform, attempt.id, { code: handoffCode }),
+ responseHeaders,
+ );
+ } catch {
+ await queries.nativeOauth.failOpenedAttempt(
+ db,
+ attempt.id,
+ "oauth_callback_failed",
+ );
+ log.warn("native OAuth handoff generation failed");
+ return nativeOauthRedirect(
+ nativeOauthReturnUrl(attempt.platform, attempt.id, {
+ status: "oauth_callback_failed",
+ }),
+ );
+ }
+ } catch {
+ log.error("native OAuth callback unavailable");
+ return errorPage(503);
+ }
+});
diff --git a/src/web/src/app/auth/native/start/route.ts b/src/web/src/app/auth/native/start/route.ts
new file mode 100644
index 000000000..de095841b
--- /dev/null
+++ b/src/web/src/app/auth/native/start/route.ts
@@ -0,0 +1,58 @@
+import { createLogger, queries } from "@alook/shared";
+import { createAuth } from "@/lib/auth";
+import { getPrimaryDb } from "@/lib/db";
+import { withEnv } from "@/lib/middleware/env";
+import {
+ isNativeOauthAttemptId,
+ isNativeOauthRequestTarget,
+ nativeOauthCallbackUrls,
+ nativeOauthHtml,
+ nativeOauthRedirect,
+} from "@/lib/native-oauth";
+
+const log = createLogger({ service: "native-oauth/start" });
+
+function errorPage(status: number): Response {
+ return nativeOauthHtml(
+ "<!doctype html><title>Sign-in unavailable</title><p>This sign-in request is unavailable.</p>",
+ { status },
+ );
+}
+
+export const GET = withEnv(async (request, ctx) => {
+ const requestUrl = new URL(request.url);
+ const attemptId = requestUrl.searchParams.get("attempt");
+ if (
+ !isNativeOauthRequestTarget(request, ctx.env.BETTER_AUTH_URL) ||
+ !isNativeOauthAttemptId(attemptId)
+ ) {
+ return errorPage(400);
+ }
+
+ try {
+ const db = getPrimaryDb(ctx.env.DB);
+ const attempt = await queries.nativeOauth.claimStart(db, attemptId);
+ if (!attempt) return errorPage(410);
+
+ try {
+ const result = await createAuth(ctx.env).api.signInSocial({
+ body: {
+ provider: attempt.provider,
+ disableRedirect: true,
+ ...nativeOauthCallbackUrls(ctx.env.BETTER_AUTH_URL, attempt.id),
+ },
+ headers: request.headers,
+ returnHeaders: true,
+ });
+ if (!result.response.url) throw new Error("missing provider URL");
+ return nativeOauthRedirect(result.response.url, result.headers);
+ } catch {
+ await queries.nativeOauth.failOpenedAttempt(db, attempt.id, "start_failed");
+ log.warn("native OAuth provider start failed");
+ return errorPage(502);
+ }
+ } catch {
+ log.error("native OAuth start unavailable");
+ return errorPage(503);
+ }
+});
diff --git a/src/web/src/lib/auth.test.ts b/src/web/src/lib/auth.test.ts
index 936fe7008..ccc8e4270 100644
--- a/src/web/src/lib/auth.test.ts
+++ b/src/web/src/lib/auth.test.ts
@@ -8,6 +8,7 @@ vi.mock("better-auth/plugins", () => ({
emailOTP: vi.fn((cfg: unknown) => ({ __plugin: "emailOTP", cfg })),
deviceAuthorization: vi.fn((cfg: unknown) => ({ __plugin: "deviceAuthorization", cfg })),
bearer: vi.fn(() => ({ __plugin: "bearer" })),
+ oneTimeToken: vi.fn((cfg: unknown) => ({ __plugin: "oneTimeToken", cfg })),
}))
// `probeAvailableDiscriminator` (called from the `user.create.before` hook)
@@ -89,7 +90,7 @@ type AuthOptions = {
}
plugins?: Array<{
__plugin?: string
- cfg?: {
+ cfg?: Record<string, unknown> & {
sendVerificationOTP?: (args: { email: string; otp: string; type: string }) => Promise<void>
}
}>
@@ -203,6 +204,25 @@ describe("createAuth rate limiting", () => {
})
})
+describe("createAuth native OAuth handoff", () => {
+ it.each(["production", "development"])(
+ "configures a server-only hashed two-minute OTT in %s",
+ async (nodeEnv) => {
+ const createAuth = await loadCreateAuth()
+ const opts = (createAuth(makeEnv({ NODE_ENV: nodeEnv }) as never) as {
+ __options: AuthOptions
+ }).__options
+ const plugin = opts.plugins?.find((candidate) => candidate.__plugin === "oneTimeToken")
+
+ expect(plugin?.cfg).toMatchObject({
+ expiresIn: 2,
+ disableClientRequest: true,
+ storeToken: "hashed",
+ })
+ },
+ )
+})
+
describe("createAuth session cookie cache", () => {
beforeEach(() => vi.clearAllMocks())
diff --git a/src/web/src/lib/auth.ts b/src/web/src/lib/auth.ts
index 56605736f..744cf4dd6 100644
--- a/src/web/src/lib/auth.ts
+++ b/src/web/src/lib/auth.ts
@@ -1,5 +1,5 @@
import { betterAuth } from "better-auth"
-import { emailOTP, deviceAuthorization, bearer } from "better-auth/plugins"
+import { emailOTP, deviceAuthorization, bearer, oneTimeToken } from "better-auth/plugins"
import { nanoid } from "nanoid"
import {
createLogger,
@@ -222,6 +222,11 @@ export function createAuth(env: Env) {
? [
deviceAuthorization({ verificationUri: "/device", validateClient, expiresIn: "5m", schema: {} }),
bearer(),
+ oneTimeToken({
+ expiresIn: 2,
+ disableClientRequest: true,
+ storeToken: "hashed",
+ }),
emailOTP({
async sendVerificationOTP({ email, otp, type }) {
// Rate-limit BEFORE minting/sending the OTP so abuse can't
@@ -272,6 +277,11 @@ export function createAuth(env: Env) {
: [
deviceAuthorization({ verificationUri: "/device", validateClient, expiresIn: "5m", schema: {} }),
bearer(),
+ oneTimeToken({
+ expiresIn: 2,
+ disableClientRequest: true,
+ storeToken: "hashed",
+ }),
],
})
}
diff --git a/src/web/src/lib/native-oauth.test.ts b/src/web/src/lib/native-oauth.test.ts
new file mode 100644
index 000000000..0c239e03b
--- /dev/null
+++ b/src/web/src/lib/native-oauth.test.ts
@@ -0,0 +1,229 @@
+import { describe, expect, it } from "vitest";
+import {
+ nativeOauthCallbackUrls,
+ nativeOauthExchangeSchema,
+ nativeOauthHtml,
+ nativeOauthJson,
+ nativeOauthRegistrationSchema,
+ nativeOauthReturnUrl,
+ parseNativeOauthJson,
+ pkceChallenge,
+ sanitizeOauthFailure,
+ sha256Hex,
+} from "./native-oauth";
+
+const ATTEMPT = "attempt_1234567890123456";
+const STATE = "A".repeat(43);
+const VERIFIER = "B".repeat(43);
+
+function jsonRequest(body: unknown, origin = "https://alook.ai") {
+ return new Request("https://alook.ai/api/auth/native/attempt", {
+ method: "POST",
+ headers: { "Content-Type": "application/json", Origin: origin },
+ body: JSON.stringify(body),
+ });
+}
+
+describe("native OAuth protocol helpers", () => {
+ it("accepts the exact registration shape and rejects unknown fields", () => {
+ const value = {
+ attemptId: ATTEMPT,
+ stateHash: "a".repeat(64),
+ codeChallenge: "C".repeat(43),
+ instanceKeyHash: "b".repeat(64),
+ platform: "ios",
+ provider: "github",
+ redirectPath: "/c/me?from=native",
+ };
+ expect(nativeOauthRegistrationSchema.safeParse(value).success).toBe(true);
+ expect(nativeOauthRegistrationSchema.safeParse({ ...value, state: STATE }).success).toBe(false);
+ });
+
+ it("requires same-origin JSON and bounds the request body", async () => {
+ const invalidOrigin = await parseNativeOauthJson(
+ jsonRequest({}, "https://evil.example"),
+ "https://alook.ai",
+ nativeOauthRegistrationSchema,
+ );
+ expect(invalidOrigin.ok).toBe(false);
+ if (!invalidOrigin.ok) expect(invalidOrigin.response.status).toBe(403);
+
+ const alternateHost = new Request("https://preview.example/api/auth/native/attempt", {
+ method: "POST",
+ headers: { "Content-Type": "application/json", Origin: "https://alook.ai" },
+ body: "{}",
+ });
+ const alternateHostResult = await parseNativeOauthJson(
+ alternateHost,
+ "https://alook.ai",
+ nativeOauthRegistrationSchema,
+ );
+ expect(alternateHostResult.ok).toBe(false);
+ if (!alternateHostResult.ok) {
+ expect(alternateHostResult.response.status).toBe(403);
+ }
+
+ const oversized = jsonRequest({ padding: "x".repeat(5000) });
+ const parsed = await parseNativeOauthJson(
+ oversized,
+ "https://alook.ai",
+ nativeOauthRegistrationSchema,
+ );
+ expect(parsed.ok).toBe(false);
+ if (!parsed.ok) expect(parsed.response.status).toBe(413);
+ });
+
+ it("rejects every malformed JSON transport before schema data is used", async () => {
+ const request = (headers: HeadersInit, body?: string) =>
+ new Request("https://alook.ai/api/auth/native/attempt", {
+ method: "POST",
+ headers: { Origin: "https://alook.ai", ...headers },
+ body,
+ });
+ const cases = [
+ request({ "Content-Type": "text/plain" }, "{}"),
+ request({
+ "Content-Type": "application/json",
+ "Content-Length": "4097",
+ }, "{}"),
+ request({ "Content-Type": "application/json" }),
+ request({ "Content-Type": "application/json" }, "{}"),
+ ];
+
+ const responses = await Promise.all(cases.map(async (candidate) => {
+ const parsed = await parseNativeOauthJson(
+ candidate,
+ "https://alook.ai",
+ nativeOauthRegistrationSchema,
+ );
+ if (parsed.ok) throw new Error("malformed transport was accepted");
+ return parsed.response;
+ }));
+
+ expect(responses.map((response) => response.status)).toEqual([
+ 415,
+ 413,
+ 400,
+ 400,
+ ]);
+ });
+
+ it("accepts only the exact preserved Host through a loopback reverse proxy", async () => {
+ const body = {
+ attemptId: ATTEMPT,
+ stateHash: "a".repeat(64),
+ codeChallenge: "C".repeat(43),
+ instanceKeyHash: "b".repeat(64),
+ platform: "ios",
+ provider: "github",
+ redirectPath: "/c/me",
+ };
+ const request = (host: string, internalUrl = "http://127.0.0.1:3001") =>
+ new Request(`${internalUrl}/api/auth/native/attempt`, {
+ method: "POST",
+ headers: {
+ "Content-Type": "application/json",
+ Host: host,
+ Origin: "http://localhost:3000",
+ "X-Forwarded-Host": "localhost:3000",
+ },
+ body: JSON.stringify(body),
+ });
+
+ const accepted = await parseNativeOauthJson(
+ request("localhost:3000"),
+ "http://localhost:3000",
+ nativeOauthRegistrationSchema,
+ );
+ expect(accepted).toEqual({ ok: true, data: body });
+
+ for (const rejectedRequest of [
+ request("evil.example"),
+ request("localhost:3000", "http://internal.example"),
+ ]) {
+ const rejected = await parseNativeOauthJson(
+ rejectedRequest,
+ "http://localhost:3000",
+ nativeOauthRegistrationSchema,
+ );
+ expect(rejected.ok).toBe(false);
+ if (!rejected.ok) expect(rejected.response.status).toBe(403);
+ }
+
+ const publicTarget = await parseNativeOauthJson(
+ new Request("http://127.0.0.1:3001/api/auth/native/attempt", {
+ method: "POST",
+ headers: {
+ "Content-Type": "application/json",
+ Host: "alook.ai",
+ Origin: "https://alook.ai",
+ },
+ body: JSON.stringify(body),
+ }),
+ "https://alook.ai",
+ nativeOauthRegistrationSchema,
+ );
+ expect(publicTarget.ok).toBe(false);
+ if (!publicTarget.ok) expect(publicTarget.response.status).toBe(403);
+ });
+
+ it("derives SHA-256 and RFC 7636 S256 values", async () => {
+ await expect(sha256Hex("abc")).resolves.toBe(
+ "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad",
+ );
+ await expect(pkceChallenge("dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk")).resolves.toBe(
+ "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM",
+ );
+ });
+
+ it("keeps raw state and verifier out of every callback/return URL", () => {
+ const callbacks = nativeOauthCallbackUrls("https://alook.ai", ATTEMPT);
+ const mobile = nativeOauthReturnUrl("ios", ATTEMPT, { code: "z".repeat(32) });
+ const desktop = nativeOauthReturnUrl("linux", ATTEMPT, { status: "access_denied" });
+
+ expect(callbacks).toEqual({
+ callbackURL: `https://alook.ai/auth/native/callback?attempt=${ATTEMPT}&kind=signin`,
+ newUserCallbackURL: `https://alook.ai/auth/native/callback?attempt=${ATTEMPT}&kind=signup`,
+ errorCallbackURL: `https://alook.ai/auth/native/callback?attempt=${ATTEMPT}&kind=error`,
+ });
+ expect(mobile).toBe(
+ `https://auth.alook.ai/auth/native/return?attempt=${ATTEMPT}&code=${"z".repeat(32)}`,
+ );
+ expect(desktop).toBe(
+ `ai.alook.desktop://auth/native/return?attempt=${ATTEMPT}&status=access_denied`,
+ );
+ for (const url of [...Object.values(callbacks), mobile, desktop]) {
+ expect(url).not.toContain(STATE);
+ expect(url).not.toContain(VERIFIER);
+ }
+ });
+
+ it("accepts only a bounded exchange body and sanitizes provider errors", () => {
+ expect(nativeOauthExchangeSchema.safeParse({
+ attemptId: ATTEMPT,
+ state: STATE,
+ verifier: VERIFIER,
+ code: "c".repeat(32),
+ }).success).toBe(true);
+ expect(sanitizeOauthFailure("access_denied")).toBe("access_denied");
+ expect(sanitizeOauthFailure("invalid_code")).toBe("provider_error");
+ expect(sanitizeOauthFailure("provider-secret-detail")).toBe("oauth_callback_failed");
+ });
+
+ it("sets no-store/no-referrer on protocol JSON", () => {
+ const response = nativeOauthJson({ ok: true });
+ expect(response.headers.get("Cache-Control")).toBe("no-store, max-age=0");
+ expect(response.headers.get("Referrer-Policy")).toBe("no-referrer");
+ });
+
+ it("applies secure HTML defaults when response init is omitted", async () => {
+ const response = nativeOauthHtml("<main>Continue</main>");
+
+ await expect(response.text()).resolves.toBe("<main>Continue</main>");
+ expect(response.headers.get("Content-Type")).toBe(
+ "text/html; charset=utf-8",
+ );
+ expect(response.headers.get("Cache-Control")).toBe("no-store, max-age=0");
+ expect(response.headers.get("Referrer-Policy")).toBe("no-referrer");
+ });
+});
diff --git a/src/web/src/lib/native-oauth.ts b/src/web/src/lib/native-oauth.ts
new file mode 100644
index 000000000..5fa9d8704
--- /dev/null
+++ b/src/web/src/lib/native-oauth.ts
@@ -0,0 +1,258 @@
+import {
+ nativeOauthAttemptIdSchema,
+ nativeOauthExchangeSchema,
+ nativeOauthProofSchema,
+ nativeOauthRegistrationSchema,
+ type NativeOauthFailureCode,
+ type NativeOauthPlatform,
+ type NativeOauthProvider,
+} from "@alook/shared";
+export {
+ nativeOauthExchangeSchema,
+ nativeOauthProofSchema,
+ nativeOauthRegistrationSchema,
+};
+export type { NativeOauthPlatform, NativeOauthProvider };
+
+const MAX_JSON_BODY_BYTES = 4096;
+const NATIVE_OAUTH_RETURN_ORIGIN = "https://auth.alook.ai";
+const NATIVE_OAUTH_RETURN_PATH = "/auth/native/return";
+export const nativeOauthSecurityHeaders = {
+ "Cache-Control": "no-store, max-age=0",
+ Pragma: "no-cache",
+ "Referrer-Policy": "no-referrer",
+ "X-Content-Type-Options": "nosniff",
+} as const;
+
+function mergeSecurityHeaders(headers?: HeadersInit): Headers {
+ const merged = new Headers(headers);
+ for (const [name, value] of Object.entries(nativeOauthSecurityHeaders)) {
+ merged.set(name, value);
+ }
+ return merged;
+}
+
+export function nativeOauthJson(
+ body: unknown,
+ init: ResponseInit = {},
+): Response {
+ return Response.json(body, {
+ ...init,
+ headers: mergeSecurityHeaders(init.headers),
+ });
+}
+
+export function nativeOauthHtml(
+ body: string,
+ init: ResponseInit = {},
+): Response {
+ const headers = mergeSecurityHeaders(init.headers);
+ headers.set("Content-Type", "text/html; charset=utf-8");
+ return new Response(body, { ...init, headers });
+}
+
+export function nativeOauthRedirect(
+ location: string,
+ sourceHeaders?: Headers,
+): Response {
+ const headers = mergeSecurityHeaders();
+ headers.set("Location", location);
+ if (sourceHeaders) copySetCookieHeaders(sourceHeaders, headers);
+ return new Response(null, { status: 302, headers });
+}
+
+export function copySetCookieHeaders(source: Headers, target: Headers): void {
+ for (const cookie of source.getSetCookie()) target.append("Set-Cookie", cookie);
+}
+
+async function readBoundedText(
+ request: Request,
+ maxBytes: number,
+): Promise<string | null> {
+ if (!request.body) return "";
+ const reader = request.body.getReader();
+ const decoder = new TextDecoder();
+ let total = 0;
+ let body = "";
+ while (true) {
+ const { done, value } = await reader.read();
+ if (done) return body + decoder.decode();
+ total += value.byteLength;
+ if (total > maxBytes) {
+ await reader.cancel();
+ return null;
+ }
+ body += decoder.decode(value, { stream: true });
+ }
+}
+
+type ParsedJson<T> =
+ | { ok: true; data: T }
+ | { ok: false; response: Response };
+
+type StrictSchema<T> = {
+ safeParse(value: unknown):
+ | { success: true; data: T }
+ | { success: false };
+};
+
+function isLoopbackHostname(hostname: string): boolean {
+ return hostname === "localhost"
+ || hostname === "127.0.0.1"
+ || hostname === "[::1]";
+}
+
+export function isNativeOauthRequestTarget(
+ request: Request,
+ expectedBaseUrl: string,
+): boolean {
+ const expectedUrl = new URL(expectedBaseUrl);
+ const requestUrl = new URL(request.url);
+ if (requestUrl.origin === expectedUrl.origin) return true;
+ return isLoopbackHostname(requestUrl.hostname)
+ && isLoopbackHostname(expectedUrl.hostname)
+ && request.headers.get("Host") === expectedUrl.host;
+}
+
+export async function parseNativeOauthJson<T>(
+ request: Request,
+ expectedBaseUrl: string,
+ schema: StrictSchema<T>,
+): Promise<ParsedJson<T>> {
+ const expectedUrl = new URL(expectedBaseUrl);
+ const expectedOrigin = expectedUrl.origin;
+ if (
+ !isNativeOauthRequestTarget(request, expectedBaseUrl) ||
+ request.headers.get("Origin") !== expectedOrigin
+ ) {
+ return {
+ ok: false,
+ response: nativeOauthJson({ error: "invalid_request" }, { status: 403 }),
+ };
+ }
+
+ const contentType = request.headers.get("Content-Type")?.split(";", 1)[0]?.trim().toLowerCase();
+ if (contentType !== "application/json") {
+ return {
+ ok: false,
+ response: nativeOauthJson({ error: "invalid_request" }, { status: 415 }),
+ };
+ }
+
+ const declaredLength = Number(request.headers.get("Content-Length"));
+ if (Number.isFinite(declaredLength) && declaredLength > MAX_JSON_BODY_BYTES) {
+ return {
+ ok: false,
+ response: nativeOauthJson({ error: "invalid_request" }, { status: 413 }),
+ };
+ }
+
+ const text = await readBoundedText(request, MAX_JSON_BODY_BYTES);
+ if (text === null) {
+ return {
+ ok: false,
+ response: nativeOauthJson({ error: "invalid_request" }, { status: 413 }),
+ };
+ }
+
+ let value: unknown;
+ try {
+ value = JSON.parse(text);
+ } catch {
+ return {
+ ok: false,
+ response: nativeOauthJson({ error: "invalid_request" }, { status: 400 }),
+ };
+ }
+ const parsed = schema.safeParse(value);
+ if (!parsed.success) {
+ return {
+ ok: false,
+ response: nativeOauthJson({ error: "invalid_request" }, { status: 400 }),
+ };
+ }
+ return { ok: true, data: parsed.data };
+}
+
+export async function sha256Hex(value: string): Promise<string> {
+ const bytes = new TextEncoder().encode(value);
+ const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", bytes));
+ return Array.from(digest, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+
+export async function pkceChallenge(verifier: string): Promise<string> {
+ const bytes = new TextEncoder().encode(verifier);
+ const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", bytes));
+ let binary = "";
+ for (const byte of digest) binary += String.fromCharCode(byte);
+ return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+}
+
+export function nativeOauthStartUrl(baseUrl: string, attemptId: string): string {
+ const url = new URL("/auth/native/start", baseUrl);
+ url.searchParams.set("attempt", attemptId);
+ return url.toString();
+}
+
+export function nativeOauthCallbackUrls(baseUrl: string, attemptId: string) {
+ const create = (kind: "signin" | "signup" | "error") => {
+ const url = new URL("/auth/native/callback", baseUrl);
+ url.searchParams.set("attempt", attemptId);
+ url.searchParams.set("kind", kind);
+ return url.toString();
+ };
+ return {
+ callbackURL: create("signin"),
+ newUserCallbackURL: create("signup"),
+ errorCallbackURL: create("error"),
+ } as const;
+}
+
+function isMobilePlatform(platform: NativeOauthPlatform): boolean {
+ return platform === "ios" || platform === "android";
+}
+
+export function nativeOauthReturnUrl(
+ platform: NativeOauthPlatform,
+ attemptId: string,
+ result: { code: string } | { status: NativeOauthFailureCode },
+): string {
+ const url = isMobilePlatform(platform)
+ ? new URL(NATIVE_OAUTH_RETURN_PATH, NATIVE_OAUTH_RETURN_ORIGIN)
+ : new URL("ai.alook.desktop://auth/native/return");
+ url.searchParams.set("attempt", attemptId);
+ if ("code" in result) url.searchParams.set("code", result.code);
+ else url.searchParams.set("status", result.status);
+ return url.toString();
+}
+
+export function sanitizeOauthFailure(
+ error: string | null,
+): "access_denied" | "provider_error" | "oauth_callback_failed" {
+ if (error === "access_denied") return "access_denied";
+ if (error === "no_code" || error === "invalid_code" || error === "oauth_provider_not_found") {
+ return "provider_error";
+ }
+ return "oauth_callback_failed";
+}
+
+export function expireBrowserAnalyticsCookies(headers: Headers, secure: boolean): void {
+ const suffix = `Max-Age=0; Path=/; SameSite=Lax${secure ? "; Secure" : ""}`;
+ headers.append("Set-Cookie", `is_new_signup=; ${suffix}`);
+ headers.append("Set-Cookie", `is_sign_in=; ${suffix}`);
+}
+
+export function setWebViewAnalyticsCookie(
+ headers: Headers,
+ authKind: "signin" | "signup",
+ provider: NativeOauthProvider,
+ secure: boolean,
+): void {
+ const name = authKind === "signup" ? "is_new_signup" : "is_sign_in";
+ const suffix = `Max-Age=60; Path=/; SameSite=Lax${secure ? "; Secure" : ""}`;
+ headers.append("Set-Cookie", `${name}=${provider}; ${suffix}`);
+}
+
+export function isNativeOauthAttemptId(value: string | null): value is string {
+ return value !== null && nativeOauthAttemptIdSchema.safeParse(value).success;
+}
diff --git a/src/web/src/lib/safe-redirect.test.ts b/src/web/src/lib/safe-redirect.test.ts
new file mode 100644
index 000000000..42cefcd6d
--- /dev/null
+++ b/src/web/src/lib/safe-redirect.test.ts
@@ -0,0 +1,32 @@
+import { describe, expect, it } from "vitest";
+import { isSafeRedirectPath, safeRedirectPath } from "./safe-redirect";
+
+describe("safe redirect paths", () => {
+ it.each([
+ "/c/me",
+ "/c/me/machines?tab=active",
+ "/sign-in?redirect=%2Fc%2Fme",
+ "/search?q=100%25",
+ ])("accepts a local path: %s", (path) => {
+ expect(isSafeRedirectPath(path)).toBe(true);
+ expect(safeRedirectPath(path)).toBe(path);
+ });
+
+ it.each([
+ "https://evil.example/c",
+ "//evil.example/c",
+ "/\\evil.example/c",
+ "/%5Cevil.example/c",
+ "/%2Fevil.example/c",
+ "/%252Fevil.example/c",
+ "/%255Cevil.example/c",
+ "/c/me#secret",
+ "/c/\nme",
+ "/c/%0ame",
+ "/" + "a".repeat(2048),
+ "%",
+ ])("rejects an unsafe path: %s", (path) => {
+ expect(isSafeRedirectPath(path)).toBe(false);
+ expect(safeRedirectPath(path)).toBe("/c/me");
+ });
+});
diff --git a/src/web/src/lib/safe-redirect.ts b/src/web/src/lib/safe-redirect.ts
new file mode 100644
index 000000000..3f06d7602
--- /dev/null
+++ b/src/web/src/lib/safe-redirect.ts
@@ -0,0 +1,7 @@
+import {
+ isSafeRedirectPath as sharedIsSafeRedirectPath,
+ safeRedirectPath as sharedSafeRedirectPath,
+} from "@alook/shared";
+
+export const isSafeRedirectPath = sharedIsSafeRedirectPath;
+export const safeRedirectPath = sharedSafeRedirectPath;
diff --git a/src/web/src/middleware.ts b/src/web/src/middleware.ts
index 6bd685fa4..51d6d8df3 100644
--- a/src/web/src/middleware.ts
+++ b/src/web/src/middleware.ts
@@ -1,13 +1,7 @@
import { NextRequest, NextResponse } from "next/server"
import { getCloudflareContext } from "@opennextjs/cloudflare"
import { createAuth } from "@/lib/auth"
-
-function isSafeRedirect(path: string): boolean {
- // Must be a relative path. Reject scheme-relative ("//evil.com") and
- // backslash tricks ("/\evil.com") — the WHATWG URL parser treats "\" as "/",
- // so both resolve to an external origin and would be an open redirect.
- return path.startsWith("/") && path[1] !== "/" && path[1] !== "\\"
-}
+import { isSafeRedirectPath } from "@/lib/safe-redirect"
const AUTH_REQUIRED_PREFIXES = ["/invite/", "/w/", "/workspaces", "/dashboard", "/c/"]
@@ -69,7 +63,7 @@ export async function middleware(request: NextRequest) {
if (result?.response) {
const redirect = request.nextUrl.searchParams.get("redirect")
- const target = redirect && isSafeRedirect(redirect)
+ const target = redirect && isSafeRedirectPath(redirect)
? new URL(redirect, request.url)
// Default landing for an already-signed-in visitor hitting /sign-in:
// community home. `/workspaces` was the retired legacy (v0) surface.
diff --git a/src/web/src/test/architecture/vitest-workspace-config.test.ts b/src/web/src/test/architecture/vitest-workspace-config.test.ts
new file mode 100644
index 000000000..fbecb9fe9
--- /dev/null
+++ b/src/web/src/test/architecture/vitest-workspace-config.test.ts
@@ -0,0 +1,17 @@
+import { describe, expect, it } from "vitest";
+import workspaceConfig from "../../../vitest.workspace.config";
+
+describe("Web Vitest workspace contract", () => {
+ it("runs both node and workerd projects for the app and auth Worker", () => {
+ expect(workspaceConfig).toMatchObject({
+ test: {
+ projects: [
+ "./vitest.config.ts",
+ "./vitest.runtime.config.mts",
+ "./auth/vitest.config.ts",
+ "./auth/vitest.runtime.config.mts",
+ ],
+ },
+ });
+ });
+});
diff --git a/src/web/src/test/e2e/auth.test.ts b/src/web/src/test/e2e/auth.test.ts
index 18d1343da..f8a6a72bf 100644
--- a/src/web/src/test/e2e/auth.test.ts
+++ b/src/web/src/test/e2e/auth.test.ts
@@ -1,4 +1,4 @@
-import { describe, it, expect, beforeAll } from "vitest"
+import { afterAll, describe, expect, it } from "vitest"
import { randomUUID } from "crypto"
import { signUp, signIn, sessionRequest, sqlRun } from "@alook/test-utils"
@@ -34,6 +34,27 @@ describe("auth", () => {
expect(res.status).toBe(401)
})
+ it("blocks public one-time-token generation and verification", async () => {
+ const cookie = await signIn(testEmail, testPassword)
+ const generate = await fetch(`${APP_URL}/api/auth/one-time-token/generate`, {
+ headers: {
+ Cookie: cookie,
+ Origin: new URL(APP_URL).origin,
+ },
+ })
+ expect(generate.status).toBe(404)
+
+ const verify = await fetch(`${APP_URL}/api/auth/one-time-token/verify`, {
+ method: "POST",
+ headers: {
+ "Content-Type": "application/json",
+ Origin: new URL(APP_URL).origin,
+ },
+ body: JSON.stringify({ token: "not-a-public-token" }),
+ })
+ expect(verify.status).toBe(404)
+ })
+
// Cleanup: remove test user created by sign-up
afterAll(() => {
try {
diff --git a/src/web/src/test/e2e/native-oauth-schema.test.ts b/src/web/src/test/e2e/native-oauth-schema.test.ts
new file mode 100644
index 000000000..7d3b874e8
--- /dev/null
+++ b/src/web/src/test/e2e/native-oauth-schema.test.ts
@@ -0,0 +1,115 @@
+import { afterAll, beforeEach, describe, expect, it } from "vitest";
+import { sqlQuery, sqlRun } from "@alook/test-utils";
+
+const TABLE = "native_oauth_attempt";
+const NOW = 1_788_531_200_000;
+const INSTANCE = "a".repeat(64);
+
+function insertPending(id: string, instanceKeyHash = INSTANCE): void {
+ sqlRun(
+ `INSERT INTO ${TABLE} (
+ id, instance_key_hash, state_hash, pkce_challenge, provider, platform,
+ redirect_path, status, attempt_expires_at, created_at, updated_at
+ ) VALUES (?, ?, ?, ?, 'github', 'ios', '/c/me', 'pending', ?, ?, ?)`,
+ id,
+ instanceKeyHash,
+ "b".repeat(64),
+ "c".repeat(43),
+ NOW + 600_000,
+ NOW,
+ NOW,
+ );
+}
+
+beforeEach(() => sqlRun(`DELETE FROM ${TABLE}`));
+afterAll(() => sqlRun(`DELETE FROM ${TABLE}`));
+
+describe("native_oauth_attempt migration parity", () => {
+ it("installs the frozen lifecycle columns and indexes", () => {
+ const columns = sqlQuery<{
+ name: string;
+ type: string;
+ notnull: number;
+ pk: number;
+ }>(`PRAGMA table_info(${TABLE})`);
+ expect(columns.map((column) => column.name)).toEqual([
+ "id",
+ "instance_key_hash",
+ "state_hash",
+ "pkce_challenge",
+ "provider",
+ "platform",
+ "redirect_path",
+ "status",
+ "handoff_code_hash",
+ "handoff_expires_at",
+ "auth_kind",
+ "failure_code",
+ "attempt_expires_at",
+ "created_at",
+ "updated_at",
+ "opened_at",
+ "ready_at",
+ "consumed_at",
+ "failed_at",
+ "cancelled_at",
+ "replaced_at",
+ ]);
+ expect(columns[0]).toMatchObject({
+ name: "id",
+ type: "TEXT",
+ notnull: 1,
+ pk: 1,
+ });
+ expect(
+ sqlQuery<{ name: string }>(
+ `SELECT name FROM sqlite_master WHERE type='index' AND tbl_name=? ORDER BY name`,
+ TABLE,
+ ).map((row) => row.name),
+ ).toEqual([
+ "idx_native_oauth_attempt_id_status_expiry",
+ "idx_native_oauth_attempt_instance_status",
+ "idx_native_oauth_attempt_terminal_cleanup",
+ "uq_native_oauth_attempt_handoff_hash",
+ "uq_native_oauth_attempt_instance_live",
+ ]);
+ });
+
+ it("enforces one live attempt per installation while permitting replacement", () => {
+ insertPending("attempt_old_123456789012");
+ expect(() => insertPending("attempt_new_123456789012")).toThrow(
+ /UNIQUE constraint failed/i,
+ );
+
+ sqlRun(
+ `UPDATE ${TABLE}
+ SET status='replaced', replaced_at=?, updated_at=?
+ WHERE id='attempt_old_123456789012'`,
+ NOW + 1,
+ NOW + 1,
+ );
+ expect(() => insertPending("attempt_new_123456789012")).not.toThrow();
+ });
+
+ it("rejects malformed hashes, unsafe redirects, invalid enums, and bad epochs", () => {
+ expect(() => insertPending("too_short")).toThrow(/CHECK constraint failed/i);
+ expect(() => {
+ insertPending("attempt_bad_hash_12345678", "not-a-hash");
+ }).toThrow(/CHECK constraint failed/i);
+ expect(() => {
+ sqlRun(
+ `INSERT INTO ${TABLE} (
+ id, instance_key_hash, state_hash, pkce_challenge, provider, platform,
+ redirect_path, status, attempt_expires_at, created_at, updated_at
+ ) VALUES (?, ?, ?, ?, 'twitter', 'ios', '//evil.example', 'pending', ?, ?, ?)`,
+ "attempt_invalid_1234567890",
+ "a".repeat(64),
+ "b".repeat(64),
+ "c".repeat(43),
+ NOW + 1,
+ NOW,
+ NOW,
+ );
+ }).toThrow(/CHECK constraint failed/i);
+ });
+});
diff --git a/src/web/src/test/e2e/native-oauth.test.ts b/src/web/src/test/e2e/native-oauth.test.ts
new file mode 100644
index 000000000..9ad797950
--- /dev/null
+++ b/src/web/src/test/e2e/native-oauth.test.ts
@@ -0,0 +1,136 @@
+import { afterAll, describe, expect, it } from "vitest";
+import { createHash, randomBytes, randomUUID } from "node:crypto";
+import { sqlQuery, sqlRun } from "@alook/test-utils";
+
+const APP_URL = process.env.APP_URL ?? "http://localhost:3000";
+const ORIGIN = new URL(APP_URL).origin;
+const ids: string[] = [];
+
+function sha256(value: string): string {
+ return createHash("sha256").update(value).digest("hex");
+}
+
+async function post(path: string, body: unknown): Promise<Response> {
+ return fetch(`${APP_URL}${path}`, {
+ method: "POST",
+ headers: {
+ "Content-Type": "application/json",
+ Origin: ORIGIN,
+ },
+ body: JSON.stringify(body),
+ });
+}
+
+afterAll(() => {
+ for (const id of ids) {
+ sqlRun("DELETE FROM native_oauth_attempt WHERE id = ?", id);
+ }
+});
+
+describe("dormant native OAuth protocol", () => {
+ it("accepts start and callback through the real zone ingress", async () => {
+ const missingAttempt = `native_${randomUUID().replaceAll("-", "")}`;
+ const [start, callback] = await Promise.all([
+ fetch(`${APP_URL}/auth/native/start?attempt=${missingAttempt}`, {
+ redirect: "manual",
+ }),
+ fetch(
+ `${APP_URL}/auth/native/callback?attempt=${missingAttempt}&kind=signin`,
+ { redirect: "manual" },
+ ),
+ ]);
+
+ expect(start.status).toBe(410);
+ expect(callback.status).toBe(410);
+ });
+
+ it("leaves exactly one live attempt after overlapping registrations", async () => {
+ const suffix = randomUUID().replaceAll("-", "");
+ const attemptIds = [`native_a_${suffix}`, `native_b_${suffix}`];
+ const instanceKeyHash = sha256(`instance:${suffix}`);
+ ids.push(...attemptIds);
+ const registrations = attemptIds.map((attemptId) => ({
+ attemptId,
+ stateHash: sha256(`state:${attemptId}`),
+ codeChallenge: createHash("sha256")
+ .update(`verifier:${attemptId}`)
+ .digest("base64url"),
+ instanceKeyHash,
+ platform: "macos",
+ provider: "github",
+ redirectPath: "/c/me",
+ }));
+
+ const settled = await Promise.allSettled(
+ registrations.map((body) => post("/api/auth/native/attempt", body)),
+ );
+ expect(settled.every((result) => result.status === "fulfilled")).toBe(true);
+ const responses = settled.map((result) => {
+ if (result.status === "rejected") throw result.reason;
+ return result.value;
+ });
+ expect(responses.map((response) => response.status)).toEqual([200, 200]);
+
+ const rows = sqlQuery<{ id: string; status: string }>(
+ `SELECT id, status FROM native_oauth_attempt
+ WHERE instance_key_hash = ? ORDER BY id`,
+ instanceKeyHash,
+ );
+ expect(rows.map((row) => row.id)).toEqual([...attemptIds].sort());
+ expect(rows.filter((row) =>
+ ["pending", "opened", "ready", "exchanging"].includes(row.status),
+ )).toHaveLength(1);
+ expect(rows.filter((row) => row.status === "replaced")).toHaveLength(1);
+ });
+
+ it("registers, reads, cancels, and proof-binds an attempt", async () => {
+ const attemptId = `native_${randomUUID().replaceAll("-", "")}`;
+ const state = randomBytes(32).toString("base64url");
+ const verifier = randomBytes(32).toString("base64url");
+ ids.push(attemptId);
+
+ const registration = await post("/api/auth/native/attempt", {
+ attemptId,
+ stateHash: sha256(state),
+ codeChallenge: createHash("sha256")
+ .update(verifier)
+ .digest("base64url"),
+ instanceKeyHash: sha256(`instance:${attemptId}`),
+ platform: "macos",
+ provider: "github",
+ redirectPath: "/c/me",
+ });
+ expect(registration.status).toBe(200);
+ await expect(registration.json()).resolves.toEqual({
+ startUrl: `${ORIGIN}/auth/native/start?attempt=${attemptId}`,
+ });
+
+ const wrongProof = await post("/api/auth/native/status", {
+ attemptId,
+ state: randomBytes(32).toString("base64url"),
+ verifier,
+ });
+ await expect(wrongProof.json()).resolves.toEqual({ status: "unknown" });
+
+ const status = await post("/api/auth/native/status", {
+ attemptId,
+ state,
+ verifier,
+ });
+ await expect(status.json()).resolves.toEqual({ status: "pending" });
+
+ const cancelled = await post("/api/auth/native/cancel", {
+ attemptId,
+ state,
+ verifier,
+ });
+ await expect(cancelled.json()).resolves.toEqual({ status: "cancelled" });
+
+ const finalStatus = await post("/api/auth/native/status", {
+ attemptId,
+ state,
+ verifier,
+ });
+ await expect(finalStatus.json()).resolves.toEqual({ status: "cancelled" });
+ });
+});
diff --git a/src/web/test-runtime/native-oauth.runtime.test.ts b/src/web/test-runtime/native-oauth.runtime.test.ts
new file mode 100644
index 000000000..bf1b7e5cd
--- /dev/null
+++ b/src/web/test-runtime/native-oauth.runtime.test.ts
@@ -0,0 +1,193 @@
+/// <reference types="@cloudflare/vitest-plugin/types" />
+
+import { env } from "cloudflare:workers"
+import { createDb, queries } from "@alook/shared"
+import { describe, expect, it } from "vitest"
+
+const runtimeEnv = env as unknown as CloudflareEnv
+
+function registration(id: string, instanceKeyHash: string) {
+ return {
+ id,
+ instanceKeyHash,
+ stateHash: "a".repeat(64),
+ pkceChallenge: "c".repeat(43),
+ provider: "github" as const,
+ platform: "ios" as const,
+ redirectPath: "/c/me",
+ }
+}
+
+describe("native OAuth CAS in real workerd D1", () => {
+ it("leaves one live row after overlapping primary-session registrations", async () => {
+ const suffix = crypto.randomUUID().replaceAll("-", "").slice(0, 16)
+ const firstId = `native_parallel_a_${suffix}`
+ const secondId = `native_parallel_b_${suffix}`
+ const instanceKeyHash = suffix.padEnd(64, "a")
+ const firstDb = createDb(runtimeEnv.DB.withSession("first-primary"))
+ const secondDb = createDb(runtimeEnv.DB.withSession("first-primary"))
+
+ try {
+ const settled = await Promise.allSettled([
+ queries.nativeOauth.registerAttempt(
+ firstDb,
+ registration(firstId, instanceKeyHash),
+ 1_788_531_200_000,
+ ),
+ queries.nativeOauth.registerAttempt(
+ secondDb,
+ registration(secondId, instanceKeyHash),
+ 1_788_531_200_001,
+ ),
+ ])
+ expect(settled.every((result) => result.status === "fulfilled")).toBe(true)
+
+ const rows = await runtimeEnv.DB.prepare(
+ `SELECT id, status FROM native_oauth_attempt
+ WHERE instance_key_hash = ? ORDER BY id`,
+ ).bind(instanceKeyHash).all<{ id: string; status: string }>()
+ expect(rows.results.map((row) => row.id)).toEqual([firstId, secondId])
+ expect(rows.results.filter((row) =>
+ ["pending", "opened", "ready", "exchanging"].includes(row.status),
+ )).toHaveLength(1)
+ expect(rows.results.filter((row) => row.status === "replaced")).toHaveLength(1)
+ } finally {
+ await runtimeEnv.DB.prepare(
+ "DELETE FROM native_oauth_attempt WHERE instance_key_hash = ?",
+ ).bind(instanceKeyHash).run()
+ }
+ })
+
+ it("has one claim and one consume winner for overlapping primary sessions", async () => {
+ const suffix = crypto.randomUUID().replaceAll("-", "").slice(0, 16)
+ const attemptId = `native_exchange_${suffix}`
+ const instanceKeyHash = suffix.padEnd(64, "b")
+ const codeHash = "d".repeat(64)
+ const proof = {
+ attemptId,
+ stateHash: "a".repeat(64),
+ pkceChallenge: "c".repeat(43),
+ handoffCodeHash: codeHash,
+ }
+ const setupDb = createDb(runtimeEnv.DB.withSession("first-primary"))
+ const firstDb = createDb(runtimeEnv.DB.withSession("first-primary"))
+ const secondDb = createDb(runtimeEnv.DB.withSession("first-primary"))
+ const now = 1_788_531_200_000
+
+ try {
+ await queries.nativeOauth.registerAttempt(
+ setupDb,
+ registration(attemptId, instanceKeyHash),
+ now,
+ )
+ await queries.nativeOauth.claimStart(setupDb, attemptId, now + 1)
+ await queries.nativeOauth.attachHandoff(setupDb, {
+ attemptId,
+ handoffCodeHash: codeHash,
+ authKind: "signin",
+ }, now + 2)
+
+ const claims = await Promise.allSettled([
+ queries.nativeOauth.claimExchange(firstDb, proof, now + 3),
+ queries.nativeOauth.claimExchange(secondDb, proof, now + 3),
+ ])
+ expect(claims.every((result) => result.status === "fulfilled")).toBe(true)
+ const claimRows = claims.map((result) => {
+ if (result.status === "rejected") throw result.reason
+ return result.value
+ })
+ expect(claimRows.filter((row) => row !== null)).toHaveLength(1)
+
+ const finishes = await Promise.allSettled([
+ queries.nativeOauth.finishExchange(firstDb, proof, now + 4),
+ queries.nativeOauth.finishExchange(secondDb, proof, now + 4),
+ ])
+ expect(finishes.every((result) => result.status === "fulfilled")).toBe(true)
+ const consumedRows = finishes.map((result) => {
+ if (result.status === "rejected") throw result.reason
+ return result.value
+ })
+ expect(consumedRows.filter((row) => row !== null)).toHaveLength(1)
+
+ const final = await runtimeEnv.DB.prepare(
+ "SELECT status FROM native_oauth_attempt WHERE id = ?",
+ ).bind(attemptId).first<{ status: string }>()
+ expect(final).toEqual({ status: "consumed" })
+ } finally {
+ await runtimeEnv.DB.prepare(
+ "DELETE FROM native_oauth_attempt WHERE instance_key_hash = ?",
+ ).bind(instanceKeyHash).run()
+ }
+ })
+
+ it("atomically replaces, rejects a wrong code, and lets cancellation win", async () => {
+ const suffix = crypto.randomUUID().replaceAll("-", "").slice(0, 16)
+ const firstId = `native_old_${suffix}`
+ const secondId = `native_new_${suffix}`
+ const instanceKeyHash = suffix.padEnd(64, "a")
+ const codeHash = "d".repeat(64)
+ const now = 1_788_531_200_000
+ const db = createDb(runtimeEnv.DB.withSession("first-primary"))
+
+ try {
+ await queries.nativeOauth.registerAttempt(
+ db,
+ registration(firstId, instanceKeyHash),
+ now,
+ )
+ await queries.nativeOauth.registerAttempt(
+ db,
+ registration(secondId, instanceKeyHash),
+ now + 1,
+ )
+ const rows = await runtimeEnv.DB.prepare(
+ `SELECT id, status FROM native_oauth_attempt
+ WHERE instance_key_hash = ? ORDER BY created_at`,
+ ).bind(instanceKeyHash).all<{ id: string; status: string }>()
+ expect(rows.results).toEqual([
+ { id: firstId, status: "replaced" },
+ { id: secondId, status: "pending" },
+ ])
+
+ await queries.nativeOauth.claimStart(db, secondId, now + 2)
+ await queries.nativeOauth.attachHandoff(db, {
+ attemptId: secondId,
+ handoffCodeHash: codeHash,
+ authKind: "signin",
+ }, now + 3)
+ await expect(queries.nativeOauth.claimExchange(db, {
+ attemptId: secondId,
+ stateHash: "a".repeat(64),
+ pkceChallenge: "c".repeat(43),
+ handoffCodeHash: "e".repeat(64),
+ }, now + 4)).resolves.toBeNull()
+ await expect(queries.nativeOauth.getAttemptStatus(db, {
+ attemptId: secondId,
+ stateHash: "a".repeat(64),
+ pkceChallenge: "c".repeat(43),
+ })).resolves.toMatchObject({ status: "ready" })
+
+ await queries.nativeOauth.claimExchange(db, {
+ attemptId: secondId,
+ stateHash: "a".repeat(64),
+ pkceChallenge: "c".repeat(43),
+ handoffCodeHash: codeHash,
+ }, now + 5)
+ await queries.nativeOauth.cancelAttempt(db, {
+ attemptId: secondId,
+ stateHash: "a".repeat(64),
+ pkceChallenge: "c".repeat(43),
+ }, now + 6)
+ await expect(queries.nativeOauth.finishExchange(db, {
+ attemptId: secondId,
+ stateHash: "a".repeat(64),
+ pkceChallenge: "c".repeat(43),
+ handoffCodeHash: codeHash,
+ }, now + 7)).resolves.toBeNull()
+ } finally {
+ await runtimeEnv.DB.prepare(
+ "DELETE FROM native_oauth_attempt WHERE instance_key_hash = ?",
+ ).bind(instanceKeyHash).run()
+ }
+ })
+})
diff --git a/src/web/tsconfig.json b/src/web/tsconfig.json
index ea4b30817..191bf58cc 100644
--- a/src/web/tsconfig.json
+++ b/src/web/tsconfig.json
@@ -43,6 +43,7 @@
"exclude": [
"node_modules",
"blog/**",
+ "auth/**",
"**/*.test.ts"
]
}
diff --git a/src/web/vitest.workspace.config.ts b/src/web/vitest.workspace.config.ts
index 0a2898afa..8ef717849 100644
--- a/src/web/vitest.workspace.config.ts
+++ b/src/web/vitest.workspace.config.ts
@@ -2,6 +2,11 @@ import { defineConfig } from "vitest/config"
export default defineConfig({
test: {
- projects: ["./vitest.config.ts", "./vitest.runtime.config.mts"],
+ projects: [
+ "./vitest.config.ts",
+ "./vitest.runtime.config.mts",
+ "./auth/vitest.config.ts",
+ "./auth/vitest.runtime.config.mts",
+ ],
},
})
diff --git a/vitest.config.ts b/vitest.config.ts
index c8fa38309..9ac77128a 100644
--- a/vitest.config.ts
+++ b/vitest.config.ts
@@ -5,6 +5,8 @@ export default defineConfig({
projects: [
"src/shared",
"src/web",
+ "src/web/auth/vitest.config.ts",
+ "src/web/auth/vitest.runtime.config.mts",
"src/cli",
"src/daemon",
"src/daemon/agent-driver",