From 88c9a201c4dda530bafd76dff80022961c1cabaf Mon Sep 17 00:00:00 2001 From: Vikas Singhal Date: Fri, 20 Nov 2026 16:03:31 +0530 Subject: [PATCH] feat(auth): two-factor sign-in (TOTP) with a reminder until it's on (v0.472.0) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A magic link can leak (the recovery path DMs it to chat and logs it), so a member can now require an authenticator-app code as well. A link used by a 2FA member mints a pending session every gate refuses until POST /api/auth/2fa/verify swaps it for a fresh one. Recovery codes, admin reset, `agent-os 2fa-reset`, and a reminder dialog on every new sign-in and every N days (Settings → Governance). Zero new dependencies. Co-Authored-By: Claude Opus 5.5 --- CHANGELOG.md | 21 +++ CLAUDE.md | 10 ++ docs/PILLARS.md | 2 +- package-lock.json | 4 +- package.json | 4 +- scripts/two-factor-test.cjs | 205 ++++++++++++++++++++++ src/cli.ts | 21 ++- src/governance/mfa.ts | 188 +++++++++++++++++++++ src/governance/qr.ts | 241 ++++++++++++++++++++++++++ src/governance/settings.ts | 16 ++ src/governance/team.ts | 66 +++++++- src/governance/totp.ts | 105 ++++++++++++ src/kernel.ts | 7 +- src/server.ts | 134 ++++++++++++++- src/state/db.ts | 23 +++ web/src/App.tsx | 26 ++- web/src/lib/api.ts | 36 +++- web/src/two-factor.tsx | 329 ++++++++++++++++++++++++++++++++++++ 18 files changed, 1416 insertions(+), 22 deletions(-) create mode 100644 scripts/two-factor-test.cjs create mode 100644 src/governance/mfa.ts create mode 100644 src/governance/qr.ts create mode 100644 src/governance/totp.ts create mode 100644 web/src/two-factor.tsx diff --git a/CHANGELOG.md b/CHANGELOG.md index 2408241f..2a03cf16 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,27 @@ new version heading in the same commit. ## [Unreleased] +## [0.472.0] - 2026-11-20 +### Added +- **Two-factor sign-in (TOTP) for console members, with a reminder until it's on.** Login is magic-link, + and a link can leak: the self-service recovery path DMs it to Slack/Discord and writes it to + `server.log`. A member can now require a 6-digit code from an authenticator app as well + (Profile → Two-factor sign-in: QR + manual key, ten single-use recovery codes, move to a new phone, + turn off). A link consumed by a member with 2FA on mints a PENDING session (10-minute TTL) that + `resolveSession` refuses everywhere — `/api/auth/me` answers 401 `mfaRequired`, so nginx's + `auth_request` keeps the terminal shut too — until `POST /api/auth/2fa/verify` swaps it for a fresh + full session. Five wrong codes destroy the pending session; a used TOTP step can't be replayed; the + secret is sealed under the vault master key and recovery codes are stored as hashes. Turning it off, + moving devices and regenerating codes all need a current code. Owners/admins see who has it on + (Team page badge) and can reset someone who lost their phone (admins: members only); `agent-os + 2fa-reset ` is the box-side last resort. Members without it get a reminder dialog on every new + sign-in AND every 7 days (Settings → Governance → Two-factor reminders; sessions slide, so the + periodic one is what reaches people who never sign out). Zero new dependencies — the QR code is a + small server-side encoder (`src/governance/qr.ts`) checked bit-for-bit against `qrencode`. Audited + `auth.2fa.{challenged,verified,failed,enabled,disabled,reset,recovery.regenerated}`. Pinned by + `scripts/two-factor-test.cjs`. + **For users:** you can now protect your account with an authenticator app, so a forwarded sign-in link alone can't get in. [Open Profile](#/profile) + ## [0.471.1] - 2026-11-19 ### Fixed - **A session whose transcript copy is empty can be reopened again.** If the credential dir a resume runs diff --git a/CLAUDE.md b/CLAUDE.md index 1ad9ba67..0a7d650e 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -655,6 +655,16 @@ in `src/types.ts` and `TeamStore.canRun()`. default `owner@localhost`); the one-time link is printed to the console + `data/server.log`. Others get a link from the Team page or the CLI (`agent-os invite|login-link|members`). Accepting a token (`GET /accept?token=…`) mints a 30-day `aos_sid` cookie session. +- **Two-factor sign-in (TOTP, opt-in per member).** `src/governance/mfa.ts` (+ `totp.ts`, and `qr.ts` — a + zero-dep QR encoder for the setup screen). A link consumed by a member with 2FA on mints a **pending** + session (`auth_sessions.mfa_pending=1`, 10 min) that `resolveSession`/`presence` ignore, so EVERY gate — + member API, terminal proxy, nginx `auth_request` — treats it as logged out; only public + `POST /api/auth/2fa/verify` accepts it and swaps it for a fresh sid. ⚠ Any NEW way of minting a login + session must go through `acceptToken(…, { mfaRequired })` or it silently bypasses the second factor. + Secret sealed under the vault master key (lose `secret.key` = everyone's 2FA reads as broken → reset via + `agent-os 2fa-reset `), recovery codes hashed, used TOTP steps unreplayable. Members without it + are reminded on the `twoFactorPolicy` cadence (every new login and/or every N days; Settings → + Governance), driven by `twoFactor.nag` on `/api/auth/me`. - **Identity map (chat run-as).** A member can be linked to external accounts — `member_identities` (provider ∈ `slack|discord|email|github`), edited on the Team page (**Chat IDs**) or via `POST /api/team/:id/identities` + `DELETE …/:provider`. `TeamStore.memberByExternalId(provider, id)` diff --git a/docs/PILLARS.md b/docs/PILLARS.md index e6b402d2..cd733a1a 100644 --- a/docs/PILLARS.md +++ b/docs/PILLARS.md @@ -43,7 +43,7 @@ Capabilities`), the taxonomy north-star that sits beside [`governance-model.md`] | 1 | Agents & Sessions | ✅ | Manifest-driven agents, real Claude in tmux, persisted sessions. The console reads them at three levels: a **run** (one pane), a **conversation** (every run sharing a claude transcript — a poke-back resumes one rather than starting one), and the **chain** (the hand-off tree over `tasks.caller_claude_id`). The sessions list collapses runs into conversations and nests delegates under their caller; a **chain rail** beside the terminal shows the tree, flags a re-dispatch of work already handed off, and answers a delegate's pending `ask`/approval in place | | 2 | Inbox | ✅ | Tasks · updates · approval/question cards, SQLite-backed, role-aware; per-member read/dismiss; out-of-band DMs for approvals **and** questions + chat-thread mirroring. See [`inbox-plan.md`](./inbox-plan.md) | | 3 | Connectors | ✅ | MCP catalog → per-session `.mcp.json`, every call still gated | -| 4 | Team | ✅ | Roles (owner/admin/member), magic-link login, agent assignment, identity map (external accounts → member) | +| 4 | Team | ✅ | Roles (owner/admin/member), magic-link login + opt-in TOTP two-factor (reminder cadence, admin reset), agent assignment, identity map (external accounts → member) | | 5 | Policy | ✅ | JSON rule engine + console editor (owner-edit, live hot-reload, persisted). **Learnable from the Inbox** — an approval's owner-only "Always" adds an `allow` rule (safely, after all `never` rules). Single ruleset per workspace; no dry-run simulator | | 6 | Audit Logs | ✅ | JSONL system-of-record + SQLite mirror + console **Audit** viewer (filter by session/type/principal) | | 7 | Automations | ✅ | Cron + webhook + native **Slack & Discord** triggers spawn governed sessions, run-as the sending member; a **generic `/agent` chat router** reaches any agent by name with no per-agent automation (replies threaded); **agent-scheduled one-shots** (`schedule`/`unschedule` MCP tools → `type:'once'`, bounded + human-cancellable) let an agent defer a future run of itself; email inbound still out | diff --git a/package-lock.json b/package-lock.json index facd0856..9f0564f6 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,12 +1,12 @@ { "name": "agent-os", - "version": "0.471.1", + "version": "0.472.0", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "agent-os", - "version": "0.471.1", + "version": "0.472.0", "license": "MIT", "bin": { "agent-os": "bin/agent-os" diff --git a/package.json b/package.json index c4139fe6..a7e189b0 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "agent-os", - "version": "0.471.1", + "version": "0.472.0", "description": "A generic, governed operating system for running autonomous agents safely across brands. Ships with a local web console.", "license": "MIT", "type": "commonjs", @@ -28,7 +28,7 @@ "dev": "ts-node src/cli.ts serve", "demo:dev": "ts-node src/demo.ts", "test:governance": "node scripts/governance-isolated.cjs", - "test:governance:run": "node scripts/version-sync-test.cjs && node scripts/agent-manifest-disk-test.cjs && node scripts/router-dispatch-test.cjs && node scripts/prompt-credential-guard-test.cjs && node scripts/standing-instructions-test.cjs && node scripts/session-trust-test.cjs && node scripts/video-gen-mapping-test.cjs && node scripts/event-loop-freeze-test.cjs && node scripts/git-ceiling-test.cjs && node scripts/cron-supersede-test.cjs && node scripts/governance-conformance.cjs && node scripts/tier-a-policy-test.cjs && node scripts/policy-baseline-test.cjs && node scripts/heredoc-intent-test.cjs && node scripts/script-body-gate-test.cjs && node scripts/capability-registry-test.cjs && node scripts/composio-envelope-test.cjs && node scripts/connector-auth-stub-test.cjs && node scripts/composio-identity-test.cjs && node scripts/idle-reaper-test.cjs && node scripts/dm-continuity-test.cjs && node scripts/telegram-dm-lane-test.cjs && node scripts/cli-link-origin-test.cjs && node scripts/alert-staleness-test.cjs && node scripts/run-as-identity-test.cjs && node scripts/email-identity-guard-test.cjs && node scripts/deps-freshness-test.cjs && node scripts/runtime-account-test.cjs && node scripts/runtime-account-misattribution-test.cjs && node scripts/runtime-usage-refresh-test.cjs && node scripts/keychain-credential-test.cjs && node scripts/credential-preflight-test.cjs && node scripts/capacity-queue-test.cjs && node scripts/runtime-pool-signed-out-test.cjs && node scripts/login-expiry-test.cjs && node scripts/runtime-login-test.cjs && node scripts/rotate-on-reload-test.cjs && node scripts/resume-transcript-stage-test.cjs && node scripts/headless-resumable-test.cjs && node scripts/session-revive-gates-test.cjs && node scripts/session-pause-test.cjs && node scripts/make-live-lock-test.cjs && node scripts/claude-config-seed-test.cjs && node scripts/claude-config-isolation-test.cjs && node scripts/output-style-test.cjs && node scripts/session-cost-test.cjs && node scripts/chain-model-test.cjs && node scripts/task-workers-test.cjs && node scripts/tuning-patch-test.cjs && node scripts/task-runs-test.cjs && node scripts/task-pr-links-test.cjs && node scripts/task-draft-delete-test.cjs && node scripts/task-discussion-delivery-test.cjs && node scripts/task-resume-test.cjs && node scripts/task-unblock-test.cjs && node scripts/unblock-run-dedupe-test.cjs && node scripts/audience-session-access-test.cjs && node scripts/warm-chat-test.cjs && node scripts/poke-warm-caller-test.cjs && node scripts/wakeup-queue-test.cjs && node scripts/stranded-human-stop-test.cjs && node scripts/inject-submit-test.cjs && node scripts/blocked-routing-test.cjs && node scripts/self-dispatch-guard-test.cjs && node scripts/task-proposals-test.cjs && node scripts/npm-boundary-test.cjs && node scripts/agent-edit-guard-test.cjs && node scripts/per-agent-context-test.cjs && node scripts/goal-update-guard-test.cjs && node scripts/insights-signal-test.cjs && node scripts/outcome-derivation-test.cjs && node scripts/episode-quality-test.cjs && node scripts/memory-upkeep-test.cjs && node scripts/automem-health-test.cjs && node scripts/memory-store-switch-test.cjs && node scripts/memory-preload-test.cjs && node scripts/turn-lifecycle-test.cjs && node scripts/resume-seed-test.cjs && node scripts/outcome-vocabulary-test.cjs && node scripts/skill-presets-test.cjs && node scripts/skill-edit-proposal-test.cjs && node scripts/notify-hook-route-test.cjs && node scripts/review-notify-test.cjs && node scripts/turn-idle-background-guard-test.cjs && node scripts/waiting-brief-test.cjs && node scripts/runtime-death-alert-test.cjs && node scripts/github-per-member-test.cjs && node scripts/github-multi-org-test.cjs && node scripts/card-measurement-test.cjs && node scripts/scheduler-admission-test.cjs && node scripts/tick-liveness-test.cjs && node scripts/audit-mirror-test.cjs && node scripts/request-metrics-test.cjs && node scripts/tool-usage-test.cjs && node scripts/sessions-list-perf-test.cjs && node scripts/summarizer-degradation-test.cjs && node scripts/agent-history-scope-test.cjs && node scripts/session-search-test.cjs && node scripts/webhook-ingress-test.cjs && node scripts/slack-content-filter-test.cjs && node scripts/slack-ingress-test.cjs && node scripts/launch-window-test.cjs && node scripts/discord-ingress-test.cjs && node scripts/chat-attachments-test.cjs && node scripts/clickup-task-bridge-test.cjs && node scripts/agentric-commands-test.cjs && node scripts/whats-new-test.cjs && node scripts/opencode-gate-test.cjs && node scripts/protected-path-guard-test.cjs && node scripts/protected-read-test.cjs && node scripts/attach-grace-test.cjs && node scripts/attach-file-liveness-test.cjs && node scripts/feed-smoke.cjs && node scripts/activity-classify-test.cjs && node scripts/goal-room-test.cjs && node scripts/secret-rotation-test.cjs && node scripts/update-watch-test.cjs && node scripts/runtime-update-watch-test.cjs && node scripts/setup-wizard-test.cjs && node scripts/md-pdf-test.cjs && node scripts/proposal-surfacing-test.cjs && node scripts/process-janitor-test.cjs && node scripts/connectors-retention-test.cjs && node scripts/detached-work-steer-test.cjs && node scripts/statusline-install-test.cjs && node scripts/docs-create-agent-test.cjs && node scripts/agent-stats-rollup-test.cjs && node scripts/task-discussion-rollup-test.cjs && node scripts/session-insights-stamp-test.cjs && node scripts/loop-stall-attribution-test.cjs && node scripts/session-progress-test.cjs && node scripts/drift-nudge-test.cjs && node scripts/goal-metric-review-test.cjs && node scripts/goal-heartbeat-test.cjs && node scripts/question-durability-test.cjs && node scripts/ask-block-link-test.cjs && node scripts/answer-pinning-test.cjs && node scripts/bets-test.cjs && node scripts/capability-gap-test.cjs && node scripts/workflow-proposal-test.cjs && node scripts/automation-edit-proposal-test.cjs && node scripts/app-card-close-test.cjs", + "test:governance:run": "node scripts/version-sync-test.cjs && node scripts/agent-manifest-disk-test.cjs && node scripts/router-dispatch-test.cjs && node scripts/prompt-credential-guard-test.cjs && node scripts/standing-instructions-test.cjs && node scripts/session-trust-test.cjs && node scripts/video-gen-mapping-test.cjs && node scripts/event-loop-freeze-test.cjs && node scripts/git-ceiling-test.cjs && node scripts/cron-supersede-test.cjs && node scripts/governance-conformance.cjs && node scripts/tier-a-policy-test.cjs && node scripts/policy-baseline-test.cjs && node scripts/heredoc-intent-test.cjs && node scripts/script-body-gate-test.cjs && node scripts/capability-registry-test.cjs && node scripts/composio-envelope-test.cjs && node scripts/connector-auth-stub-test.cjs && node scripts/composio-identity-test.cjs && node scripts/idle-reaper-test.cjs && node scripts/dm-continuity-test.cjs && node scripts/telegram-dm-lane-test.cjs && node scripts/cli-link-origin-test.cjs && node scripts/alert-staleness-test.cjs && node scripts/run-as-identity-test.cjs && node scripts/email-identity-guard-test.cjs && node scripts/deps-freshness-test.cjs && node scripts/runtime-account-test.cjs && node scripts/runtime-account-misattribution-test.cjs && node scripts/runtime-usage-refresh-test.cjs && node scripts/keychain-credential-test.cjs && node scripts/credential-preflight-test.cjs && node scripts/capacity-queue-test.cjs && node scripts/runtime-pool-signed-out-test.cjs && node scripts/login-expiry-test.cjs && node scripts/runtime-login-test.cjs && node scripts/rotate-on-reload-test.cjs && node scripts/resume-transcript-stage-test.cjs && node scripts/headless-resumable-test.cjs && node scripts/session-revive-gates-test.cjs && node scripts/session-pause-test.cjs && node scripts/make-live-lock-test.cjs && node scripts/claude-config-seed-test.cjs && node scripts/claude-config-isolation-test.cjs && node scripts/output-style-test.cjs && node scripts/session-cost-test.cjs && node scripts/chain-model-test.cjs && node scripts/task-workers-test.cjs && node scripts/tuning-patch-test.cjs && node scripts/task-runs-test.cjs && node scripts/task-pr-links-test.cjs && node scripts/task-draft-delete-test.cjs && node scripts/task-discussion-delivery-test.cjs && node scripts/task-resume-test.cjs && node scripts/task-unblock-test.cjs && node scripts/unblock-run-dedupe-test.cjs && node scripts/audience-session-access-test.cjs && node scripts/warm-chat-test.cjs && node scripts/poke-warm-caller-test.cjs && node scripts/wakeup-queue-test.cjs && node scripts/stranded-human-stop-test.cjs && node scripts/inject-submit-test.cjs && node scripts/blocked-routing-test.cjs && node scripts/self-dispatch-guard-test.cjs && node scripts/task-proposals-test.cjs && node scripts/npm-boundary-test.cjs && node scripts/agent-edit-guard-test.cjs && node scripts/per-agent-context-test.cjs && node scripts/goal-update-guard-test.cjs && node scripts/insights-signal-test.cjs && node scripts/outcome-derivation-test.cjs && node scripts/episode-quality-test.cjs && node scripts/memory-upkeep-test.cjs && node scripts/automem-health-test.cjs && node scripts/memory-store-switch-test.cjs && node scripts/memory-preload-test.cjs && node scripts/turn-lifecycle-test.cjs && node scripts/resume-seed-test.cjs && node scripts/outcome-vocabulary-test.cjs && node scripts/skill-presets-test.cjs && node scripts/skill-edit-proposal-test.cjs && node scripts/notify-hook-route-test.cjs && node scripts/review-notify-test.cjs && node scripts/turn-idle-background-guard-test.cjs && node scripts/waiting-brief-test.cjs && node scripts/runtime-death-alert-test.cjs && node scripts/github-per-member-test.cjs && node scripts/github-multi-org-test.cjs && node scripts/card-measurement-test.cjs && node scripts/scheduler-admission-test.cjs && node scripts/tick-liveness-test.cjs && node scripts/audit-mirror-test.cjs && node scripts/request-metrics-test.cjs && node scripts/tool-usage-test.cjs && node scripts/sessions-list-perf-test.cjs && node scripts/summarizer-degradation-test.cjs && node scripts/agent-history-scope-test.cjs && node scripts/session-search-test.cjs && node scripts/webhook-ingress-test.cjs && node scripts/slack-content-filter-test.cjs && node scripts/slack-ingress-test.cjs && node scripts/launch-window-test.cjs && node scripts/discord-ingress-test.cjs && node scripts/chat-attachments-test.cjs && node scripts/clickup-task-bridge-test.cjs && node scripts/agentric-commands-test.cjs && node scripts/whats-new-test.cjs && node scripts/opencode-gate-test.cjs && node scripts/protected-path-guard-test.cjs && node scripts/protected-read-test.cjs && node scripts/attach-grace-test.cjs && node scripts/attach-file-liveness-test.cjs && node scripts/feed-smoke.cjs && node scripts/activity-classify-test.cjs && node scripts/goal-room-test.cjs && node scripts/secret-rotation-test.cjs && node scripts/update-watch-test.cjs && node scripts/runtime-update-watch-test.cjs && node scripts/setup-wizard-test.cjs && node scripts/two-factor-test.cjs && node scripts/md-pdf-test.cjs && node scripts/proposal-surfacing-test.cjs && node scripts/process-janitor-test.cjs && node scripts/connectors-retention-test.cjs && node scripts/detached-work-steer-test.cjs && node scripts/statusline-install-test.cjs && node scripts/docs-create-agent-test.cjs && node scripts/agent-stats-rollup-test.cjs && node scripts/task-discussion-rollup-test.cjs && node scripts/session-insights-stamp-test.cjs && node scripts/loop-stall-attribution-test.cjs && node scripts/session-progress-test.cjs && node scripts/drift-nudge-test.cjs && node scripts/goal-metric-review-test.cjs && node scripts/goal-heartbeat-test.cjs && node scripts/question-durability-test.cjs && node scripts/ask-block-link-test.cjs && node scripts/answer-pinning-test.cjs && node scripts/bets-test.cjs && node scripts/capability-gap-test.cjs && node scripts/workflow-proposal-test.cjs && node scripts/automation-edit-proposal-test.cjs && node scripts/app-card-close-test.cjs", "test:alert-staleness": "node scripts/alert-staleness-test.cjs", "test:deps": "node scripts/deps-freshness-test.cjs && node scripts/runtime-account-test.cjs && node scripts/runtime-account-misattribution-test.cjs && node scripts/runtime-login-test.cjs && node scripts/claude-config-seed-test.cjs && node scripts/claude-config-isolation-test.cjs", "test:dm-continuity": "node scripts/dm-continuity-test.cjs", diff --git a/scripts/two-factor-test.cjs b/scripts/two-factor-test.cjs new file mode 100644 index 00000000..3f9993cd --- /dev/null +++ b/scripts/two-factor-test.cjs @@ -0,0 +1,205 @@ +#!/usr/bin/env node +/* Two-factor sign-in test — src/governance/{totp,qr,mfa}.ts + the /accept → /api/auth/2fa/verify flow. + * + * What this pins: + * - TOTP matches the RFC 6238 vectors, and a used code can't be replayed inside its own window. + * - The QR encoder matches `qrencode -l M` bit-for-bit (skipped where qrencode isn't installed). + * - Nothing usable at rest: the secret is sealed, recovery codes are hashes. + * - A magic link alone NO LONGER signs a 2FA member in: the session it mints is refused by every gate + * (/api/auth/me says mfaRequired, /api/state 401s) until a code swaps it for a FRESH full session. + * - Guessing is bounded (5 per pending session, then it's gone); a recovery code works exactly once. + * - Stripping the second factor needs a code (self) or the right role (admin reset). + * - The reminder cadence: every login (per session) and every N days (per member), only while off. + * Isolated home; no tmux, no ttyd, no network. + */ +const fs = require('fs'); +const os = require('os'); +const path = require('path'); +const { execFileSync } = require('child_process'); + +const ROOT = path.resolve(__dirname, '..'); +const HOME = fs.mkdtempSync(path.join(os.tmpdir(), 'aos-2fa-test-')); +process.env.AGENT_OS_HOME = HOME; +process.env.AGENT_OS_TENANT = 'testco'; +process.env.AOS_NO_TTYD = '1'; +delete process.env.AGENT_OS_SECRET_KEY; + +let pass = 0, fail = 0; +const assert = (c, name, d) => c ? (pass++, console.log(` \x1b[32m✓\x1b[0m ${name}`)) : (fail++, console.log(` \x1b[31m✗ ${name}\x1b[0m${d ? ' — ' + d : ''}`)); + +const { totpAt, totpStep, verifyTotp, base32Encode, base32Decode, normalizeRecoveryCode } = require(path.join(ROOT, 'dist/governance/totp.js')); +const { qrMatrix } = require(path.join(ROOT, 'dist/governance/qr.js')); +const { TenantRegistry } = require(path.join(ROOT, 'dist/tenant-registry.js')); +const { createHttpServer } = require(path.join(ROOT, 'dist/server.js')); + +console.log('\n\x1b[1m1) TOTP (RFC 6238 SHA-1 vectors, 6-digit tail)\x1b[0m'); +const RFC = base32Encode(Buffer.from('12345678901234567890')); +assert(RFC === 'GEZDGNBVGY3TQOJQGEZDGNBVGY3TQOJQ', 'base32 encodes the RFC seed'); +assert(base32Decode(RFC).toString() === '12345678901234567890', 'base32 round-trips'); +for (const [t, want] of [[59, '287082'], [1111111109, '081804'], [1234567890, '005924'], [2000000000, '279037']]) { + assert(totpAt(RFC, Math.floor(t / 30)) === want, `T=${t} → ${want}`); +} +const now = 1234567890 * 1000; +assert(verifyTotp(RFC, '005924', { nowMs: now }) === Math.floor(1234567890 / 30), 'verify returns the matched step'); +assert(verifyTotp(RFC, '005924', { nowMs: now + 30_000 }) != null, 'one step of clock drift is tolerated'); +assert(verifyTotp(RFC, '005924', { nowMs: now + 90_000 }) === null, 'three steps late is refused'); +assert(verifyTotp(RFC, '005924', { nowMs: now, afterStep: Math.floor(1234567890 / 30) }) === null, 'a code at/below last_step is a replay → refused'); +assert(verifyTotp(RFC, '12345', { nowMs: now }) === null && verifyTotp(RFC, 'abcdef', { nowMs: now }) === null, 'malformed codes are refused'); +assert(normalizeRecoveryCode(' ABCD efgh ') === 'abcd-efgh' && normalizeRecoveryCode('abcd-efg') === '', 'recovery codes normalise case/spacing, reject wrong length'); + +console.log('\n\x1b[1m2) QR encoder vs qrencode\x1b[0m'); +let haveQrencode = true; +try { execFileSync('qrencode', ['-V'], { stdio: 'ignore' }); } catch { haveQrencode = false; } +if (!haveQrencode) { + console.log(' (qrencode not installed — skipped)'); +} else { + const samples = ['hi', 'otpauth://totp/Agentric%20(Acme)%3Aowner%40example.com?secret=JBSWY3DPEHPK3PXPJBSWY3DPEHPK3PXP&issuer=Agentric%20(Acme)&algorithm=SHA1&digits=6&period=30', 'x'.repeat(300)]; + for (const t of samples) { + const ascii = execFileSync('qrencode', ['-l', 'M', '-8', '-m', '0', '-t', 'ASCII', t]).toString().replace(/\n$/, '').split('\n'); + const ref = ascii.map((r) => { const a = []; for (let i = 0; i < r.length; i += 2) a.push(r[i] === '#'); return a; }); + let hit = -1; + for (let m = 0; m < 8; m++) { + const mine = qrMatrix(t, m); + if (mine.length === ref.length && mine.every((row, y) => row.every((v, x) => v === ref[y][x]))) hit = m; + } + assert(hit >= 0, `${t.length}-byte payload (v${(ref.length - 17) / 4}) matches qrencode under mask ${hit}`); + } +} + +const registry = new TenantRegistry(ROOT, 0); +registry.bootAll(); +const { os: aos } = registry.get('testco'); +const owner = aos.team.listMembers().find((m) => m.role === 'owner'); +const mk = (email, role) => { + const { member } = aos.team.invite({ email, role }); + aos.db.prepare("UPDATE members SET status='active' WHERE id=?").run(member.id); + return aos.team.getMember(member.id); +}; +const alice = mk('alice@example.com', 'member'); +const adam = mk('adam@example.com', 'admin'); +const code = (secret, offset = 0) => totpAt(secret, totpStep() + offset); +const clearReplay = (id) => aos.db.prepare('UPDATE member_mfa SET last_step = NULL WHERE member_id = ?').run(id); + +console.log('\n\x1b[1m3) Enrolment + storage\x1b[0m'); +const setup = aos.mfa.beginSetup(alice.id, alice.email); +assert(/^otpauth:\/\/totp\/.*secret=[A-Z2-7]{32}/.test(setup.uri) && setup.qrSvg.startsWith(' { + const srv = createHttpServer(registry); + await new Promise((r) => srv.listen(0, '127.0.0.1', r)); + const port = srv.address().port; + const req = async (method, p, cookie, body) => { + const res = await fetch(`http://127.0.0.1:${port}${p}`, { method, redirect: 'manual', headers: { cookie: cookie || '', 'content-type': 'application/json' }, body: body ? JSON.stringify(body) : undefined }); + const setCookie = res.headers.get('set-cookie') || ''; + return { status: res.status, body: await res.json().catch(() => ({})), cookie: (setCookie.match(/aos_sid=[^;]*/) || [''])[0] }; + }; + const signInWithLink = async (email) => req('POST', `/accept?token=${aos.team.issueLoginLink(email).token}`, ''); + + // a member WITHOUT 2FA: link → full session, reminder due + const bob = mk('bob@example.com', 'member'); + const b1 = await signInWithLink(bob.email); + assert(b1.status === 302 && b1.cookie, 'no-2FA member: the link mints a cookie'); + const bMe = await req('GET', '/api/auth/me', b1.cookie); + assert(bMe.status === 200 && bMe.body.twoFactor && bMe.body.twoFactor.enabled === false, 'no-2FA member is fully signed in'); + assert(bMe.body.twoFactor.nag === true, 'reminder is due on a fresh login (default policy)'); + await req('POST', '/api/me/2fa/nag/dismiss', b1.cookie); + assert((await req('GET', '/api/auth/me', b1.cookie)).body.twoFactor.nag === false, '"Not now" quiets it for the rest of this login'); + const b2 = await signInWithLink(bob.email); + assert((await req('GET', '/api/auth/me', b2.cookie)).body.twoFactor.nag === true, 'every-login cadence: a NEW sign-in reminds again'); + + // a member WITH 2FA: link → pending session, refused everywhere + clearReplay(alice.id); + const a1 = await signInWithLink(alice.email); + assert(a1.status === 302 && a1.cookie, '2FA member: the link still sets a cookie…'); + const aMe = await req('GET', '/api/auth/me', a1.cookie); + assert(aMe.status === 401 && aMe.body.mfaRequired === true && aMe.body.email === alice.email, '…but /api/auth/me says a code is owed (still 401 for nginx auth_request)'); + assert((await req('GET', '/api/state', a1.cookie)).status === 401, 'a pending session reaches no member API'); + assert(!aos.team.presence().some((p) => p.memberId === alice.id), 'a pending session does not count as online'); + const wrong = await req('POST', '/api/auth/2fa/verify', a1.cookie, { code: code(setup.secret) === '111111' ? '222222' : '111111' }); + assert(wrong.status === 401 && wrong.body.remaining === 4, 'a wrong code is refused and counted'); + const ok = await req('POST', '/api/auth/2fa/verify', a1.cookie, { code: code(setup.secret) }); + assert(ok.status === 200 && ok.body.via === 'totp' && ok.cookie && ok.cookie !== a1.cookie, 'the right code → a FRESH full session id'); + assert((await req('GET', '/api/auth/me', ok.cookie)).status === 200, 'the new session is signed in'); + assert((await req('GET', '/api/auth/me', a1.cookie)).status === 401 && !(await req('GET', '/api/auth/me', a1.cookie)).body.mfaRequired, 'the pending session id is dead after use'); + assert((await req('GET', '/api/auth/me', ok.cookie)).body.twoFactor.nag === false, 'no reminder once 2FA is on'); + + // lockout + const a2 = await signInWithLink(alice.email); + let last; + for (let i = 0; i < 5; i++) last = await req('POST', '/api/auth/2fa/verify', a2.cookie, { code: '000000' === code(setup.secret) ? '999999' : '000000' }); + assert(last.status === 401 && last.body.expired === true, '5 wrong codes destroy the pending session'); + clearReplay(alice.id); + assert((await req('POST', '/api/auth/2fa/verify', a2.cookie, { code: code(setup.secret) })).status === 401, '…so even the right code no longer works on it'); + + // recovery code + const a3 = await signInWithLink(alice.email); + const rc = enabled.recoveryCodes[0]; + const viaRc = await req('POST', '/api/auth/2fa/verify', a3.cookie, { code: rc.toUpperCase() }); + assert(viaRc.status === 200 && viaRc.body.via === 'recovery' && viaRc.body.recoveryRemaining === 9, 'a recovery code signs in (case-insensitive) and is burned'); + const a4 = await signInWithLink(alice.email); + assert((await req('POST', '/api/auth/2fa/verify', a4.cookie, { code: rc })).status === 401, 'the same recovery code does not work twice'); + + // self-service: strip needs a code + const aliceCookie = viaRc.cookie; + assert((await req('POST', '/api/me/2fa/disable', aliceCookie, { code: '' })).status === 403, 'turning 2FA off without a code is refused (a hijacked cookie alone cannot strip it)'); + assert((await req('POST', '/api/me/2fa/setup', aliceCookie, {})).status === 403, 'moving to a new device without a code is refused'); + clearReplay(alice.id); + const regen = await req('POST', '/api/me/2fa/recovery', aliceCookie, { code: code(setup.secret) }); + assert(regen.status === 200 && regen.body.recoveryCodes.length === 10 && regen.body.recoveryRemaining === 10, 'regenerating recovery codes (with a code) replaces the set'); + assert(!aos.mfa.verify(alice.id, enabled.recoveryCodes[1]).ok, 'old recovery codes stop working after regeneration'); + + // admin reset rules + const adamCookie = `aos_sid=${aos.team.createSession(adam.id)}`; + const bobCookie = b2.cookie; + const ownerCookie = `aos_sid=${aos.team.createSession(owner.id)}`; + assert((await req('DELETE', `/api/team/${alice.id}/2fa`, bobCookie)).status === 403, 'a member cannot reset anyone'); + // give the owner 2FA so we can test admin→owner refusal + const os2 = aos.mfa.beginSetup(owner.id, owner.email); + aos.mfa.confirmSetup(owner.id, code(os2.secret)); + assert((await req('DELETE', `/api/team/${owner.id}/2fa`, adamCookie)).status === 403, 'an admin cannot reset an owner'); + assert((await req('DELETE', `/api/team/${owner.id}/2fa`, ownerCookie)).status === 400, 'nobody resets themselves via the admin route'); + const reset = await req('DELETE', `/api/team/${alice.id}/2fa`, adamCookie); + assert(reset.status === 200 && !aos.mfa.enabled(alice.id), 'an admin resets a member (lost phone)'); + const a5 = await signInWithLink(alice.email); + assert((await req('GET', '/api/auth/me', a5.cookie)).status === 200, 'after a reset, the link alone signs them in again'); + const team = await req('GET', '/api/team', ownerCookie); + assert(Array.isArray(team.body.twoFactor) && team.body.twoFactor.includes(owner.id) && !team.body.twoFactor.includes(alice.id), '/api/team reports who has 2FA on'); + + // policy: periodic cadence + assert((await req('PUT', '/api/settings/two-factor', bobCookie, { nagOnLogin: false })).status === 403, 'members cannot change the reminder policy'); + const pol = await req('PUT', '/api/settings/two-factor', ownerCookie, { nagOnLogin: false, nagEveryDays: 3 }); + assert(pol.status === 200 && pol.body.nagOnLogin === false && pol.body.nagEveryDays === 3, 'owner saves the policy'); + const carol = mk('carol@example.com', 'member'); + const c1 = await signInWithLink(carol.email); + assert((await req('GET', '/api/auth/me', c1.cookie)).body.twoFactor.nag === true, 'periodic only: never dismissed → due'); + await req('POST', '/api/me/2fa/nag/dismiss', c1.cookie); + const c2 = await signInWithLink(carol.email); + assert((await req('GET', '/api/auth/me', c2.cookie)).body.twoFactor.nag === false, 'periodic only: a new login inside the window stays quiet'); + aos.db.prepare('UPDATE member_mfa SET nag_dismissed_at = ? WHERE member_id = ?').run(Date.now() - 4 * 86400_000, carol.id); + assert((await req('GET', '/api/auth/me', c2.cookie)).body.twoFactor.nag === true, 'periodic: due again after N days, even mid-session'); + await req('PUT', '/api/settings/two-factor', ownerCookie, { nagOnLogin: false, nagEveryDays: 0 }); + assert((await req('GET', '/api/auth/me', c2.cookie)).body.twoFactor.nag === false, 'both cadences off → no reminder'); + const garbage = await req('PUT', '/api/settings/two-factor', ownerCookie, { nagOnLogin: 'yes', nagEveryDays: -5 }); + assert(garbage.body.nagOnLogin === true && garbage.body.nagEveryDays === 0, 'policy input is sanitised (bad bool → default, negative days → 0)'); + + // member removal clears the enrolment + const s3 = aos.mfa.beginSetup(bob.id, bob.email); aos.mfa.confirmSetup(bob.id, code(s3.secret)); + aos.team.removeMember(bob.id); + assert(!aos.db.prepare('SELECT 1 FROM member_mfa WHERE member_id = ?').get(bob.id), 'removing a member deletes their 2FA row'); + + srv.close(); + registry.stopAll(); + console.log(`\n${fail === 0 ? '\x1b[32m' : '\x1b[31m'}${pass} passed, ${fail} failed\x1b[0m`); + fs.rmSync(HOME, { recursive: true, force: true }); + process.exit(fail === 0 ? 0 : 1); +})().catch((e) => { console.error(e); registry.stopAll(); fs.rmSync(HOME, { recursive: true, force: true }); process.exit(1); }); diff --git a/src/cli.ts b/src/cli.ts index ffd41e9c..ed9812c8 100644 --- a/src/cli.ts +++ b/src/cli.ts @@ -6,6 +6,7 @@ * agent-os invite [role] create a magic-link for a teammate (role: admin|member) * agent-os login-link print a fresh login link for an existing member (recovery) * agent-os members list workspace members and their roles + * agent-os 2fa-reset turn off a member's two-factor (lost device — last-resort recovery) * agent-os demo run the scripted governance demo in the terminal * agent-os help show this help */ @@ -48,6 +49,7 @@ async function main(): Promise { case 'invite': case 'login-link': case 'members': + case '2fa-reset': team(cmd, rest); break; case 'tenant': @@ -157,7 +159,8 @@ function team(cmd: string, rest: string[]): void { if (cmd === 'members') { const members = os.team.listMembers(); if (!members.length) return console.log('no members yet — run `agent-os serve` once to seed the owner.'); - for (const m of members) console.log(` ${m.role.padEnd(6)} ${m.email.padEnd(28)} ${m.status.padEnd(8)} ${m.id}`); + const mfa = new Set(os.mfa.enabledMemberIds()); + for (const m of members) console.log(` ${m.role.padEnd(6)} ${m.email.padEnd(28)} ${m.status.padEnd(8)} ${(mfa.has(m.id) ? '2fa' : '-').padEnd(4)} ${m.id}`); return; } @@ -180,6 +183,21 @@ function team(cmd: string, rest: string[]): void { return; } + if (cmd === '2fa-reset') { + // The box-side escape hatch for an owner locked out by a lost authenticator AND lost recovery + // codes (nobody left in the console who can reset them). Shell access to the box = already trusted. + const m = os.team.getMemberByEmail(email); + if (!m) { + console.log(`no member with email ${email}.`); + process.exitCode = 1; + return; + } + os.mfa.disable(m.id); + os.audit.append({ ts: Date.now(), runId: '-', tenant: os.tenant, principal: 'cli', type: 'auth.2fa.reset', data: { member: m.id, email: m.email, via: 'cli' } }); + console.log(`two-factor turned off for ${m.email}. Sign in with a fresh link: agent-os login-link ${m.email}`); + return; + } + // login-link const issued = os.team.issueLoginLink(email); if (!issued) { @@ -351,6 +369,7 @@ function usage(): void { invite [role] mint a magic-link to invite a teammate (role: admin | member) login-link print a fresh login link for an existing member (recovery) members list workspace members and their roles + 2fa-reset turn off a member's two-factor sign-in (lost device + lost recovery codes) deps check the native tools sessions need (tmux/ttyd/claude/git) + their freshness deps update upgrade an npm-installed tool in place (e.g. deps update claude) install-deps install the missing native tools via the box's package manager diff --git a/src/governance/mfa.ts b/src/governance/mfa.ts new file mode 100644 index 00000000..405fee0a --- /dev/null +++ b/src/governance/mfa.ts @@ -0,0 +1,188 @@ +/** + * Member two-factor sign-in (TOTP authenticator app + single-use recovery codes). + * + * Login is magic-link, so the link IS the first factor — and a link can leak: it is DM'd to Slack/ + * Discord and written to server.log (the self-service recovery path), both places other people and + * processes can read. A second factor bound to a device the human holds means a leaked link alone no + * longer signs anyone in. + * + * Flow: a member with 2FA on who consumes a link gets a PENDING session (TeamStore, 10-minute TTL, + * refused by resolveSession) that only unlocks POST /api/auth/2fa/verify; a right code swaps it for a + * full session. Enrolment is two-step (setup → a pending secret; enable → proves the app has it), so a + * half-finished setup never locks anyone out. + * + * At rest: the TOTP secret is sealed under the vault master key and recovery codes are SHA-256 hashes — + * the DB is readable by an agent's shell running as the same OS user, so neither may sit in plaintext. + * + * The reminder ("nag") cadence for members who haven't turned it on is workspace policy + * (`SettingsStore.twoFactorPolicy`): on every new login, and/or every N days. + */ +import { Db, tokenAtRest } from '../state/db'; +import { seal, open } from '../edge/secret-crypto'; +import { generateTotpSecret, verifyTotp, otpauthUri, generateRecoveryCodes, normalizeRecoveryCode } from './totp'; +import { qrSvg } from './qr'; + +const PENDING_SETUP_TTL_MS = 15 * 60 * 1000; +const DAY_MS = 24 * 60 * 60 * 1000; + +export interface TwoFactorPolicy { + /** Remind a member without 2FA once per new login (each magic-link sign-in). */ + nagOnLogin: boolean; + /** …and again every N days while they still haven't (0 = no periodic reminder). */ + nagEveryDays: number; +} +export const DEFAULT_TWO_FACTOR_POLICY: TwoFactorPolicy = { nagOnLogin: true, nagEveryDays: 7 }; +export function sanitizeTwoFactorPolicy(raw: unknown): TwoFactorPolicy { + const r = (raw && typeof raw === 'object' ? raw : {}) as Record; + const days = Number(r.nagEveryDays); + return { + nagOnLogin: typeof r.nagOnLogin === 'boolean' ? r.nagOnLogin : DEFAULT_TWO_FACTOR_POLICY.nagOnLogin, + nagEveryDays: Number.isFinite(days) ? Math.max(0, Math.min(365, Math.floor(days))) : DEFAULT_TWO_FACTOR_POLICY.nagEveryDays, + }; +} + +export interface TwoFactorStatus { + enabled: boolean; + enabledAt?: number; + recoveryRemaining: number; +} + +interface MfaRow { + member_id: string; + secret: string | null; + enabled_at: number | null; + last_step: number | null; + recovery: string; + pending_secret: string | null; + pending_at: number | null; + nag_dismissed_at: number | null; +} + +export type VerifyResult = { ok: true; via: 'totp' | 'recovery'; recoveryRemaining: number } | { ok: false }; + +export class MfaStore { + constructor(private readonly db: Db, private readonly key: Buffer, private readonly issuer: () => string) {} + + private row(memberId: string): MfaRow | undefined { + return this.db.prepare('SELECT * FROM member_mfa WHERE member_id = ?').get(memberId); + } + private ensureRow(memberId: string): void { + this.db.prepare('INSERT OR IGNORE INTO member_mfa (member_id) VALUES (?)').run(memberId); + } + private openSecret(sealed: string | null): string | null { + if (!sealed) return null; + try { return open(this.key, sealed); } catch { return null; } + } + + enabled(memberId: string): boolean { + const r = this.row(memberId); + return !!(r?.enabled_at && r.secret); + } + status(memberId: string): TwoFactorStatus { + const r = this.row(memberId); + const on = !!(r?.enabled_at && r.secret); + return { enabled: on, enabledAt: on ? r!.enabled_at! : undefined, recoveryRemaining: on ? parseHashes(r!.recovery).length : 0 }; + } + /** Member ids with 2FA on — the Team page's adoption column. */ + enabledMemberIds(): string[] { + return this.db + .prepare('SELECT member_id FROM member_mfa WHERE enabled_at IS NOT NULL AND secret IS NOT NULL') + .all<{ member_id: string }>() + .map((r) => r.member_id); + } + + /** Step 1 of enrolment: a fresh secret held PENDING (the live one, if any, is untouched). */ + beginSetup(memberId: string, account: string): { secret: string; uri: string; qrSvg: string } { + this.ensureRow(memberId); + const secret = generateTotpSecret(); + this.db.prepare('UPDATE member_mfa SET pending_secret = ?, pending_at = ? WHERE member_id = ?').run(seal(this.key, secret), Date.now(), memberId); + const uri = otpauthUri(this.issuer(), account, secret); + return { secret, uri, qrSvg: qrSvg(uri) }; + } + + /** Step 2: the typed code proves the app holds the pending secret → 2FA on, fresh recovery codes + * returned ONCE (only their hashes are kept). Null when the code is wrong or setup expired. */ + confirmSetup(memberId: string, code: string): { recoveryCodes: string[] } | null { + const r = this.row(memberId); + if (!r?.pending_secret || !r.pending_at || Date.now() - r.pending_at > PENDING_SETUP_TTL_MS) return null; + const secret = this.openSecret(r.pending_secret); + if (!secret) return null; + const step = verifyTotp(secret, code); + if (step == null) return null; + const codes = generateRecoveryCodes(); + this.db + .prepare('UPDATE member_mfa SET secret = ?, enabled_at = ?, last_step = ?, recovery = ?, pending_secret = NULL, pending_at = NULL WHERE member_id = ?') + .run(r.pending_secret, Date.now(), step, JSON.stringify(codes.map(tokenAtRest)), memberId); + return { recoveryCodes: codes }; + } + + /** + * Check a sign-in code: a 6-digit TOTP (each step usable once) or a recovery code (burned on use). + * Never throws; a member without 2FA always fails. + */ + verify(memberId: string, code: string, nowMs = Date.now()): VerifyResult { + const r = this.row(memberId); + if (!r?.enabled_at || !r.secret) return { ok: false }; + const typed = String(code ?? '').trim(); + if (/^\d[\d\s]*$/.test(typed)) { + const secret = this.openSecret(r.secret); + if (!secret) return { ok: false }; + const step = verifyTotp(secret, typed, { nowMs, afterStep: r.last_step ?? undefined }); + if (step == null) return { ok: false }; + this.db.prepare('UPDATE member_mfa SET last_step = ? WHERE member_id = ?').run(step, memberId); + return { ok: true, via: 'totp', recoveryRemaining: parseHashes(r.recovery).length }; + } + const norm = normalizeRecoveryCode(typed); + if (!norm) return { ok: false }; + const hashes = parseHashes(r.recovery); + const h = tokenAtRest(norm); + if (!hashes.includes(h)) return { ok: false }; + const left = hashes.filter((x) => x !== h); + this.db.prepare('UPDATE member_mfa SET recovery = ? WHERE member_id = ?').run(JSON.stringify(left), memberId); + return { ok: true, via: 'recovery', recoveryRemaining: left.length }; + } + + /** Replace the recovery codes (caller has already verified a code). Returned once. */ + regenerateRecovery(memberId: string): string[] | null { + if (!this.enabled(memberId)) return null; + const codes = generateRecoveryCodes(); + this.db.prepare('UPDATE member_mfa SET recovery = ? WHERE member_id = ?').run(JSON.stringify(codes.map(tokenAtRest)), memberId); + return codes; + } + + /** Turn 2FA off (self, after a code; or an admin reset for a lost device). Keeps the nag clock. */ + disable(memberId: string): void { + this.db + .prepare("UPDATE member_mfa SET secret = NULL, enabled_at = NULL, last_step = NULL, recovery = '[]', pending_secret = NULL, pending_at = NULL WHERE member_id = ?") + .run(memberId); + } + + // ── the reminder ──────────────────────────────────────────────────────────────── + /** + * Should this member be reminded to turn on 2FA right now? Only while it's off. `sessionSeen` = this + * login already showed (and had dismissed) the reminder. Never dismissed → always due. + */ + nagDue(memberId: string, policy: TwoFactorPolicy, sessionSeen: boolean, nowMs = Date.now()): boolean { + if (this.enabled(memberId)) return false; + if (policy.nagOnLogin && !sessionSeen) return true; + if (policy.nagEveryDays > 0) { + const last = this.row(memberId)?.nag_dismissed_at; + if (!last) return true; + return nowMs - last >= policy.nagEveryDays * DAY_MS; + } + return false; + } + dismissNag(memberId: string, nowMs = Date.now()): void { + this.ensureRow(memberId); + this.db.prepare('UPDATE member_mfa SET nag_dismissed_at = ? WHERE member_id = ?').run(nowMs, memberId); + } +} + +function parseHashes(raw: string): string[] { + try { + const v = JSON.parse(raw || '[]'); + return Array.isArray(v) ? v.filter((x): x is string => typeof x === 'string') : []; + } catch { + return []; + } +} diff --git a/src/governance/qr.ts b/src/governance/qr.ts new file mode 100644 index 00000000..1b8c47f6 --- /dev/null +++ b/src/governance/qr.ts @@ -0,0 +1,241 @@ +/** + * A minimal QR Code encoder — byte mode, error-correction level M, versions 1–15 (≤ 412 bytes, far + * more than an `otpauth://` URI needs). Exists so the 2FA setup screen can show a scannable code + * without adding a dependency to the server or the console bundle. Algorithm follows ISO/IEC 18004 + * (structure after Project Nayuki's reference implementation, MIT). + * + * Verified against `qrencode -l M` in scripts/two-factor-test.cjs (the module matrix matches one of + * the eight masks bit-for-bit). + */ + +// Level M tables, indexed by version (index 0 unused). +const ECC_PER_BLOCK_M = [-1, 10, 16, 26, 18, 24, 16, 18, 22, 22, 26, 30, 22, 22, 24, 24]; +const NUM_BLOCKS_M = [-1, 1, 1, 1, 2, 2, 4, 4, 4, 5, 5, 5, 8, 9, 9, 10]; +const FORMAT_BITS_M = 0; +const MAX_VERSION = 15; + +function gfMul(x: number, y: number): number { + let z = 0; + for (let i = 7; i >= 0; i--) { + z = (z << 1) ^ ((z >>> 7) * 0x11d); + z ^= ((y >>> i) & 1) * x; + } + return z & 0xff; +} +function rsDivisor(degree: number): number[] { + const result = new Array(degree).fill(0); + result[degree - 1] = 1; + let root = 1; + for (let i = 0; i < degree; i++) { + for (let j = 0; j < result.length; j++) { + result[j] = gfMul(result[j], root); + if (j + 1 < result.length) result[j] ^= result[j + 1]; + } + root = gfMul(root, 0x02); + } + return result; +} +function rsRemainder(data: number[], divisor: number[]): number[] { + const result = new Array(divisor.length).fill(0); + for (const b of data) { + const factor = b ^ (result.shift() as number); + result.push(0); + divisor.forEach((coef, i) => { result[i] ^= gfMul(coef, factor); }); + } + return result; +} +function rawDataModules(ver: number): number { + let r = (16 * ver + 128) * ver + 64; + if (ver >= 2) { + const n = Math.floor(ver / 7) + 2; + r -= (25 * n - 10) * n - 55; + if (ver >= 7) r -= 36; + } + return r; +} +function dataCodewords(ver: number): number { + return Math.floor(rawDataModules(ver) / 8) - ECC_PER_BLOCK_M[ver] * NUM_BLOCKS_M[ver]; +} +function alignmentPositions(ver: number): number[] { + if (ver === 1) return []; + const size = ver * 4 + 17; + const n = Math.floor(ver / 7) + 2; + const step = Math.ceil((ver * 4 + 4) / (n * 2 - 2)) * 2; + const result = [6]; + for (let pos = size - 7; result.length < n; pos -= step) result.splice(1, 0, pos); + return result; +} + +/** Encode `text` (UTF-8) → a square boolean matrix, `true` = dark. Throws if it won't fit v15-M. */ +export function qrMatrix(text: string, forceMask?: number): boolean[][] { + const bytes = Array.from(Buffer.from(text, 'utf8')); + let ver = 1; + for (; ver <= MAX_VERSION; ver++) { + const ccBits = ver <= 9 ? 8 : 16; + if (4 + ccBits + bytes.length * 8 <= dataCodewords(ver) * 8) break; + } + if (ver > MAX_VERSION) throw new Error('qr: payload too long'); + const size = ver * 4 + 17; + + // ── data bits ── + const bits: number[] = []; + const push = (val: number, len: number) => { for (let i = len - 1; i >= 0; i--) bits.push((val >>> i) & 1); }; + push(0b0100, 4); + push(bytes.length, ver <= 9 ? 8 : 16); + for (const b of bytes) push(b, 8); + const capBits = dataCodewords(ver) * 8; + push(0, Math.min(4, capBits - bits.length)); + push(0, (8 - (bits.length % 8)) % 8); + for (let pad = 0xec; bits.length < capBits; pad ^= 0xec ^ 0x11) push(pad, 8); + const data: number[] = []; + for (let i = 0; i < bits.length; i += 8) data.push(parseInt(bits.slice(i, i + 8).join(''), 2)); + + // ── ECC + interleave ── + const numBlocks = NUM_BLOCKS_M[ver]; + const eccLen = ECC_PER_BLOCK_M[ver]; + const rawCodewords = Math.floor(rawDataModules(ver) / 8); + const numShort = numBlocks - (rawCodewords % numBlocks); + const shortLen = Math.floor(rawCodewords / numBlocks); + const divisor = rsDivisor(eccLen); + const blocks: number[][] = []; + for (let i = 0, k = 0; i < numBlocks; i++) { + const dat = data.slice(k, k + shortLen - eccLen + (i < numShort ? 0 : 1)); + k += dat.length; + const ecc = rsRemainder(dat, divisor); + if (i < numShort) dat.push(0); + blocks.push(dat.concat(ecc)); + } + const codewords: number[] = []; + for (let i = 0; i < blocks[0].length; i++) { + blocks.forEach((blk, j) => { if (i !== shortLen - eccLen || j >= numShort) codewords.push(blk[i]); }); + } + + // ── function patterns ── + const mod: boolean[][] = Array.from({ length: size }, () => new Array(size).fill(false)); + const fn: boolean[][] = Array.from({ length: size }, () => new Array(size).fill(false)); + const setF = (x: number, y: number, dark: boolean) => { mod[y][x] = dark; fn[y][x] = true; }; + for (let i = 0; i < size; i++) { setF(6, i, i % 2 === 0); setF(i, 6, i % 2 === 0); } + for (const [cx, cy] of [[3, 3], [size - 4, 3], [3, size - 4]]) { + for (let dy = -4; dy <= 4; dy++) for (let dx = -4; dx <= 4; dx++) { + const x = cx + dx, y = cy + dy; + if (x < 0 || x >= size || y < 0 || y >= size) continue; + const d = Math.max(Math.abs(dx), Math.abs(dy)); + setF(x, y, d !== 2 && d !== 4); + } + } + const al = alignmentPositions(ver); + al.forEach((ax, i) => al.forEach((ay, j) => { + if ((i === 0 && j === 0) || (i === 0 && j === al.length - 1) || (i === al.length - 1 && j === 0)) return; + for (let dy = -2; dy <= 2; dy++) for (let dx = -2; dx <= 2; dx++) setF(ax + dx, ay + dy, Math.max(Math.abs(dx), Math.abs(dy)) !== 1); + })); + const drawFormat = (mask: number) => { + const d = (FORMAT_BITS_M << 3) | mask; + let rem = d; + for (let i = 0; i < 10; i++) rem = (rem << 1) ^ ((rem >>> 9) * 0x537); + const fbits = ((d << 10) | rem) ^ 0x5412; + const bit = (i: number) => ((fbits >>> i) & 1) !== 0; + for (let i = 0; i <= 5; i++) setF(8, i, bit(i)); + setF(8, 7, bit(6)); setF(8, 8, bit(7)); setF(7, 8, bit(8)); + for (let i = 9; i < 15; i++) setF(14 - i, 8, bit(i)); + for (let i = 0; i < 8; i++) setF(size - 1 - i, 8, bit(i)); + for (let i = 8; i < 15; i++) setF(8, size - 15 + i, bit(i)); + setF(8, size - 8, true); + }; + drawFormat(0); + if (ver >= 7) { + let rem = ver; + for (let i = 0; i < 12; i++) rem = (rem << 1) ^ ((rem >>> 11) * 0x1f25); + const vbits = (ver << 12) | rem; + for (let i = 0; i < 18; i++) { + const b = ((vbits >>> i) & 1) !== 0; + const a = size - 11 + (i % 3), c = Math.floor(i / 3); + setF(a, c, b); setF(c, a, b); + } + } + + // ── codewords (zig-zag) ── + let bi = 0; + for (let right = size - 1; right >= 1; right -= 2) { + if (right === 6) right = 5; + for (let v = 0; v < size; v++) for (let j = 0; j < 2; j++) { + const x = right - j; + const up = ((right + 1) & 2) === 0; + const y = up ? size - 1 - v : v; + if (!fn[y][x] && bi < codewords.length * 8) { + mod[y][x] = ((codewords[bi >>> 3] >>> (7 - (bi & 7))) & 1) !== 0; + bi++; + } + } + } + + const applyMask = (mask: number) => { + for (let y = 0; y < size; y++) for (let x = 0; x < size; x++) { + if (fn[y][x]) continue; + let inv: boolean; + switch (mask) { + case 0: inv = (x + y) % 2 === 0; break; + case 1: inv = y % 2 === 0; break; + case 2: inv = x % 3 === 0; break; + case 3: inv = (x + y) % 3 === 0; break; + case 4: inv = (Math.floor(x / 3) + Math.floor(y / 2)) % 2 === 0; break; + case 5: inv = ((x * y) % 2) + ((x * y) % 3) === 0; break; + case 6: inv = (((x * y) % 2) + ((x * y) % 3)) % 2 === 0; break; + default: inv = (((x + y) % 2) + ((x * y) % 3)) % 2 === 0; + } + if (inv) mod[y][x] = !mod[y][x]; + } + }; + + let mask = forceMask ?? -1; + if (mask < 0) { + let best = Infinity; + for (let m = 0; m < 8; m++) { + applyMask(m); drawFormat(m); + const p = penalty(mod); + if (p < best) { best = p; mask = m; } + applyMask(m); // XOR undo + } + } + applyMask(mask); + drawFormat(mask); + return mod; +} + +/** ISO 18004 mask penalty (N1 runs, N2 blocks, N3 finder-likes, N4 balance) — picks a readable mask. */ +function penalty(m: boolean[][]): number { + const n = m.length; + let p = 0; + const line = (get: (i: number) => boolean) => { + let run = 1; + for (let i = 1; i <= n; i++) { + if (i < n && get(i) === get(i - 1)) run++; + else { if (run >= 5) p += 3 + (run - 5); run = 1; } + } + const pat = [true, false, true, true, true, false, true]; + for (let i = 0; i + 7 <= n; i++) { + if (!pat.every((v, k) => get(i + k) === v)) continue; + const lightBefore = i >= 4 && [1, 2, 3, 4].every((k) => !get(i - k)); + const lightAfter = i + 11 <= n && [7, 8, 9, 10].every((k) => !get(i + k)); + if (lightBefore || lightAfter) p += 40; + } + }; + for (let y = 0; y < n; y++) line((i) => m[y][i]); + for (let x = 0; x < n; x++) line((i) => m[i][x]); + let dark = 0; + for (let y = 0; y < n; y++) for (let x = 0; x < n; x++) { + if (m[y][x]) dark++; + if (x + 1 < n && y + 1 < n && m[y][x] === m[y][x + 1] && m[y][x] === m[y + 1][x] && m[y][x] === m[y + 1][x + 1]) p += 3; + } + const total = n * n; + p += (Math.ceil(Math.abs(dark * 20 - total * 10) / total) - 1) * 10; + return p; +} + +/** Render as a self-contained SVG (4-module quiet zone, crisp edges, black-on-white for scanners). */ +export function qrSvg(text: string, px = 200): string { + const m = qrMatrix(text); + const n = m.length + 8; + let d = ''; + m.forEach((row, y) => row.forEach((dark, x) => { if (dark) d += `M${x + 4} ${y + 4}h1v1h-1z`; })); + return ``; +} diff --git a/src/governance/settings.ts b/src/governance/settings.ts index 1079b680..9cfcd33d 100644 --- a/src/governance/settings.ts +++ b/src/governance/settings.ts @@ -9,6 +9,7 @@ * Backed by a key→value `settings` table (same constructor-takes-Db pattern as the other stores), * so adding more instance-level settings later is just another key. */ +import { TwoFactorPolicy, DEFAULT_TWO_FACTOR_POLICY, sanitizeTwoFactorPolicy } from './mfa'; import { Db } from '../state/db'; import { AgentProposalTrust, Branding, EnrichPattern, GithubInstallationRecord, MemoryConfig, Recommendation, RouterConfig, RuntimeTuning, sanitizeAgentProposalTrust, sanitizeBranding, sanitizeGithubInstallation, sanitizeRuntimeTuning } from '../types'; @@ -71,6 +72,7 @@ const SEMANTIC_GUARD_KEY = 'semantic_guard_enabled'; // master switch for the pr const FILE_WRITE_GUARD_KEY = 'file_write_guard'; const ENRICH_PATTERNS_KEY = 'enrich_patterns'; // operator regex→boolean-fact rules the enricher applies (JSON EnrichPattern[]) const BRANDING_KEY = 'ui_branding'; // per-tenant web-console accent colour + favicon badge (JSON Branding) +const TWO_FACTOR_KEY = 'two_factor_policy'; // reminder cadence for members without 2FA (JSON TwoFactorPolicy) const SETUP_KEY = 'setup_state'; // install-wizard state: dismissal + per-step "not now" (JSON SetupState) /** Numeric governance caps the policy's never-tier rules reference by name (e.g. `$moneyCapUsd`). @@ -687,6 +689,20 @@ export class SettingsStore { return this.branding(); } + // ── two-factor reminder policy ───────────────────────────────────────────────────── + // How insistently members WITHOUT 2FA are reminded to turn it on (src/governance/mfa.ts). Default: + // on every new login + every 7 days — sessions slide for an active user, so "every login" alone would + // nag someone who never signs out exactly once. + twoFactorPolicy(): TwoFactorPolicy { + const raw = this.getRow(TWO_FACTOR_KEY)?.value; + if (!raw) return { ...DEFAULT_TWO_FACTOR_POLICY }; + try { return sanitizeTwoFactorPolicy(JSON.parse(raw)); } catch { return { ...DEFAULT_TWO_FACTOR_POLICY }; } + } + setTwoFactorPolicy(p: unknown, by?: string): TwoFactorPolicy { + this.set(TWO_FACTOR_KEY, JSON.stringify(sanitizeTwoFactorPolicy(p)), by); + return this.twoFactorPolicy(); + } + // ── self-learning (Dreaming) cadence ───────────────────────────────────────────── // How often the periodic reflection pass runs, in hours. 0 / unset → off (manual "run now" only). /** Hours between automatic self-learning passes; 0 when disabled. */ diff --git a/src/governance/team.ts b/src/governance/team.ts index b882020e..d128587e 100644 --- a/src/governance/team.ts +++ b/src/governance/team.ts @@ -14,6 +14,8 @@ import { AgentAccess, Member, MemberIdentity, IdentityProvider, Role, ApprovalLe const INVITE_TTL_MS = 7 * 24 * 60 * 60 * 1000; // magic links valid for 7 days const SESSION_TTL_MS = 30 * 24 * 60 * 60 * 1000; // login cookie valid for 30 days +const MFA_PENDING_TTL_MS = 10 * 60 * 1000; // a half-signed-in session (link used, 2FA code not yet typed) +export const MFA_MAX_ATTEMPTS = 5; // wrong codes per pending session before it is destroyed const MEMBER_CONTEXT_MAX = 8000; // cap a member's personal context so it can't dominate every prompt interface MemberRow { @@ -250,6 +252,8 @@ export class TeamStore { } // Drop their external-account links so a freed id can be re-mapped to someone else cleanly. this.db.prepare('DELETE FROM member_identities WHERE member_id = ?').run(id); + // Their 2FA enrolment — a member re-invited under the same email starts fresh, not with a stale secret. + this.db.prepare('DELETE FROM member_mfa WHERE member_id = ?').run(id); this.db.prepare('DELETE FROM members WHERE id = ?').run(id); return { ok: true }; } @@ -314,8 +318,12 @@ export class TeamStore { return inv ? { email: inv.email, role: inv.role } : null; } - /** Consume a magic-link token: activate the member and mint a session. Null if invalid/expired. */ - acceptToken(tok: string): { member: Member; sid: string } | null { + /** + * Consume a magic-link token: activate the member and mint a session. Null if invalid/expired. + * When `mfaRequired(memberId)` says the member has two-factor on, the session is minted PENDING — + * resolveSession refuses it until completeMfa swaps it for a full one (see POST /api/auth/2fa/verify). + */ + acceptToken(tok: string, opts: { mfaRequired?: (memberId: string) => boolean } = {}): { member: Member; sid: string; mfaPending: boolean } | null { const now = Date.now(); const inv = this.db .prepare('SELECT * FROM invites WHERE token = ? AND accepted_at IS NULL AND expires_at > ?') @@ -325,22 +333,64 @@ export class TeamStore { const member = this.getMemberByEmail(inv.email); if (!member) return null; if (member.status !== 'active') this.db.prepare('UPDATE members SET status = ? WHERE id = ?').run('active', member.id); - return { member: { ...member, status: 'active' }, sid: this.createSession(member.id) }; + const mfaPending = !!opts.mfaRequired?.(member.id); + return { member: { ...member, status: 'active' }, sid: this.createSession(member.id, { mfaPending }), mfaPending }; } - createSession(memberId: string): string { + createSession(memberId: string, opts: { mfaPending?: boolean } = {}): string { const sid = token(); const now = Date.now(); + const pending = opts.mfaPending ? 1 : 0; this.db - .prepare('INSERT INTO auth_sessions (sid, member_id, created_at, expires_at) VALUES (?, ?, ?, ?)') - .run(tokenAtRest(sid), memberId, now, now + SESSION_TTL_MS); + .prepare('INSERT INTO auth_sessions (sid, member_id, created_at, expires_at, mfa_pending) VALUES (?, ?, ?, ?, ?)') + .run(tokenAtRest(sid), memberId, now, now + (pending ? MFA_PENDING_TTL_MS : SESSION_TTL_MS), pending); return sid; } + + // ── two-factor: the pending (half-signed-in) session ──────────────────────────── + /** The member behind a PENDING session (magic link used, 2FA code still owed), or undefined. */ + resolvePendingSession(sid: string): Member | undefined { + if (!sid) return undefined; + const row = this.db + .prepare('SELECT member_id FROM auth_sessions WHERE sid = ? AND mfa_pending = 1 AND expires_at > ?') + .get<{ member_id: string }>(tokenAtRest(sid), Date.now()); + return row ? this.getMember(row.member_id) : undefined; + } + /** Count one wrong code against a pending session; destroys it at MFA_MAX_ATTEMPTS. Returns guesses left. */ + recordMfaFailure(sid: string): number { + const at = tokenAtRest(sid); + this.db.prepare('UPDATE auth_sessions SET mfa_attempts = mfa_attempts + 1 WHERE sid = ? AND mfa_pending = 1').run(at); + const row = this.db.prepare('SELECT mfa_attempts FROM auth_sessions WHERE sid = ?').get<{ mfa_attempts: number }>(at); + const left = Math.max(0, MFA_MAX_ATTEMPTS - (row?.mfa_attempts ?? MFA_MAX_ATTEMPTS)); + if (left === 0) this.destroySession(sid); + return left; + } + /** The code checked out: retire the pending session and mint a FRESH full one (no id reuse across the + * privilege change). Returns the new sid, or null if the pending session is gone. */ + completeMfa(sid: string): string | null { + const m = this.resolvePendingSession(sid); + if (!m) return null; + this.destroySession(sid); + return this.createSession(m.id); + } + /** Sign a member out everywhere (2FA reset / disable by an admin). */ + destroyMemberSessions(memberId: string): void { + this.db.prepare('DELETE FROM auth_sessions WHERE member_id = ?').run(memberId); + } + /** Whether THIS login already showed (and had dismissed) the enable-2FA reminder. */ + sessionNagSeen(sid: string): boolean { + if (!sid) return false; + const row = this.db.prepare('SELECT nag_seen FROM auth_sessions WHERE sid = ?').get<{ nag_seen: number }>(tokenAtRest(sid)); + return !!row?.nag_seen; + } + markSessionNagSeen(sid: string): void { + if (sid) this.db.prepare('UPDATE auth_sessions SET nag_seen = 1 WHERE sid = ?').run(tokenAtRest(sid)); + } resolveSession(sid: string): Member | undefined { if (!sid) return undefined; const now = Date.now(); const row = this.db - .prepare('SELECT member_id, expires_at, last_seen_at FROM auth_sessions WHERE sid = ? AND expires_at > ?') + .prepare('SELECT member_id, expires_at, last_seen_at FROM auth_sessions WHERE sid = ? AND expires_at > ? AND mfa_pending = 0') .get<{ member_id: string; expires_at: number; last_seen_at: number | null }>(tokenAtRest(sid), now); if (!row) return undefined; // Sliding window: bump the 30-day expiry on activity so a daily-active user never hits the hard @@ -366,7 +416,7 @@ export class TeamStore { presence(): { memberId: string; lastSeenAt: number }[] { return this.db .prepare( - 'SELECT member_id AS memberId, MAX(last_seen_at) AS lastSeenAt FROM auth_sessions WHERE last_seen_at IS NOT NULL AND expires_at > ? GROUP BY member_id', + 'SELECT member_id AS memberId, MAX(last_seen_at) AS lastSeenAt FROM auth_sessions WHERE last_seen_at IS NOT NULL AND expires_at > ? AND mfa_pending = 0 GROUP BY member_id', ) .all<{ memberId: string; lastSeenAt: number }>(Date.now()); } diff --git a/src/governance/totp.ts b/src/governance/totp.ts new file mode 100644 index 00000000..3028b5d8 --- /dev/null +++ b/src/governance/totp.ts @@ -0,0 +1,105 @@ +/** + * TOTP (RFC 6238) + the base32 / recovery-code plumbing behind member two-factor sign-in. Zero + * dependencies — HMAC-SHA1 from node:crypto, the same 30-second / 6-digit profile every authenticator + * app (Google Authenticator, 1Password, Authy, …) defaults to. + */ +import { createHmac, randomBytes, timingSafeEqual } from 'crypto'; + +const B32 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'; +export const TOTP_STEP_SECONDS = 30; +export const TOTP_DIGITS = 6; + +export function base32Encode(buf: Buffer): string { + let bits = 0; + let value = 0; + let out = ''; + for (const byte of buf) { + value = (value << 8) | byte; + bits += 8; + while (bits >= 5) { + out += B32[(value >>> (bits - 5)) & 31]; + bits -= 5; + } + } + if (bits > 0) out += B32[(value << (5 - bits)) & 31]; + return out; +} + +export function base32Decode(s: string): Buffer { + const clean = s.toUpperCase().replace(/[\s=-]/g, ''); + let bits = 0; + let value = 0; + const out: number[] = []; + for (const ch of clean) { + const i = B32.indexOf(ch); + if (i < 0) throw new Error('invalid base32'); + value = (value << 5) | i; + bits += 5; + if (bits >= 8) { + out.push((value >>> (bits - 8)) & 255); + bits -= 8; + } + } + return Buffer.from(out); +} + +/** A fresh 160-bit shared secret, base32 (the form an authenticator app is given). */ +export function generateTotpSecret(): string { + return base32Encode(randomBytes(20)); +} + +/** The TOTP code for one 30-second step. */ +export function totpAt(secretB32: string, step: number): string { + const counter = Buffer.alloc(8); + counter.writeBigUInt64BE(BigInt(step)); + const h = createHmac('sha1', base32Decode(secretB32)).update(counter).digest(); + const off = h[h.length - 1] & 0xf; + const bin = ((h[off] & 0x7f) << 24) | (h[off + 1] << 16) | (h[off + 2] << 8) | h[off + 3]; + return String(bin % 10 ** TOTP_DIGITS).padStart(TOTP_DIGITS, '0'); +} + +export function totpStep(nowMs = Date.now()): number { + return Math.floor(nowMs / 1000 / TOTP_STEP_SECONDS); +} + +/** + * Check a typed code against the secret, tolerating ±`window` steps of clock drift. Returns the step + * that matched (the caller persists it and passes it back as `afterStep`, so a code observed over a + * shoulder can't be replayed inside its own 90-second validity) — or null. + */ +export function verifyTotp(secretB32: string, code: string, opts: { nowMs?: number; window?: number; afterStep?: number } = {}): number | null { + const typed = String(code ?? '').replace(/\s/g, ''); + if (!/^\d{6}$/.test(typed)) return null; + const now = totpStep(opts.nowMs); + const window = opts.window ?? 1; + for (let d = -window; d <= window; d++) { + const step = now + d; + if (opts.afterStep != null && step <= opts.afterStep) continue; + const expect = totpAt(secretB32, step); + if (timingSafeEqual(Buffer.from(expect), Buffer.from(typed))) return step; + } + return null; +} + +/** The `otpauth://` URI an authenticator app scans (as a QR code) or imports. */ +export function otpauthUri(issuer: string, account: string, secretB32: string): string { + const label = encodeURIComponent(`${issuer}:${account}`); + const q = new URLSearchParams({ secret: secretB32, issuer, algorithm: 'SHA1', digits: String(TOTP_DIGITS), period: String(TOTP_STEP_SECONDS) }); + return `otpauth://totp/${label}?${q.toString()}`; +} + +/** Ten single-use recovery codes, `xxxx-xxxx` (lowercase base32 — no 0/1/8/9 ambiguity to mistype). */ +export function generateRecoveryCodes(n = 10): string[] { + const out: string[] = []; + for (let i = 0; i < n; i++) { + const s = base32Encode(randomBytes(5)).toLowerCase(); // 40 bits → 8 chars + out.push(`${s.slice(0, 4)}-${s.slice(4, 8)}`); + } + return out; +} + +/** Canonical form of a typed recovery code: lowercase, dash/space-insensitive. */ +export function normalizeRecoveryCode(code: string): string { + const s = String(code ?? '').toLowerCase().replace(/[\s-]/g, ''); + return /^[a-z2-7]{8}$/.test(s) ? `${s.slice(0, 4)}-${s.slice(4)}` : ''; +} diff --git a/src/kernel.ts b/src/kernel.ts index 45fb2c0e..2df25a02 100644 --- a/src/kernel.ts +++ b/src/kernel.ts @@ -55,6 +55,7 @@ import { JsonPolicyEngine, PolicyDocument, PolicyRule, policyContextMismatch } f import { PolicyDrift, baselineDrift, dropRetiredRules, retiredRuleImpact } from './governance/policy-baseline'; import { EnvSecretsVault, SqliteSecretsVault } from './edge/secrets'; import { resolveMasterKey } from './edge/secret-crypto'; +import { MfaStore } from './governance/mfa'; import { seedBuiltinAgents } from './edge/agent-catalog'; import { HealthMonitor } from './observability/monitor'; import { MockAdapter, MockBehavior } from './runtime/mock-adapter'; @@ -88,6 +89,8 @@ export class AgentOS { readonly approvals: SqliteApprovals; /** The humans with access to this workspace, their roles, sessions and agent assignments. */ readonly team: TeamStore; + /** Member two-factor sign-in (TOTP + recovery codes) — src/governance/mfa.ts. */ + readonly mfa: MfaStore; /** Workspace-wide settings — incl. the Company context injected into every claude-code agent. */ readonly settings: SettingsStore; /** Global skills library — Claude Code Skills materialised into every claude-code agent at launch. */ @@ -158,7 +161,8 @@ export class AgentOS { this.paths = opts.paths; // The per-workspace DB backs everything user-facing. No paths (tests/demo) → ephemeral in-memory. this.db = openDb(opts.paths?.db ?? ':memory:'); - this.secrets = new SqliteSecretsVault(this.db, resolveMasterKey(opts.paths?.home), new EnvSecretsVault()); + const masterKey = resolveMasterKey(opts.paths?.home); + this.secrets = new SqliteSecretsVault(this.db, masterKey, new EnvSecretsVault()); this.connectors = new ConnectorStore(this.db); this.composioShares = new ComposioShareStore(this.db); this.composioIdentities = new ComposioIdentityStore(this.db); @@ -168,6 +172,7 @@ export class AgentOS { this.approvals = new SqliteApprovals(this.db); this.team = new TeamStore(this.db); this.settings = new SettingsStore(this.db); + this.mfa = new MfaStore(this.db, masterKey, () => `Agentric (${this.tenantName})`); this.skills = new SkillsStore(opts.paths?.skills, this.db, opts.paths?.bundledSkills); this.outputStyles = new OutputStylesStore(opts.paths?.outputStyles); this.artifacts = new ArtifactStore(this.db, opts.paths?.artifacts); diff --git a/src/server.ts b/src/server.ts index b206e55b..bbd26aca 100644 --- a/src/server.ts +++ b/src/server.ts @@ -736,15 +736,26 @@ async function handle(os: AgentOS, tm: TerminalManager, autos: Automations, req: return sendHtml(res, 200, acceptLandingHtml(peek.email, token, os.settings.branding().accentColor)); } if (method === 'POST' && p === '/accept') { - const accepted = os.team.acceptToken(url.searchParams.get('token') || ''); + // A member with two-factor on gets a PENDING session: the cookie is set, but resolveSession refuses + // it until POST /api/auth/2fa/verify swaps it for a full one — so a leaked link alone signs no one in. + const accepted = os.team.acceptToken(url.searchParams.get('token') || '', { mfaRequired: (id) => os.mfa.enabled(id) }); if (!accepted) return redirect(res, '/?login=invalid'); + if (accepted.mfaPending) { + os.audit.append({ ts: Date.now(), runId: '-', tenant: os.tenant, principal: accepted.member.email, type: 'auth.2fa.challenged', data: { member: accepted.member.id } }); + } res.writeHead(302, { location: '/', 'set-cookie': sessionCookie(accepted.sid) }); res.end(); return; } if (method === 'GET' && p === '/api/auth/me') { const m = memberFor(os, req); - if (!m) return sendJson(res, 401, { error: 'not authenticated' }); + if (!m) { + // Half signed in (link used, 2FA code owed): still a 401 — nginx's auth_request and every gate + // treat it as logged out — but the console learns to ask for the code instead of a new link. + const pending = os.team.resolvePendingSession(parseCookies(req)['aos_sid'] || ''); + if (pending) return sendJson(res, 401, { error: 'two-factor code required', mfaRequired: true, email: pending.email }); + return sendJson(res, 401, { error: 'not authenticated' }); + } // Sliding session: re-stamp the cookie on every app load (the SPA GETs this on mount) so an active // user's 30-day browser cookie never lapses. Pairs with the DB-side slide in TeamStore.resolveSession // — restamping the cookie alone would outlive the server row, sliding the row alone would outlive the @@ -755,7 +766,36 @@ async function handle(os: AgentOS, tm: TerminalManager, autos: Automations, req: res.writeHead(200, headers); // navPins + agentPins ride along on the auth payload (not a separate fetch) so the sidebar's pinned layout is // known at first shell paint — no flash of the default nav before a follow-up request lands. - res.end(JSON.stringify({ member: m, navPins: os.team.navPins(m.id), agentPins: os.team.agentPins(m.id) })); + // twoFactor.nag: whether to show the "turn on two-factor" reminder now (workspace cadence policy). + const twoFactor = { enabled: os.mfa.enabled(m.id), nag: os.mfa.nagDue(m.id, os.settings.twoFactorPolicy(), os.team.sessionNagSeen(sid || '')) }; + res.end(JSON.stringify({ member: m, navPins: os.team.navPins(m.id), agentPins: os.team.agentPins(m.id), twoFactor })); + return; + } + // Second step of a 2FA sign-in: the pending cookie + a 6-digit authenticator code (or a recovery + // code) → a fresh full session. Public by necessity (the caller isn't signed in yet); bounded by + // MFA_MAX_ATTEMPTS per pending session (then it's destroyed and a new link is needed) and per IP. + if (method === 'POST' && p === '/api/auth/2fa/verify') { + const sid = parseCookies(req)['aos_sid'] || ''; + const pending = os.team.resolvePendingSession(sid); + if (!pending) return sendJson(res, 401, { error: 'Sign-in expired — request a fresh link', expired: true }); + if (!allowMfaAttempt(req)) return sendJson(res, 429, { error: 'Too many attempts — wait a few minutes' }); + const b = await readBody(req); + const r = os.mfa.verify(pending.id, String(b.code ?? '')); + if (!r.ok) { + const remaining = os.team.recordMfaFailure(sid); + os.audit.append({ ts: Date.now(), runId: '-', tenant: os.tenant, principal: pending.email, type: 'auth.2fa.failed', data: { member: pending.id, remaining } }); + if (remaining === 0) { + res.writeHead(401, { 'content-type': 'application/json; charset=utf-8', 'set-cookie': clearCookie() }); + res.end(JSON.stringify({ error: 'Too many wrong codes — request a fresh sign-in link', expired: true })); + return; + } + return sendJson(res, 401, { error: 'That code is not right', remaining }); + } + const full = os.team.completeMfa(sid); + if (!full) return sendJson(res, 401, { error: 'Sign-in expired — request a fresh link', expired: true }); + os.audit.append({ ts: Date.now(), runId: '-', tenant: os.tenant, principal: pending.email, type: 'auth.2fa.verified', data: { member: pending.id, via: r.via, recoveryRemaining: r.recoveryRemaining } }); + res.writeHead(200, { 'content-type': 'application/json; charset=utf-8', 'set-cookie': sessionCookie(full) }); + res.end(JSON.stringify({ ok: true, via: r.via, recoveryRemaining: r.recoveryRemaining })); return; } // Per-tenant console branding (accent colour + favicon badge). PUBLIC + display-only (no secrets): @@ -3187,6 +3227,7 @@ async function handle(os: AgentOS, tm: TerminalManager, autos: Automations, req: members: os.team.listMembers(), assignments, identities: os.team.identitiesByMember(), // member id → external accounts (chat run-as join keys) + twoFactor: os.mfa.enabledMemberIds(), // member ids with 2FA on — the Team page's adoption badge agents, // owner sees ALL to assign access; admins never see owner-only agents }); } @@ -3210,6 +3251,20 @@ async function handle(os: AgentOS, tm: TerminalManager, autos: Automations, req: const updated = os.team.setRole(teamRole[1], role); return sendJson(res, updated ? 200 : 404, updated ?? { error: 'not found' }); } + // Reset a member's two-factor (lost phone + lost recovery codes). Admins reset members; only an owner + // resets an admin/owner; nobody resets themselves here (that's the code-gated self-service disable). + // Their next sign-in is link-only, and the reminder resumes. + const team2fa = p.match(/^\/api\/team\/([\w-]+)\/2fa$/); + if (method === 'DELETE' && team2fa) { + if (!isAdmin(me)) return sendJson(res, 403, { error: 'owner or admin required' }); + const target = os.team.getMember(team2fa[1]); + if (!target) return sendJson(res, 404, { error: 'not found' }); + if (target.id === me.id) return sendJson(res, 400, { error: 'turn off your own two-factor from your Profile' }); + if (target.role !== 'member' && me.role !== 'owner') return sendJson(res, 403, { error: 'only an owner can reset an admin or owner' }); + os.mfa.disable(target.id); + os.audit.append({ ts: Date.now(), runId: '-', tenant: os.tenant, principal: me.email, type: 'auth.2fa.reset', data: { member: target.id, email: target.email } }); + return sendJson(res, 200, { ok: true }); + } const teamLink = p.match(/^\/api\/team\/([\w-]+)\/login-link$/); if (method === 'POST' && teamLink) { if (!isAdmin(me)) return sendJson(res, 403, { error: 'owner or admin required' }); @@ -4354,6 +4409,51 @@ async function handle(os: AgentOS, tm: TerminalManager, autos: Automations, req: // This member's own notification preferences (which session events ping them, toasts/sound/DM). Per // person, not workspace-wide — every role reads/writes their OWN, so it's not admin-gated. + // ── two-factor sign-in, self-service (src/governance/mfa.ts) ── + // Enrolment is two-step so a half-finished setup never locks anyone out: setup mints a PENDING secret + // (QR + text), enable proves the app has it. Changing an enrolled device, turning it off and + // regenerating recovery codes all require a current code — a hijacked browser session alone can't + // strip the second factor. + if (method === 'GET' && p === '/api/me/2fa') { + return sendJson(res, 200, { ...os.mfa.status(me.id), policy: os.settings.twoFactorPolicy() }); + } + if (method === 'POST' && p === '/api/me/2fa/setup') { + const b = await readBody(req); + if (os.mfa.enabled(me.id) && !os.mfa.verify(me.id, String(b.code ?? '')).ok) { + return sendJson(res, 403, { error: 'Enter a current code from your authenticator to move it to a new device' }); + } + return sendJson(res, 200, os.mfa.beginSetup(me.id, me.email)); + } + if (method === 'POST' && p === '/api/me/2fa/enable') { + const b = await readBody(req); + const out = os.mfa.confirmSetup(me.id, String(b.code ?? '')); + if (!out) return sendJson(res, 400, { error: 'That code is not right (or setup expired — start again)' }); + os.team.markSessionNagSeen(parseCookies(req)['aos_sid'] || ''); + os.audit.append({ ts: Date.now(), runId: '-', tenant: os.tenant, principal: me.email, type: 'auth.2fa.enabled', data: { member: me.id } }); + return sendJson(res, 200, { ok: true, recoveryCodes: out.recoveryCodes, ...os.mfa.status(me.id) }); + } + if (method === 'POST' && p === '/api/me/2fa/disable') { + const b = await readBody(req); + if (!os.mfa.verify(me.id, String(b.code ?? '')).ok) return sendJson(res, 403, { error: 'That code is not right' }); + os.mfa.disable(me.id); + os.audit.append({ ts: Date.now(), runId: '-', tenant: os.tenant, principal: me.email, type: 'auth.2fa.disabled', data: { member: me.id, by: 'self' } }); + return sendJson(res, 200, { ok: true, ...os.mfa.status(me.id) }); + } + if (method === 'POST' && p === '/api/me/2fa/recovery') { + const b = await readBody(req); + if (!os.mfa.verify(me.id, String(b.code ?? '')).ok) return sendJson(res, 403, { error: 'That code is not right' }); + const codes = os.mfa.regenerateRecovery(me.id); + if (!codes) return sendJson(res, 400, { error: 'two-factor is not on' }); + os.audit.append({ ts: Date.now(), runId: '-', tenant: os.tenant, principal: me.email, type: 'auth.2fa.recovery.regenerated', data: { member: me.id } }); + return sendJson(res, 200, { ok: true, recoveryCodes: codes, ...os.mfa.status(me.id) }); + } + // "Not now" on the reminder: quiet for the rest of THIS login, and restarts the every-N-days clock. + if (method === 'POST' && p === '/api/me/2fa/nag/dismiss') { + os.mfa.dismissNag(me.id); + os.team.markSessionNagSeen(parseCookies(req)['aos_sid'] || ''); + return sendJson(res, 200, { ok: true }); + } + if (method === 'GET' && p === '/api/me/prefs') return sendJson(res, 200, os.team.notificationPrefs(me.id)); if (method === 'PUT' && p === '/api/me/prefs') { const b = await readBody(req); @@ -6291,6 +6391,20 @@ async function handle(os: AgentOS, tm: TerminalManager, autos: Automations, req: return sendJson(res, 200, { ok: true, ...saved }); } + // ── two-factor reminder cadence (owner/admin) ── + if (method === 'GET' && p === '/api/settings/two-factor') { + if (!isAdmin(me)) return sendJson(res, 403, { error: 'owner or admin required' }); + const members = os.team.listMembers().filter((m) => m.status === 'active'); + const on = new Set(os.mfa.enabledMemberIds()); + return sendJson(res, 200, { ...os.settings.twoFactorPolicy(), adoption: { enabled: members.filter((m) => on.has(m.id)).length, members: members.length } }); + } + if (method === 'PUT' && p === '/api/settings/two-factor') { + if (!isAdmin(me)) return sendJson(res, 403, { error: 'owner or admin required' }); + const saved = os.settings.setTwoFactorPolicy(await readBody(req), me.email); + os.audit.append({ ts: Date.now(), runId: '-', tenant: os.tenant, principal: me.email, type: 'settings.two_factor.updated', data: { ...saved } }); + return sendJson(res, 200, { ok: true, ...saved }); + } + // ── governance thresholds (the numeric caps the never-tier policy rules read) ── if (method === 'GET' && p === '/api/settings/governance') { if (!isAdmin(me)) return sendJson(res, 403, { error: 'owner or admin required' }); @@ -8601,6 +8715,20 @@ function allowLinkRequest(email: string, req: http.IncomingMessage): boolean { return ok; } +// Per-IP throttle on POST /api/auth/2fa/verify, on top of the per-pending-session attempt cap: bounds +// guessing spread across many pending sessions (each needs its own one-time magic link anyway). +const MFA_REQ_WINDOW_MS = 15 * 60 * 1000; +const MFA_REQ_MAX = 20; +const mfaReqHits = new Map(); +function allowMfaAttempt(req: http.IncomingMessage): boolean { + const ip = String(req.headers['x-forwarded-for'] || req.socket.remoteAddress || '').split(',')[0].trim() || '-'; + const now = Date.now(); + const hits = (mfaReqHits.get(ip) || []).filter((t) => now - t < MFA_REQ_WINDOW_MS); + hits.push(now); + mfaReqHits.set(ip, hits); + return hits.length <= MFA_REQ_MAX; +} + // ── per-member GitHub OAuth state (Phase 2 — docs/per-member-github-plan.md) ─── // The single-use CSRF `state` for the browser round-trip. Held in-process (the OAuth hop is seconds; // a restart mid-flow just makes the member retry). Keyed by the random state string, so it's safe diff --git a/src/state/db.ts b/src/state/db.ts index a72bc29f..0d68d47e 100644 --- a/src/state/db.ts +++ b/src/state/db.ts @@ -77,6 +77,21 @@ function migrate(db: Db): void { ); CREATE INDEX IF NOT EXISTS idx_member_identities_member ON member_identities (member_id); + -- Two-factor sign-in (TOTP) per member — src/governance/mfa.ts. secret/pending_secret are sealed + -- under the vault master key (never plaintext: an agent's shell can reach this file); recovery codes + -- are stored only as tokenAtRest hashes. last_step blocks replay of an already-used code. + -- nag_dismissed_at drives the "turn on 2FA" reminder cadence (Settings → Governance). + CREATE TABLE IF NOT EXISTS member_mfa ( + member_id TEXT PRIMARY KEY, + secret TEXT, + enabled_at INTEGER, + last_step INTEGER, + recovery TEXT NOT NULL DEFAULT '[]', + pending_secret TEXT, + pending_at INTEGER, + nag_dismissed_at INTEGER + ); + -- User-registered MCP connectors (Slack / GitHub / Composio / …) + the credentials they carry. -- stdio connectors use command/args/env; remote (http|sse) connectors use url/headers. CREATE TABLE IF NOT EXISTS connectors ( @@ -1060,6 +1075,14 @@ function migrate(db: Db): void { // TeamStore.resolveSession). A member is "online" when any of their sessions was seen recently. addColumn(db, 'auth_sessions', 'last_seen_at', 'INTEGER'); + // Two-factor sign-in. A magic link consumed by a member with 2FA on mints a PENDING session + // (mfa_pending=1, 10-minute TTL) that resolveSession refuses — it only unlocks POST /api/auth/2fa/verify, + // which swaps it for a full session. `mfa_attempts` caps guesses per pending session. `nag_seen` + // records that THIS login already showed the enable-2FA reminder (the "every login" cadence). + addColumn(db, 'auth_sessions', 'mfa_pending', 'INTEGER NOT NULL DEFAULT 0'); + addColumn(db, 'auth_sessions', 'mfa_attempts', 'INTEGER NOT NULL DEFAULT 0'); + addColumn(db, 'auth_sessions', 'nag_seen', 'INTEGER NOT NULL DEFAULT 0'); + // Per-session bearer secret for the loopback agent endpoints (0d). Older rows have none → the // server fails open for them (they predate the secret), but every new session mints one. addColumn(db, 'term_sessions', 'secret', 'TEXT'); diff --git a/web/src/App.tsx b/web/src/App.tsx index e0edb3d8..6479c071 100644 --- a/web/src/App.tsx +++ b/web/src/App.tsx @@ -21,6 +21,7 @@ import { ENTITY_ID_SRC, entityHref, isEntityId } from '@/lib/entity-links' import { createGithubApp } from '@/lib/github-app' import { ConnectorsPage, GithubMineCard } from '@/connectors' import { SetupPage, SetupBanner } from '@/setup' +import { TwoFactorChallenge, TwoFactorNag, TwoFactorSection, TwoFactorPolicyCard } from '@/two-factor' import { docPages } from '@/docs' import { Xterm } from './Xterm' @@ -1175,10 +1176,16 @@ function insightTarget(m: Msg): { route: Route; detail?: string; label: string } export default function App() { // undefined = checking, null = not logged in (show Login), Member = authed. const [me, setMe] = useState(undefined) + // Set when the magic link was used but a two-factor code is still owed (half signed in). + const [mfaEmail, setMfaEmail] = useState(null) const [accent, setAccent] = useState(undefined) - useEffect(() => { - api.me().then(setMe) + const loadMe = useCallback(() => { + api.meOrChallenge().then((r) => { + if (r && 'mfaRequired' in r) { setMfaEmail(r.email); setMe(null) } + else { setMfaEmail(null); setMe(r) } + }).catch(() => setMe(null)) }, []) + useEffect(() => { loadMe() }, [loadMe]) // Per-tenant branding — fetched from the PUBLIC endpoint so it themes the login screen + tab favicon // before any session exists. Runs once on mount, independent of auth. useEffect(() => { @@ -1206,6 +1213,7 @@ export default function App() { const termTmux = hash.match(/^#\/term\/([^?]+)/)?.[1] if (me === undefined) return
Loading…
+ if (me === null && mfaEmail !== null) return if (me === null) return if (viewArtifactId) return if (termTmux) return @@ -2150,6 +2158,7 @@ function Console({ me }: { me: Member }) {
{route !== 'setup' && !fullBleed && } + {route === 'setup' && nav('setup', id)} onDone={refreshState} />} {route === 'agents' && nav('agents', id)} run={runAgent} onEdit={openAgent} onNew={() => nav('new-agent')} onDelete={deleteAgent} onDuplicate={duplicateAgent} onRescan={rescanAgents} onImport={importAgent} onRefresh={refreshState} nav={nav} />} {route === 'new-agent' && { await refreshState(); nav('agents', id) }} />} @@ -9972,6 +9981,8 @@ function ProfilePage({ me, prefs, onSavePrefs, onProfileChange }: { + + {/* Notifications (moved off the bell) */}
Notifications
@@ -10041,6 +10052,12 @@ function TeamPage({ me, onProfileChange }: { me: Member; onProfileChange: () => if (!('error' in r && r.error)) setLinks((p) => ({ ...p, [id]: r.link })) } const changeRole = async (id: string, r: Role) => { await api.setRole(id, r); load() } + const resetTwoFactor = async (m: Member) => { + if (!window.confirm(`Turn off two-factor for ${m.email}? Their next sign-in will need only a link, and they'll be reminded to set it up again.`)) return + const r = await api.resetMemberTwoFactor(m.id) + if (r.error) return setHint('⚠ ' + r.error) + load() + } const remove = async (id: string) => { await api.removeMember(id); load() } if (!data) return
Loading…
@@ -10078,6 +10095,7 @@ function TeamPage({ me, onProfileChange }: { me: Member; onProfileChange: () => {m.name} {m.status === 'invited' && invited} + {data.twoFactor?.includes(m.id) && 2FA} {m.id === me.id && (you)}
{m.email}
@@ -10100,6 +10118,9 @@ function TeamPage({ me, onProfileChange }: { me: Member; onProfileChange: () => {isAdmin && ( )} + {isAdmin && m.id !== me.id && data.twoFactor?.includes(m.id) && (isOwner || m.role === 'member') && ( + + )} {isOwner && m.id !== me.id && ( + ) : ( + <> + + +
+ + +
+

Lost your phone and your recovery codes? Ask a workspace owner or admin to reset your two-factor from the Team page.

+ + )} + + + + ) +} + +// ── the reminder ──────────────────────────────────────────────────────────────── +/** Shown once per page load while /api/auth/me says it's due. "Set it up" goes to Profile; either button + * records the dismissal (quiet for the rest of this login, and the every-N-days clock restarts). */ +export function TwoFactorNag({ me }: { me: Member }) { + const [open, setOpen] = useState(!!me.twoFactor?.nag && !me.twoFactor?.enabled) + const dismiss = () => { setOpen(false); api.dismissTwoFactorNag().catch(() => {}) } + const setup = () => { + dismiss() + window.location.hash = '#/profile' + // The Profile page mounts after the hash change; give it a tick, then bring the section into view. + setTimeout(() => document.getElementById('pf-2fa')?.scrollIntoView({ behavior: 'smooth', block: 'start' }), 300) + } + return ( + { if (!o) dismiss() }}> + + + Turn on two-factor sign-in + + Your account can run agents that act on real systems. Right now anyone holding one of your sign-in links can get in — + links travel through chat DMs and server logs. A code from an authenticator app on your phone closes that gap. It takes about a minute. + + + + + + + + + ) +} + +// ── recovery codes ────────────────────────────────────────────────────────────── +function RecoveryCodes({ codes, email, onDone }: { codes: string[]; email: string; onDone: () => void }) { + const [copied, setCopied] = useState(false) + const text = `Agentric recovery codes for ${email}\nEach code signs you in once if you lose your authenticator.\n\n${codes.join('\n')}\n` + const copy = async () => { + try { await navigator.clipboard.writeText(text); setCopied(true); setTimeout(() => setCopied(false), 1500) } catch { /* non-secure context: the codes are on screen */ } + } + const download = () => { + const a = document.createElement('a') + a.href = URL.createObjectURL(new Blob([text], { type: 'text/plain' })) + a.download = 'agentric-recovery-codes.txt' + a.click() + URL.revokeObjectURL(a.href) + } + return ( +
+
Save your recovery codes
+

+ If you lose your phone, each of these signs you in once. This is the only time they're shown — store them in a password manager. +

+
+ {codes.map((c) => {c})} +
+
+ + + +
+
+ ) +} + +// ── Profile section ───────────────────────────────────────────────────────────── +type Action = 'recovery' | 'move' | 'disable' +const ACTION_LABEL: Record = { recovery: 'New recovery codes', move: 'Move to a new phone', disable: 'Turn off' } + +export function TwoFactorSection({ me }: { me: Member }) { + const [status, setStatus] = useState(null) + const [setup, setSetup] = useState<{ secret: string; qrSvg: string } | null>(null) + const [codes, setCodes] = useState(null) + const [action, setAction] = useState(null) + const [code, setCode] = useState('') + const [busy, setBusy] = useState(false) + const [error, setError] = useState() + const load = () => api.twoFactor().then((s) => { if (!s.error) setStatus(s) }).catch(() => {}) + useEffect(() => { load() }, []) + + const reset = () => { setCode(''); setError(undefined) } + const run = async (fn: () => Promise) => { + if (busy) return + setBusy(true); setError(undefined) + try { await fn() } catch { setError('Could not reach the server — try again.') } finally { setBusy(false) } + } + const begin = (current?: string) => run(async () => { + const r = await api.twoFactorSetup(current) + if (r.error || !r.secret || !r.qrSvg) return setError(r.error || 'Could not start setup.') + setSetup({ secret: r.secret, qrSvg: r.qrSvg }); setAction(null); setCode('') + }) + const enable = () => run(async () => { + const r = await api.twoFactorEnable(code) + if (!r.ok) return setError(r.error || 'That code is not right.') + setSetup(null); setCode(''); setCodes(r.recoveryCodes ?? null); setStatus(r) + }) + const confirmAction = () => run(async () => { + if (action === 'move') return begin(code) + if (action === 'disable') { + const r = await api.twoFactorDisable(code) + if (!r.ok) return setError(r.error || 'That code is not right.') + setStatus(r); setAction(null); setCode('') + return + } + const r = await api.twoFactorRecovery(code) + if (!r.ok) return setError(r.error || 'That code is not right.') + setStatus(r); setCodes(r.recoveryCodes ?? null); setAction(null); setCode('') + }) + + const grouped = setup?.secret.match(/.{1,4}/g)?.join(' ') ?? '' + return ( +
+
Two-factor sign-in
+

+ After you open a sign-in link, also ask for a code from an authenticator app (1Password, Google Authenticator, Authy, …) — + so a forwarded or leaked link alone can't get into your account. +

+ + {codes ? ( + setCodes(null)} /> + ) : setup ? ( + + +
1. Scan this with your authenticator app
+
+ {/* Server-rendered SVG (src/governance/qr.ts) — no user content in it but the otpauth URI. */} +
+
+
Can't scan? Enter this key instead:
+
{grouped}
+
Time-based · 6 digits · 30 seconds
+
+
+
2. Enter the 6-digit code it shows
+
+ + +
+ + + + ) : !status ? ( +
Loading…
+ ) : status.enabled ? ( + + +
+ + On + since {fmtDate(status.enabledAt)} · {status.recoveryRemaining} recovery {status.recoveryRemaining === 1 ? 'code' : 'codes'} left +
+ {status.recoveryRemaining <= 2 &&
You're running low on recovery codes — make new ones.
} + {action ? ( +
+
{ACTION_LABEL[action]}: confirm with a current code from your authenticator (or a recovery code).
+
+ setCode(e.target.value)} onKeyDown={(e) => e.key === 'Enter' && confirmAction()} placeholder="123456" className="font-mono tracking-widest" autoComplete="one-time-code" /> + + +
+
+ ) : ( +
+ {(['recovery', 'move', 'disable'] as Action[]).map((a) => ( + + ))} +
+ )} +
+
+ ) : ( + + + + Off — your sign-in link is the only thing protecting this account. + + + + )} +
+ ) +} + +// ── Settings → Governance ─────────────────────────────────────────────────────── +export function TwoFactorPolicyCard({ me }: { me: Member }) { + const [p, setP] = useState(null) + const [saved, setSaved] = useState(null) + const [adoption, setAdoption] = useState<{ enabled: number; members: number }>() + const [msg, setMsg] = useState() + useEffect(() => { + api.twoFactorPolicy().then((r) => { + if (r.error) return + const pol = { nagOnLogin: r.nagOnLogin, nagEveryDays: r.nagEveryDays } + setP(pol); setSaved(pol); setAdoption(r.adoption) + }).catch(() => {}) + }, []) + if (me.role !== 'owner' && me.role !== 'admin') return null + if (!p) return null + const dirty = JSON.stringify(p) !== JSON.stringify(saved) + const save = async () => { + const r = await api.saveTwoFactorPolicy(p) + if (r.error) return setMsg(r.error) + const pol = { nagOnLogin: r.nagOnLogin, nagEveryDays: r.nagEveryDays } + setP(pol); setSaved(pol); setMsg('Saved'); setTimeout(() => setMsg(undefined), 2000) + } + return ( + + +
+

Two-factor reminders

+ {adoption && {adoption.enabled} of {adoption.members} active members have two-factor on} +
+

+ Members without two-factor sign-in get a reminder to turn it on. Each member sets it up from their Profile; an owner or admin can + reset someone who lost their phone from the Team page. +

+ + +

Sign-ins last 30 days and renew while someone stays active, so a periodic reminder is what reaches people who never sign out.

+
+ + {msg && {msg}} +
+
+
+ ) +}